Was ist das Designmuster Factory Builder?

Das Factory Builder-Muster, oder besser gesagt Factory Method in Kombination mit Builder, ist eine Kombination aus zwei Mustern, die die Erstellung komplexer Objekte verbessert.

Factory Method definiert eine Schnittstelle zur Objekterstellung, lässt aber Unterklassen entscheiden, welche Klasse instanziiert wird. Sie delegiert die Verantwortung für die Objekterstellung an die Unterklassen.

Builder trennt die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass derselbe Bauprozess unterschiedliche Darstellungen erzeugen kann. Es ermöglicht, ein Objekt schrittweise zu erstellen, indem eine Kette von Methodenaufrufen verwendet wird.

Die Kombination dieser Muster tritt am häufigsten in Szenarien auf, in denen mehrere Varianten eines komplexen Objekts erstellt werden müssen. Factory Method bestimmt welchen Builder-Typ verwendet werden soll, und der Builder kümmert sich dann um wie das Objekt mit verschiedenen Konfigurationen erstellt wird.

Beispiel für die Verwendung: Wenn Sie eine Hierarchie von Objekten haben, die eine komplexe Initialisierung erfordern, und diese Objekte mit unterschiedlichen Konfigurationen erstellen möchten.

Typische Interaktionsstruktur:

• Fabrik: Hat eine Methode, die eine Instanz eines bestimmten Builders basierend auf Eingabeparametern oder seinem Typ zurückgibt.
• Builder: Hat Methoden, um Schritt für Schritt die Parameter des komplexen Objekts zu konfigurieren, und eine finale Methode build(), die das fertige Objekt zurückgibt.
• Produkt: Das komplexe Objekt, das vom Builder erstellt wird.

Vorteile:

• Verbesserte Lesbarkeit und Wartbarkeit des Codes bei der Erstellung komplexer Objekte.
• Flexibilität bei der Erstellung verschiedener Konfigurationen desselben Objekttyps.
• Trennung der Objekterstellungslogik von seiner Darstellung.
• Erleichtert die Hinzufügung neuer Produkttypen (mithilfe von Factory Method) oder neuer Bauweisen (mithilfe von Builder).

Nachteile:

• Erhöhung der Klassenanzahl im Projekt.
• Kann für einfache Objekte übertrieben sein.

Beispiel (Pseudocode):

// Produkt
class ComplexObject {
    private String partA;
    private int partB;

    // privater Konstruktor
    private ComplexObject(String partA, int partB) {
        this.partA = partA;
        this.partB = partB;
    }

    // Innere Builder-Klasse
    public static class Builder {
        private String partA;
        private int partB;

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(int partB) {
            this.partB = partB;
            return this;
        }

        public ComplexObject build() {
            return new ComplexObject(partA, partB);
        }
    }
}

// Fabrik, die einen Builder zurückgibt
class ComplexObjectFactory {
    public static ComplexObject.Builder createDefaultBuilder() {
        return new ComplexObject.Builder()
                .setPartA("defaultA")
                .setPartB(10);
    }

    public static ComplexObject.Builder createSpecialBuilder() {
        return new ComplexObject.Builder()
                .setPartA("specialA")
                .setPartB(50);
    }
}

// Verwendung:
// ComplexObject obj1 = ComplexObjectFactory.createDefaultBuilder().build();
// ComplexObject obj2 = ComplexObjectFactory.createSpecialBuilder().setPartA("customA").build();