Builder

Intento
Separare la costruzione di un oggetto complesso dalla sua rappresentazione, rendendo possibile il riutilizzo dello stesso processo di costruzione per oggetti differenti (differenti rappresentazioni).

Descrizione
Il Builder pattern rende possibile ad un client object di costruire oggetti complessi specificando solo il suo tipo e contenuto.
Il client è disaccoppiato dai dettagli della creazione dell'oggetto, cioè dal "come" questo oggetto viene creato.
Ciò semplifica la creazione di oggetti complessi definendo una classe che costruisce istanze di un'altra classe.

Il builder pattern produce un prodotto principale, possono esserci più parti che compongono il prodotto.

L'oggetto Director sa le operazioni da compiere per costruire il prodotto. L'oggetto Builder sa costruire le singoli parti, ma non conosce la sequenza e l'ordine delle operazioni di assemblaggio. Quando la costruzione dell'oggetto è terminata, si chiede al Builder di restituire l'oggetto assemblato.

La differenza tra il Builder pattern e gli altri Creational Patterns è che con il Builder è possibile creare un oggetto complesso un passo per volta, mentre gli altri patterns costruiscono l'oggetto in un singolo passo.

Collaboration

(dopo questo disegno, mi comincia a venire l'allergia a PoseidonUML... ;-) )

Il director chiama in sequenza i metodi di costruzione sul builder, la cui interfaccia è definita.

L'oggetto creato non implementa un'interfaccia predefinita, infatti è il client che invoca getResult sul concrete Builder.

Il programmatore può definire diverse implementazioni del builder per creare oggetti differenti. La superclasse di builder può implementare metodi vuoti, di cui le sottoclassi implementano solo quelle a cui sono interessate, lasciando vuoti gli altri metodi.

Benefici

Permette di variare la rappresentazione interna di un prodotto.
Isola il codice di costruzione dal codice di rappresentazione.
Fornisce un miglior controllo sul processo di creazione.

Quando utilizzarlo

L'algoritmo di creazione di un oggetto complesso deve essere indipendente dalle parti che fanno parte dell'oggetto e da come tali parti vengono assemblate.
Il processo di costruzione deve rendere possibile differenti rappresentazioni dell'oggetto costruito, ovvero creare oggetti di classi diverse.

Esempio:




public class Client {



   public static void main(String[] args) {



      SimpleMazeBuilder simpleMazeBuilder = new SimpleMazeBuilder();

      MazeDirector director = new MazeDirector(simpleMazeBuilder);

      director.startBuilding();

      SimpleMaze simpleMaze = simpleMazeBuilder.getSimpleMaze();



      ComplexMazeBuilder complexMazeBuilder = new ComplexMazeBuilder();

      director = new MazeDirector(complexMazeBuilder);

      director.startBuilding();

      ComplexMaze complexMaze = complexMazeBuilder.getComplexMaze();

   }

}




/**

 * @stereotype Component of Product

 */

public class Door {

}




/**

 * @stereotype Component of Product

 */

public class Room {

   private Door door;

   public void setDoor(Door val) { door = val; }

}




/**

 * @stereotype Abstract Builder

 */

public abstract class MazeBuilder {

   public void buildRooms() {}

   public void buildDoors() {}

}




/**

 * @stereotype Director

 */

public class MazeDirector {

   private MazeBuilder builder;

   public MazeDirector(MazeBuilder val) { builder = val; }

   public void startBuilding() {

      builder.buildRooms();

      builder.buildDoors();

   }

}




import java.util.ArrayList;

import java.util.Iterator;



/**

 * @stereotype Product

 */

public class ComplexMaze {

   private ArrayList rooms = new ArrayList();

   public void addRoom(Room room) { rooms.add(room); }

   public Iterator rooms() { return rooms.iterator(); }

}




import java.util.Iterator;



/**

 * @stereotype Concrete Builder

 */

public class ComplexMazeBuilder extends MazeBuilder{

   private ComplexMaze maze;



   public ComplexMazeBuilder() { maze = new ComplexMaze(); }



   public void buildRooms() {

      for(int i = 0;i  1000;i++) maze.addRoom(new Room());

   }



   public void buildDoors() {

      Iterator it = maze.rooms();

      while(it.hasNext()) ((Room)it.next()).setDoor(new Door());

   }



   public ComplexMaze getComplexMaze() { return maze; }

}




/**

 * @stereotype Product

 */

public class SimpleMaze {

   private Room room;

   public void setRoom(Room val) { room = val; }

   public Room getRoom() { return room; }

}




import java.util.Iterator;



/**

 * @stereotype Concrete Builder

 */

public class SimpleMazeBuilder extends MazeBuilder{

   private SimpleMaze maze;

   public SimpleMazeBuilder() { maze = new SimpleMaze(); }

   public void buildRooms() { maze.setRoom(new Room()); }

   public void buildDoors() { maze.getRoom().setDoor(new Door()); }

   public SimpleMaze getSimpleMaze() { return maze; }

}

Builder is mentioned on: CreationalPatterns

Java User Group Torino