Builder

Nella programmazione ad oggetti, il Builder è uno dei pattern fondamentali, definiti originariamente dalla Gang of Four (banda dei quattro).

Il design pattern Builder, nella programmazione ad oggetti, separa la costruzione di un oggetto complesso dalla sua rappresentazione cosicché il processo di costruzione stesso possa creare diverse rappresentazioni.

L'algoritmo per la creazione di un oggetto complesso è indipendente dalle varie parti che costituiscono l'oggetto e da come vengono assemblate.

Builder Pattern

Ciò ha l'effetto immediato di rendere più semplice la classe, permettendo a una classe builder separata di focalizzarsi sulla corretta costruzione di un'istanza e lasciando che la classe originale si concentri sul funzionamento degli oggetti. Questo è particolarmente utile quando volete assicurarvi che un oggetto sia valido prima di istanziarlo, e non volete che la logica di controllo appaia nei costruttori degli oggetti. Un builder permette anche di costruire un oggetto passo-passo, cosa che si può verificare quando si fa il parsing di un testo o si ottengono i parametri da un'interfaccia interattiva.

Struttura di un Builder

• Builder: specifica la classe astratta che crea le parti dell'oggetto Product.
• ConcreteBuilder: costruisce e assembla le parti del prodotto implementando l'interfaccia Builder; definisce e tiene traccia della rappresentazione che crea.
• Director: costruisce un oggetto utilizzando l'interfaccia Builder.
• Product: rappresenta l'oggetto complesso e include le classi che definiscono le parti che lo compongono, includendo le interfacce per assemblare le parti nel risultato finale.

Diagramma delle classi

Funzionamento

Il Client crea un oggetto Director e lo configura con gli oggetti Builder desiderati. Il Director notifica al Builder se una parte del prodotto deve essere costruita, il Builder riceve le richieste dal Director e aggiunge le parti al prodotto. Il Client riceve il prodotto dal Builder tramite il Director.

Questo consente di variare la rappresentazione interna del prodotto, isolare il codice per la costruzione e la rappresentazione e controllare in modo preciso il processo di costruzione.

• il Builder si focalizza sulla costruzione di un oggetto complesso "step by step". Abstract Factory enfatizza una famiglia di oggetti (sia semplici che complessi). Il Builder restituisce il prodotto come passo finale del processo di creazione, mentre per quanto riguarda l'Abstract Factory, il prodotto viene ritornato immediatamente.
• Builder spesso costruisce un Composite.
• In genere, il design procede nel modo seguente: parte utilizzando il pattern Factory Method (meno complicato, più customizzabile, ma che genera una proliferazione di sottoclassi) ed evolve verso Abstract Factory, Prototype, oppure Builder (più flessibili, più complessi) nel momento in cui il progettista scopre la necessità di una maggiore flessibilità.
• Spesso i pattern creazionali sono complementari: Builder può infatti utilizzare uno degli altri pattern per implementare le componenti che deve costruire. Abstract Factory, Builder, e Prototype possono utilizzare il Singleton nelle loro implementazioni.

/** "Prodotto" */ 
class Pizza { 
    private String dough = ""; 
    private String sauce = ""; 
    private String topping = ""; 
    public void setDough(String dough) { 
        this.dough = dough; 
    } 
    public void setSauce(String sauce) { 
        this.sauce = sauce; 
        
    } 
    public void setTopping(String topping) { 
        this.topping = topping; 
    } 
}

/** "Abstract Builder" */ 
abstract class PizzaBuilder { 
    protected Pizza pizza; 
    public Pizza getPizza() { 
        return pizza; 
    } 
    public void createNewPizzaProduct() { 
        pizza = new Pizza();
        } 
    public abstract void buildDough(); 
    public abstract void buildSauce(); 
    public abstract void buildTopping(); 
}

/** "ConcreteBuilder" */ 
class HawaiianPizzaBuilder extends PizzaBuilder { 
    public void buildDough() { 
        pizza.setDough("cross");
        } 
    public void buildSauce() { 
        pizza.setSauce("mild"); 
    } 
    public void buildTopping() { 
        pizza.setTopping("ham+pineapple"); 
    } 
}

/** "ConcreteBuilder" */ 
class SpicyPizzaBuilder extends PizzaBuilder { 
    public void buildDough() { 
        pizza.setDough("pan baked"); 
    } 
    public void buildSauce() { 
        pizza.setSauce("hot");
        } 
    public void buildTopping() {
        pizza.setTopping("pepperoni+salami");
        } 
}

   /** "Director" */
   class Cook {
   
       private PizzaBuilder pizzaBuilder;
       
       public void setPizzaBuilder(PizzaBuilder pb) {
           pizzaBuilder = pb; 
       }
   
       public Pizza getPizza() {
           return pizzaBuilder.getPizza(); 
       }
       
       public void constructPizza() {
           pizzaBuilder.createNewPizzaProduct();
           pizzaBuilder.buildDough();
           pizzaBuilder.buildSauce();
           pizzaBuilder.buildTopping();
       }
   }

/** A given type of pizza being constructed. */ 
class BuilderExample {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
        PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();
        cook.setPizzaBuilder( hawaiianPizzaBuilder );
        cook.constructPizza();
        Pizza pizza = cook.getPizza();
    }
}

Bibliografia

• Erich Gamma, design patterns elements of reusable object-oriented software, Richard Helm,Ralph Johnson,John Vlissides.

Voci correlate

• Design pattern

Altri progetti

Altri progetti

• Wikimedia Commons

• Wikimedia Commons contiene immagini o altri file su Builder

Collegamenti esterni

• Dai costruttori al Builder Pattern in Java [1] Archiviato l'11 febbraio 2013 in Internet Archive. articolo su http://www.cosenonjaviste.it Archiviato il 15 dicembre 2012 in Internet Archive.