Wenn man mit dem Builder Pattern arbeitet, gelangt man an den Punkt, an dem man komplexe Objekte aufbauen muss. Nehmen wir nun an, dass wir ein Auto erzeugen möchten. Dieses besteht aus den Attributen Motor, Maschine und einer Anzahl Räder. Hierfür verwenden wir nun das nachfolgende Klassenmodell.
1public class Car {
2 private Engine engine;
3 private List<Wheel> wheelList;
4}
5
6public class Engine {
7 private int power;
8 private int type;
9}
10
11public class Wheel {
12 private int size;
13 private int type;
14 private int colour;
15}
Nun kann man für jede Klasse einen entsprechenden Builder generieren lassen. Wenn man sich dabei an das Basispattern hält, sieht das für die Klasse Wheel in etwa so aus:
1public static final class Builder {
2 private int size;
3 private int type;
4 private int colour;
5
6 private Builder() {}
7
8 public Builder withSize(int size) {
9 this.size = size;
10 return this;
11 }
12
13 public Builder withType(int type) {
14 this.type = type;
15 return this;
16 }
17
18 public Builder withColour(int colour) {
19 this.colour = colour;
20 return this;
21 }
22
23 public Wheel build() {
24 return new Wheel(this);
25 }
26 }
Der Builder ist als inner static class realisiert und vollzieht demnach die Änderungen in der Klasse Wheel nach, damit nur noch über den Builder gegangen werden kann, um eine Instanz zu erzeugen. Natürlich habe ich hierbei die Möglichkeiten via Reflection ausgelassen.
1public class Wheel {
2
3 private int size;
4 private int type;
5 private int colour;
6
7 private Wheel(Builder builder) {
8 setSize(builder.size);
9 setType(builder.type);
10 setColour(builder.colour);
11 }
12
13 public static Builder newBuilder() {
14 return new Builder();
15 }
16
17 public static Builder newBuilder(Wheel copy) {
18 Builder builder = new Builder();
19 builder.size = copy.size;
20 builder.type = copy.type;
21 builder.colour = copy.colour;
22 return builder;
23 }
24...}
Wie aber sieht es nun aus, wenn man eine Instanz der Klasse Car erzeugen möchte? Hier kommen wir zu dem Punkt, dass wir die Instanz der Klasse Wheel der Instanz der Klasse Car hinzufügen wollen.
1public class Main {
2 public static void main(String[] args) {
3
4 Engine engine = Engine.newBuilder().withPower(100).withType(5).build();
5
6 Wheel wheel1 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
7 Wheel wheel2 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
8 Wheel wheel3 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
9
10 List<Wheel> wheels = new ArrayList<>();
11 wheels.add(wheel1);
12 wheels.add(wheel2);
13 wheels.add(wheel3);
14
15 Car car = Car.newBuilder()
16 .withEngine(engine)
17 .withWheelList(wheels)
18 .build();
19
20 System.out.println("car = " + car);
21 }
22}
Dieser Quelltext ist nicht sonderlich schön und auf keinen Fall kompakt. Wie also kann man hier das Builder Pattern anpassen, damit man auf der einen Seite möglichst wenig von dem Builder selbst von Hand schreiben muss und auf der anderen Seite bei der Verwendung mehr Komfort bekommt?
WheelListBuilder
Gehen wir zuerst einen kleinen Umweg. Um zum Beispiel sicherzustellen, dass man einem Auto nur vier Räder hinzufügen kann, kann man z. B. einen WheelListBuilder erzeugen. Hier kann man z. B. in der Methode build() überprüfen, ob vier Instanzen der Klasse Wheel vorhanden sind.
1public class WheelListBuilder {
2
3 public static WheelListBuilder newBuilder(){
4 return new WheelListBuilder();
5 }
6
7 private WheelListBuilder() {}
8
9 private List<Wheel> wheelList;
10
11 public WheelListBuilder withNewList(){
12 this.wheelList = new ArrayList<>();
13 return this;
14 }
15 public WheelListBuilder withList(List wheelList){
16 this.wheelList = wheelList;
17 return this;
18 }
19
20 public WheelListBuilder addWheel(Wheel wheel){
21 this.wheelList.add(wheel);
22 return this;
23 }
24
25 public List<Wheel> build(){
26 //test if there are 4 instances....
27 return this.wheelList;
28 }
29
30}
Nun sieht unser Beispiel von vorhin wie folgt aus:
1public class Main {
2 public static void main(String[] args) {
3
4 Engine engine = Engine.newBuilder().withPower(100).withType(5).build();
5
6 Wheel wheel1 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
7 Wheel wheel2 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
8 Wheel wheel3 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
9
10// List<Wheel> wheels = new ArrayList<>();
11// wheels.add(wheel1);
12// wheels.add(wheel2);
13// wheels.add(wheel3);
14
15 List<Wheel> wheelList = WheelListBuilder.newBuilder()
16 .withNewList()
17 .addWheel(wheel1)
18 .addWheel(wheel2)
19 .addWheel(wheel3)
20 .build();//more robust if you add tests at build()
21
22 Car car = Car.newBuilder()
23 .withEngine(engine)
24 .withWheelList(wheelList)
25 .build();
26
27 System.out.println("car = " + car);
28 }
29}
Als nächstes verbinden wir den Builder der Klasse Wheel und die Klasse WheelListBuilder. Das Ziel ist es, ein Fluent API zu erhalten, damit wir nicht die Instanzen der Klasse Wheel einzeln erzeugen und dann diese mit der Methode addWheel(Wheel w) dem WheelListBuilder hinzufügen müssen. Es soll dann für den Entwickler in der Verwendung wie folgt aussehen:
1List<Wheel> wheels = wheelListBuilder 2 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 3 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 4 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 5 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 6 .build();
Was hier also passiert, ist folgendes: Sobald die Methode addWheel() aufgerufen wird, soll eine neue Instanz der Klasse WheelBuilder zurückgegeben werden. Die Methode addWheelToList() erzeugt die Instanz der Klasse Wheel und fügt sie der List hinzu.
Um das zu erreichen, muss man die beiden beteiligten Builder modifizieren. Auf der Seite des WheelBuilder kommt die Methode addWheelToList() hinzu. Diese fügt die Instanz der Klasse Wheel dem WheelListBuilder hinzu und liefert die Instanz der Klasse WheelListBuilder zurück.
1private WheelListBuilder wheelListBuilder;
2
3public WheelListBuilder addWheelToList(){
4 this.wheelListBuilder.addWheel(this.build());
5 return this.wheelListBuilder;
6}
Auf der Seite der Klasse WheelListBuilder wird lediglich die Methode addWheel() hinzugefügt.
1public Wheel.Builder addWheel() {
2 Wheel.Builder builder = Wheel.newBuilder();
3 builder.withWheelListBuilder(this);
4 return builder;
5 }
Wenn wir nun dieses auf die anderen Builder übertragen, kommen wir zu einem recht ansehnlichen Ergebnis:
1Car car = Car.newBuilder() 2 .addEngine().withPower(100).withType(5).done() 3 .addWheels() 4 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 5 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 6 .addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 7 .done() 8 .build();
NestedBuilder
Bisher wurden die Builder von Hand einzeln modifiziert. Dieses kann man aber recht einfach generisch implementieren. Es handelt sich lediglich um einen Baum von Buildern. Jeder Builder kennt demnach seine Kinder und seinen Vater. Die dafür notwendigen Implementierungen sind in der Klasse NestedBuilder zu finden. Hierbei wird angenommen, dass die Methoden zum Setzen von Attributen immer mit with beginnen. Da dies aber bei den meisten Generatoren für Builder so zu sein scheint, ist hier keine manuelle Anpassung notwendig.
1public abstract class NestedBuilder<T, V> {
2 /**
3 * To get the parent builder
4 *
5 * @return T the instance of the parent builder
6 */
7 public T done() {
8 Class<?> parentClass = parent.getClass();
9 try {
10 V build = this.build();
11 String methodname = "with" + build.getClass().getSimpleName();
12 Method method = parentClass.getDeclaredMethod(methodname, build.getClass());
13 method.invoke(parent, build);
14 } catch (NoSuchMethodException
15 | IllegalAccessException
16 | InvocationTargetException e) {
17 e.printStackTrace();
18 }
19 return parent;
20 }
21
22 public abstract V build();
23
24 protected T parent;
25
26 /**
27 * @param parent
28 * @return
29 */
30 public <P extends NestedBuilder<T, V>> P withParentBuilder(T parent) {
31 this.parent = parent;
32 return (P) this;
33 }
34}
Nun können einem Parent die spezifischen Methoden für die Verbindungen zu den Kindern hinzugefügt werden. Ein Ableiten von NestedBuilder ist nicht erforderlich.
1public class Parent {
2
3 private KidA kidA;
4 private KidB kidB;
5
6 //snipp.....
7
8 public static final class Builder {
9 private KidA kidA;
10 private KidB kidB;
11
12 private Builder() {
13 }
14
15 public Builder withKidA(KidA kidA) {
16 this.kidA = kidA;
17 return this;
18 }
19
20 public Builder withKidB(KidB kidB) {
21 this.kidB = kidB;
22 return this;
23 }
24
25 // to add manually
26 private KidA.Builder builderKidA = KidA.newBuilder().withParentBuilder(this);
27 private KidB.Builder builderKidB = KidB.newBuilder().withParentBuilder(this);
28
29 public KidA.Builder addKidA() {
30 return this.builderKidA;
31 }
32
33 public KidB.Builder addKidB() {
34 return this.builderKidB;
35 }
36 //---------
37
38 public Parent build() {
39 return new Parent(this);
40 }
41 }
42}
Und bei den Kindern sieht es wie folgt aus: Hier muss lediglich von NestedBuilder abgeleitet werden.
1public class KidA {
2
3 private String note;
4
5 private KidA(Builder builder) {
6 note = builder.note;
7 }
8
9 public static Builder newBuilder() {
10 return new Builder();
11 }
12
13 public static final class Builder extends NestedBuilder<Parent.Builder, KidA> {
14 private String note;
15
16 private Builder() {
17 }
18
19 public Builder withNote(String note) {
20 this.note = note;
21 return this;
22 }
23
24 public KidA build() {
25 return new KidA(this);
26 }
27
28 }
29}
Die Verwendung ist dann, wie in dem vorherigen Beispiel gezeigt, sehr kompakt.
1public class Main {
2 public static void main(String[] args) {
3 Parent build = Parent.newBuilder()
4 .addKidA().withNote("A").done()
5 .addKidB().withNote("B").done()
6 .build();
7 System.out.println("build = " + build);
8 }
9}
Fazit
Natürlich ist auch eine beliebige Kombination möglich. Das bedeutet, dass ein Proxy Vater und Kind gleichzeitig sein kann. Dem Aufbau komplexer Strukturen steht nun nichts mehr im Wege.
1public class Main {
2 public static void main(String[] args) {
3 Parent build = Parent.newBuilder()
4 .addKidA().withNote("A")
5 .addKidB().withNote("B").done()
6 .done()
7 .build();
8 System.out.println("build = " + build);
9 }
10}
War dieser Beitrag hilfreich?
Weitere Beiträge
von Sven Ruppert
16.11.2015 Dein Job bei codecentric?
Jobs
Agile Developer und Consultant (w/d/m)
Alle Standorte
Weitere Artikel in diesem Themenbereich
Entdecke spannende weiterführende Themen und lass dich von der codecentric Welt inspirieren.
Gemeinsam bessere Projekte umsetzen.
Wir helfen deinem Unternehmen.
Du stehst vor einer großen IT-Herausforderung? Wir sorgen für eine maßgeschneiderte Unterstützung. Informiere dich jetzt.
Hilf uns, noch besser zu werden.
Wir sind immer auf der Suche nach neuen Talenten. Auch für dich ist die passende Stelle dabei.
Blog-Autor*in
Sven Ruppert
Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.
Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.