Mi az a builder a szoftverfejlesztés kontextusában?

A tervezési minta, amely elválasztja egy összetett objektum felépítését annak megjelenítésétől, lehetővé téve ugyanazon építési folyamat különböző megjelenítéseinek létrehozását.

Fő jellemzők:

• Felelősségek szétválasztása: Az objektum létrehozásának logikája (építési lépések) és az objektum megjelenítése (az eredmény) külön van választva.
• Lépésenkénti építés: Az objektum lépésről lépésre épül, ezáltal rugalmasabbá és érthetőbbé válik a folyamat.
• Különböző megjelenítések: Ugyanaz a felépítési folyamat különböző változatok létrehozására használható.
• Encapsuláció: Az objektum létrehozásának részletei el vannak rejtve az ügyfél elől, ez megkönnyíti a használatát.

Fő résztvevők:

• Builder (Építő): Egy absztrakt interfész vagy osztály, amely meghatározza a lépéseket a termék részeinek létrehozásához.
• ConcreteBuilder (Konkrét Építő): A Builder konkrét megvalósítása, amely ténylegesen építi a termék részeit és tárolja az eredményt.
• Director (Igazgató): Olyan osztály, amely a ConcreteBuilder objektumot használva építi a terméket, a megfelelő módszereket meghatározott sorrendben hívva.
• Product (Termék): Az épített összetett objektum.

Használati példa:

Egy Pizza objektum létrehozása különböző összetevőkkel:

// Termék
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 tésztával: " + dough + ", szósz: " + sauce + ", sajt: " + cheese + ", feltétek: " + toppings;
    }
}

// Builder interfész
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildCheese();
    void addTopping(String topping);
    Pizza getResult();
}

// Konkrét Builder
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

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

    @Override
    public void buildDough() {
        pizza.setDough("Vékony tészta");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("Paradicsomszósz");
    }

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

    @Override
    public void addTopping(String topping) {
        // A Margherita alapból nem tartalmaz extra feltéteket
    }

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

// Igazgató
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildCheese();
        // További feltéteket itt lehet hozzáadni a pizza típusától vagy követelményektől függően
    }
}

// Ügyfél kód
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);
    }
}

Alkalmazás, amikor:

• Szükség van összetett objektum létrehozására sok opcionális paraméterrel.
• A létrehozási folyamat szekvenciális és több lépést foglal magában.
• Különböző variációkat kell létrehozni ugyanabból az objektumból ugyanazzal az építési algoritmussal.
• El kell kerülni a "telescoping constructor" (csőszerű konstruktor) használatát.

Előnyök:

• Javítja a kód olvashatóságát és karbantarthatóságát.
• Rugalmasságot biztosít az objektumok létrehozásában.
• Lehetővé teszi változatlan (immutable) objektumok létrehozását.
• Megszünteti a sok konstruktőr szükségességét.

Hátrányok:

• Növelheti a osztályok számát a projektben (minden típusú objektum és minden építő esetében).
• Kezdeti tervezési erőfeszítést igényel.