Builder Pattern

Le design pattern Builder est un patron de conception conçu pour séparer la construction d'un objet complexe de sa représentation. Ainsi, le même processus de construction peut créer différentes représentations de l'objet. C'est un patron de conception faisant partie de la famille des créateurs.

Table des matières

1. Avantages
2. Le diagramme de classe
3. Exemple
4. Inconvénients
5. En vidéo

Avantages

• Permet de contrôler la construction de l'objet
• Évite de passer des valeurs nulles lorsqu'un argument est facultatif
• Permet d'encapsuler la construction de l'objet

Le diagramme de classe

Builder : classe abstraite pour créer le produit

BuilderImpl : implémentation de Builder

Director : gère l'algorithme de la construction de l'objet. Cette classe peut très bien être une classe cliente.

Exemple

import java.util.UUID;

class Product {

 private UUID uuid;
 private String name;
 private double price;

 public UUID getUuid() {
  return uuid;
 }

 public void setUuid(UUID uuid) {
  this.uuid = uuid;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public double getPrice() {
  return price;
 }

 public void setPrice(double price) {
  this.price = price;
 }

 @Override
 public String toString() {
  return "Product [uuid=" + uuid + ", name=" + name + ", price=" + price + "]";
 }

}

interface ProductBuilder {

 Product build();

 ProductBuilder setUuid(UUID uuid);

 ProductBuilder setName(String name);

 ProductBuilder setPrice(double price);

}

class ProductBuilderImpl implements ProductBuilder {

 Product product;

 public ProductBuilderImpl() {
  product = new Product();
 }

 @Override
 public Product build() {
  return product;
 }

 @Override
 public ProductBuilder setUuid(UUID uuid) {
  product.setUuid(uuid);
  return this;
 }

 @Override
 public ProductBuilder setName(String name) {
  product.setName(name);
  return this;
 }

 @Override
 public ProductBuilder setPrice(double price) {
  product.setPrice(price);
  return this;
 }

}

class ProductBuildDirector {
 private ProductBuilder builder;

 public ProductBuildDirector(ProductBuilder builder) {
  this.builder = builder;
 }

 public Product construct() {
  return builder.setName("Un Livre").setPrice(10).build();
 }
}

public class Main {
 public static void main(String[] args) {

  ProductBuilder builder = new ProductBuilderImpl();

   ProductBuildDirector productBuildDirector = new ProductBuildDirector(builder);
   System.out.println(productBuildDirector.construct());

 /*
  * Product [uuid=b4539efe-062d-4892-9bfc-da96c6562449, name=Un Livre, price=10.0]
  */

 }

}

Inconvénients

• Cela crée plus de code et pourrait introduire plus de complexité. Il faut utiliser ce patron de conception uniquement si vous avez affaire à des objets complexes ou des objets avec des attributs facultatifs.
• Peut complexifier l'injection de dépendances.

En vidéo

Voir la vidéo sur le patron de conception build pattern.