Design patterns: Builder

Mauto 3 min

il Builder Pattern è ideale quando hai bisogno di costruire oggetti complessi in modo chiaro e flessibile. Favorisce la separazione dei dettagli di costruzione dalla rappresentazione finale e migliora la leggibilità e la manutenibilità del codice.

Caratteristiche del Builder pattern

  1. Separazione della costruzione e della rappresentazione: Il Builder Pattern separa il processo di costruzione di un oggetto dalla sua rappresentazione finale, consentendo di creare diversi tipi di oggetti con lo stesso processo.
  2. Costruzione passo dopo passo: Gli oggetti possono essere costruiti in modo incrementale, configurando i parametri desiderati in vari passaggi. Ogni passaggio può restituire il builder stesso, consentendo una sintassi fluida.
  3. Immutabilità dell’oggetto finale: Il risultato finale del builder è spesso immutabile, garantendo che non possa essere modificato dopo la creazione, migliorando la coerenza e la stabilità.
  4. Flessibilità ed estensibilità: È possibile estendere il builder per supportare nuovi tipi di oggetti senza modificare il codice esistente. Aggiungere nuovi metodi per configurare parametri aggiuntivi è semplice.
  5. Semplicità di utilizzo: Il Builder Pattern semplifica la creazione di oggetti complessi, nascondendo i dettagli di implementazione e riducendo il numero di costruttori necessari.
  6. Chiarezza e manutenibilità: La creazione di oggetti utilizzando un builder è più chiara e comprensibile rispetto all’utilizzo di costruttori complessi, migliorando la leggibilità e la manutenibilità del codice.

Esempio in PHP:

Un esempio comune del Builder Pattern è la costruzione di un oggetto Pizza. Puoi avere un builder per la pizza che ti permette di specificare gli ingredienti, le dimensioni e le opzioni di cottura. Puoi aggiungere ingredienti o configurare la pizza passo dopo passo e, una volta completata, ottenere l’oggetto Pizza finale.

class Pizza {
    private $size;
    private $cheese = false;
    private $pepperoni = false;
    private $mushrooms = false;

    public function __construct($size) {
        $this->size = $size;
    }

    public function __toString() {
        $toppings = [];
        if ($this->cheese) $toppings[] = "cheese";
        if ($this->pepperoni) $toppings[] = "pepperoni";
        if ($this->mushrooms) $toppings[] = "mushrooms";

        return "Pizza: Size - {$this->size}, Toppings - " . implode(", ", $toppings);
    }

    public function addCheese() {
        $this->cheese = true;
    }

    public function addPepperoni() {
        $this->pepperoni = true;
    }

    public function addMushrooms() {
        $this->mushrooms = true;
    }
}

class PizzaBuilder {
    private $size;
    private $pizza;

    public function __construct($size) {
        $this->size = $size;
        $this->pizza = new Pizza($this->size);
    }

    public function withCheese() {
        $this->pizza->addCheese();
        return $this;
    }

    public function withPepperoni() {
        $this->pizza->addPepperoni();
        return $this;
    }

    public function withMushrooms() {
        $this->pizza->addMushrooms();
        return $this;
    }

    public function build() {
        return $this->pizza; // Restituisce l'oggetto Pizza costruito
    }
}

// Creare un builder per una pizza di grandezza "large"
$pizzaBuilder = new PizzaBuilder("large");

// Aggiungere ingredienti e costruire la pizza
$pizza = $pizzaBuilder
    ->withCheese()
    ->withPepperoni()
    ->withMushrooms()
    ->build();

// Stampare la pizza
echo $pizza; // Output: Pizza: Size - large, Toppings - cheese, pepperoni, mushrooms

TORNA ALLA GUIDA

content_copy Copiato