Ce este pattern-ul de proiectare Factory Builder?

Modelul Factory Builder, sau mai bine spus Factory Method în combinație cu Builder, este o combinație a două modele care îmbunătățesc crearea obiectelor complexe.

Factory Method definește o interfață pentru crearea unui obiect, dar permite subclasei să decidă ce clasă să instanțieze. Delegă responsabilitatea creării obiectului către clasele derivate.

Builder separă construcția unui obiect complex de reprezentarea sa, astfel încât același proces de construcție poate crea diferite reprezentări. Permite construirea pas cu pas a unui obiect, folosind o lanț de apeluri de metode.

Combinația acestor modele se întâlnește cel mai frecvent în scenarii în care este necesar să se creeze mai multe variante ale unui obiect complex. Factory Method determină care tip de Builder trebuie utilizat, iar Builder se ocupă de cum să creeze obiectul cu diferite configurații.

Exemplu de utilizare: Când aveți o ierarhie de clase de obiecte care necesită inițializare complexă și doriți să creați aceste obiecte cu configurații diferite.

Structura tipică de interacțiune:

• Furnizor: Are o metodă care returnează o instanță a unui Builder specific, în funcție de parametrii de intrare sau de tipul său.
• Builder: Are metode pentru configurarea pas cu pas a parametrilor obiectului complex și o metodă finală build(), care returnează obiectul gata.
• Produs: Obiectul complex creat de Builder.

Avantaje:

• Îmbunătățirea lizibilității și gestionării codului la crearea obiectelor complexe.
• Flexibilitate în crearea diferitelor configurații ale aceluiași tip de obiect.
• Separarea logicii de creare a obiectului de reprezentarea sa.
• Ușurează adăugarea de noi tipuri de produse (folosind Factory Method) sau noi moduri de construire (folosind Builder).

Dezavantaje:

• Creșterea numărului de clase în proiect.
• Poate fi excesiv pentru obiecte simple.

Exemplu (pseudo-cod):

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

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

    // Clasă internă Builder
    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);
        }
    }
}

// Fabrica care returnează un Builder
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);
    }
}

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