Ce este un builder în contextul dezvoltării software?

Modelul de proiectare care separă construirea unui obiect complex de prezentarea sa, permițând crearea de diferite prezentări ale aceluiași proces de construcție.

Caracteristici cheie:

• Separarea responsabilităților: Logica de creare a obiectului (pașii de construcție) și prezentarea obiectului (produsul rezultat) sunt separate.
• Construcție pas cu pas: Obiectul este construit pas cu pas, ceea ce face procesul mai flexibil și mai clar.
• Prezentări diferite: Același proces de construcție poate fi folosit pentru a crea variații diferite ale obiectului.
• Incapsulare: Detaliile construirii obiectului sunt ascunse clientului, ceea ce simplifică utilizarea sa.

Participanți principali:

• Builder (Constructor): Interfață sau clasă abstractă care definește pașii pentru crearea părților produsului.
• ConcreteBuilder (Constructor concret): Implementare concretă a Builder care efectuează construcția efectivă a părților produsului și păstrează rezultatul.
• Director (Regizor): Clasă care folosește obiectul ConcreteBuilder pentru a construi produsul, apelând metodele corespunzătoare în anumite secvențe.
• Product (Produs): Obiect complex care este construit.

Exemplu de utilizare:

Crearea obiectului Pizza cu diferiți ingrediente:

// Produs
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 cu aluat: " + dough + ", sos: " + sauce + ", brânză: " + cheese + ", toppinguri: " + toppings;
    }
}

// Interfață Builder
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// ConcreteBuilder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

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

    @Override
    public void buildDough() {
        pizza.setDough("Aluat subțire");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("Sos de roșii");
    }

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

    @Override
    public void addTopping(String topping) {
        // Margherita nu are toppinguri suplimentare implicit
    }

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

// Regizor
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // Toppinguri suplimentare pot fi adăugate aici în funcție de tipul de pizza sau cerințe
    }
}

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

Se aplică când:

• Este necesar să se creeze un obiect complex cu mulți parametri opționali.
• Procesul de creare este secvențial și include mai mulți pași.
• Se dorește crearea de variații diferite ale aceluiași obiect, folosind același algoritm de construcție.
• Este nevoie să se evite constructorul cu mulți parametri ("constructor telescopic").

Avantaje:

• Îmbunătățește lizibilitatea și întreținerea codului.
• Oferă flexibilitate în crearea obiectelor.
• Permite crearea de obiecte imuabile.
• Elimină necesitatea unui număr mare de constructori.

Dezavantaje:

• Poate crește numărul de clase din proiect (pentru fiecare tip de obiect și fiecare constructor).
• Necesită un efort inițial de proiectare.