Re: Builders/Factories and Inheritance.
On Aug 16, 1:58 pm, Daniel Pitts
<newsgroup.spamfil...@virtualinfinity.net> wrote:
I was just thinking about the Builder pattern (because of Roedy's recent
post).
It seems to me that Builders are a special type of Factory, and in
general Factories /tend/ to prevent the client from specifying the
actual implementation to use. I was thinking about ways to give the
client some control, while allowing the builder to do its job as-well.
I was thinking of a double-indirection factory (bad name maybe?)
class Foo { public Foo(int bar, Baz baz) {} }
interface FooFactory {
Foo createFoo(int bar, Baz baz);
}
class FooBuilder {
private final FooFactory factory;
public FooBuilder(FooFactory factory) {this.factory = factory;}
public FooBuilder() {this.factory = new DefaultFooFactory();}
// builder methods etc...
public Foo toFoo() { return factory.createFoo(getBar(), getBaz());=
}
}
This gives the client the ability to create a subclass foo builder, and
utilize the foo builder:
class SpecialFoo extends Foo {
SpecialFoo(int bar, Baz baz, Zip zip) {
super(bar, baz);
}
}
class SpecialFooBuilder implements FooFactory {
// builder methods to get "zip"
Foo createFoo(int bar, Baz baz) {
return new SpecialFoo(bar, baz, zip);
}
}
class Client {
public void stuff() {
SpecialFooBuilder specialFooBuilder = new SpecialFooBuil=
der();
FooBuilder fooBuilder = new FooBuilder(specialFooBuilder=
);
configureSpecialFooBuilder(specialFooBuilder);
configureFooBuilder(fooBuilder);
fooBuilder.toFoo().doFooThing();
}
}
This seems like it *might* be an anti-pattern, but I'm not sure. Have
any of you had to implement this design? How did it work out? I don't
actually have any real code for this, since I'm just thinking "out loud"
at the moment.
Without context it's hard to say if that structure is good or bad, but
it *is* awfully verbose. It'd read somewhat better in a language with
lambdas, I think, and as written it'd be easier to do most of the
connections using spring or something like it rather than having the
client directly responsible for creating the factories and builders.
I can see something like this (separating the actual creation logic
from configuration logic) for writing parsers, where the parser
interacts with a builder for building up the final object to
construct, but the builder delegates to a factory-as-strategy for the
final creation step.
-o