Wat is het ontwerp patroon Factory Builder?

Het Factory Builder-patroon, of beter gezegd Factory Method in combinatie met Builder, is een combinatie van twee patronen die het maken van complexe objecten verbetert.

Factory Method definieert een interface voor het maken van een object, maar laat subklassen beslissen welke klasse geïnstantieerd moet worden. Het delegeert de verantwoordelijkheid voor het maken van het object aan de afgeleide klassen.

Builder scheidt de constructie van een complex object van zijn presentatie, zodat hetzelfde constructieproces verschillende presentaties kan creëren. Het stelt je in staat om een object stapsgewijs te bouwen, met behulp van een keten van methodenaanroepen.

De combinatie van deze patronen wordt het meest gebruikt in scenario's waar het nodig is om meerdere varianten van een complex object te maken. Factory Method bepaalt welke type Builder gebruikt moet worden, en de Builder zorgt vervolgens voor hoe het object met verschillende configuraties gemaakt wordt.

Voorbeeld van gebruik: Wanneer je een hiërarchie van objectklassen hebt die een complexe initialisatie vereisen, en je wilt deze objecten met verschillende configuraties maken.

Typische interactiestructuur:

• Fabriek: Heeft een methode die een instantie van een specifieke Builder retourneert, afhankelijk van de invoerparameters of het type.
• Builder: Heeft methoden om stap voor stap de parameters van het complexe object in te stellen en een finale methode build(), die het gereed gemaakte object retourneert.
• Product: Het complexe object dat door de Builder wordt gemaakt.

Voordelen:

• Verbeterde leesbaarheid en beheersbaarheid van de code bij het maken van complexe objecten.
• Flexibiliteit in het maken van verschillende configuraties van hetzelfde type object.
• Scheiding van de objectcreatie-logica van de presentatie.
• Eenvoudiger toevoegen van nieuwe producttypes (met Factory Method) of nieuwe bouwmethoden (met Builder).

Nadelen:

• Toename in het aantal klassen in het project.
• Kan overbodig zijn voor eenvoudige objecten.

Voorbeeld (pseudo-code):

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

    // privé constructor
    private ComplexObject(String partA, int partB) {
        this.partA = partA;
        this.partB = partB;
    }

    // Interne 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);
        }
    }
}

// Fabriek die een Builder retourneert
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);
    }
}

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