Cos'è il pattern di progettazione Factory Builder?

Il pattern Factory Builder, o più correttamente Factory Method in combinazione con Builder, è una combinazione di due pattern che migliora la creazione di oggetti complessi.

Factory Method definisce un'interfaccia per creare un oggetto, ma permette alle sottoclassi di decidere quale classe istanziare. Delegano la responsabilità di creare l'oggetto alle classi figlie.

Builder separa la costruzione di un oggetto complesso dalla sua rappresentazione, in modo che lo stesso processo di costruzione possa creare diverse rappresentazioni. Permette di costruire un oggetto passo dopo passo, usando una catena di chiamate ai metodi.

La combinazione di questi pattern si trova più frequentemente in scenari in cui è necessario creare diverse varianti di un oggetto complesso. Factory Method determina quale tipo di Builder deve essere usato, e poi il Builder si occupa di come creare l'oggetto con diverse configurazioni.

Esempio di utilizzo: Quando si ha una gerarchia di classi di oggetti che richiedono una inizializzazione complessa, e si desidera creare questi oggetti con configurazioni diverse.

Struttura tipica di interazione:

• Fornitore: Ha un metodo che restituisce un'istanza di un Builder specifico in base ai parametri di input o al suo tipo.
• Builder: Ha metodi per configurare passo dopo passo i parametri dell'oggetto complesso e un metodo finale build(), che restituisce l'oggetto pronto.
• Prodotto: L'oggetto complesso che viene creato dal Builder.

Vantaggi:

• Miglior leggibilità e gestibilità del codice nella creazione di oggetti complessi.
• Flessibilità nella creazione di diverse configurazioni dello stesso tipo di oggetto.
• Separazione della logica di creazione dell'oggetto dalla sua rappresentazione.
• Facilita l'aggiunta di nuovi tipi di prodotti (usando Factory Method) o nuovi metodi di costruzione (usando Builder).

Svantaggi:

• Aumento del numero di classi nel progetto.
• Potrebbe essere eccessivo per oggetti semplici.

Esempio (pseudo-codice):

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

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

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

// Fattoria che restituisce 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);
    }
}

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