Qu'est-ce que le patron de conception 'Constructeur'…

Le patron de conception "Builder" (Constructeur) est un patron de création qui fournit une méthode pour créer un objet complexe étape par étape. Il sépare le processus de construction d’un objet complexe de sa représentation, ce qui permet d’utiliser le même processus de construction pour créer différentes représentations.

Composants clés du patron :

Builder : Interface abstraite ou concrète (ou classe) définissant un ensemble de méthodes pour construire étape par étape les parties du produit.
ConcreteBuilder : Implémentation concrète de Builder qui crée une représentation spécifique du produit. Il connaît tous les détails de la construction.
Director : Classe optionnelle, mais souvent utilisée. Définit l’ordre dans lequel les étapes de construction sont appelées pour créer une configuration spécifique du produit.
Product : Objet complexe qui est construit. Il est composé de plusieurs parties.

Avantages :

Permet de créer des objets complexes étape par étape, évitant les constructeurs "téléscopiques" (constructeurs avec beaucoup de paramètres).
Encapsule la logique de création de l’objet complexe.
Facilite la modification de la représentation interne du produit.
Permet d’utiliser le même processus de construction pour créer différentes variantes du produit.

Applicabilité :

Lorsque le processus de création d’un objet implique de nombreuses étapes, et que ces étapes doivent être effectuées dans un ordre précis.
Lorsqu’il est nécessaire d’avoir différentes représentations du même objet.
Lorsque le constructeur de l’objet possède de nombreux paramètres optionnels.

Exemple :

// Produit
class Pizza {
    private String dough = "";
    private String sauce = "";
    private List<String> toppings = new ArrayList<>();

    public void setDough(String dough) {
        this.dough = dough;
    }

    public void setSauce(String sauce) {
        this.sauce = sauce;
    }

    public void addTopping(String topping) {
        this.toppings.add(topping);
    }

    @Override
    public String toString() {
        return "Pizza avec pâte : " + dough + ", sauce : " + sauce + ", garnitures : " + toppings;
    }
}

// Interface du constructeur
interface PizzaBuilder {
    void buildDough();
    void buildSauce();
    void buildToppings();
    Pizza getPizza();
}

// Constructeur concret
class MargheritaPizzaBuilder implements PizzaBuilder {
    private Pizza pizza = new Pizza();

    @Override
    public void buildDough() {
        pizza.setDough("croûte fine");
    }

    @Override
    public void buildSauce() {
        pizza.setSauce("tomate");
    }

    @Override
    public void buildToppings() {
        pizza.addTopping("mozzarella");
        pizza.addTopping("basilic");
    }

    @Override
    public Pizza getPizza() {
        return this.pizza;
    }
}

// Directeur (optionnel)
class Cook {
    private PizzaBuilder pizzaBuilder;

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

    public Pizza getPizza() {
        return pizzaBuilder.getPizza();
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();
        pizzaBuilder.buildSauce();
        pizzaBuilder.buildToppings();
    }
}

// Utilisation
public class BuilderExample {
    public static void main(String[] args) {
        Cook cook = new Cook();
        PizzaBuilder margheritaBuilder = new MargheritaPizzaBuilder();

        cook.setPizzaBuilder(margheritaBuilder);
        cook.constructPizza();

        Pizza margherita = cook.getPizza();
        System.out.println(margherita);
    }
}

Dans le contexte de l’automatisation des tests, "Builder" est souvent utilisé pour créer des données de test ou des objets de test complexes (par exemple, un objet utilisateur avec de multiples attributs, un objet commande avec plusieurs éléments), lorsque la configuration de différentes variantes de ces données est nécessaire pour différents scénarios de test.

Qu'est-ce que le patron de conception 'Constructeur' (Builder) ?