Cos'è un builder nel contesto dello sviluppo…

Schema di progettazione che separa la costruzione di un oggetto complesso dalla sua rappresentazione, consentendo di creare diverse rappresentazioni dello stesso processo di costruzione.

Caratteristiche principali:

Separazione delle responsabilità: La logica di creazione dell’oggetto (passaggi di costruzione) e la rappresentazione dell’oggetto (prodotto finale) sono separate.
Costruzione passo passo: L’oggetto viene costruito passo dopo passo, rendendo il processo più flessibile e comprensibile.
Diverse rappresentazioni: Lo stesso processo di costruzione può essere usato per creare diverse variazioni dell’oggetto.
Incapsulamento: I dettagli della creazione dell’oggetto sono nascosti al cliente, semplificando il suo utilizzo.

Principali partecipanti:

Builder (Costruttore): Interfaccia o classe astratta che definisce i passaggi per creare parti del prodotto.
ConcreteBuilder (Costruttore Concreto): Implementazione concreta del costruttore, che esegue la costruzione reale delle parti del prodotto e memorizza il risultato.
Director (Direttore): Classe che utilizza un oggetto ConcreteBuilder per costruire il prodotto, chiamando i metodi appropriati in una sequenza determinata.
Product (Prodotto): Oggetto complesso che viene costruito.

Esempio di utilizzo:

Creazione di un oggetto Pizza con diversi ingredienti:

// Prodotto
class Pizza {
    private String dough;
    private String sauce;
    private String cheese;
    private List<String> toppings;

    public void setDough(String dough) { this.dough = dough; }
    public void setSauce(String sauce) { this.sauce = sauce; }
    public void setCheese(String cheese) { this.cheese = cheese; }
    public void addTopping(String topping) {
        if (toppings == null) {
            toppings = new ArrayList<>();
        }
        toppings.add(topping);
    }

    @Override
    public String toString() {
        return "Pizza con impasto: " + dough + ", salsa: " + sauce + ", formaggio: " + cheese + ", condimenti: " + toppings;
    }
}

// Interfaccia del builder
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// Builder concreto
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public MargheritaPizzaBuilder() {
        this.pizza = new Pizza();
    }

    @Override
    public void buildDough() {
        pizza.setDough("Impasto sottile");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("Salsa di pomodoro");
    }

    @Override
    public void buildCheese() {
        pizza.setCheese("Mozzarella");
    }

    @Override
    public void addTopping(String topping) {
        // La Margherita non ha condimenti extra di default
    }

    @Override
    public Pizza getResult() {
        return pizza;
    }
}

// Direttore
class Cook {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pb) {
        pizzaBuilder = pb;
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Toppings aggiuntivi possono essere aggiunti qui in base al tipo di pizza o ai requisiti
    }
}

// Codice cliente
public class PizzaShop {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder margheritaBuilder = new MargheritaPizzaBuilder();

        cook.setPizzaBuilder(margheritaBuilder);
        cook.constructPizza();

        Pizza pizza = margheritaBuilder.getResult();
        System.out.println(pizza);
    }
}

Applicato quando:

È necessario creare un oggetto complesso con molti parametri opzionali.
Il processo di creazione dell’oggetto è sequenziale e comprende più passaggi.
Si devono creare diverse variazioni dello stesso oggetto usando lo stesso algoritmo di costruzione.
È necessario evitare costruttori con molti parametri ("costruttore telescopico").

Vantaggi:

Migliora la leggibilità e la manutenibilità del codice.
Offre flessibilità nella creazione di oggetti.
Permette di creare oggetti immutabili.
Elimina la necessità di molti costruttori.

Svantaggi:

Può aumentare il numero di classi nel progetto (per ogni tipo di oggetto e ogni costruttore).
Richiede uno sforzo iniziale di progettazione.

Cos'è un builder nel contesto dello sviluppo software?