Patron Builder

Le patron Builder est un patron de conception de création qui permet de séparer les étapes de création d'un objet complexe de sa représentation.

Le patron Builder est un patron de conception de création dont l'objectif principal est de séparer le processus de construction d'un objet complexe de sa représentation, afin que des objets avec différentes représentations puissent être créés.

summary

intention

Séparer un processus de construction complexe de sa représentation, afin qu'un même processus de construction puisse créer différentes représentations.

Résout principalement

Dans les systèmes logiciels, la création d'un objet complexe se compose généralement de plusieurs parties ; les combinaisons de ces parties changent souvent, mais l'algorithme de combinaison est relativement stable.

Quand l'utiliser

Lorsque certains composants de base restent inchangés, mais que leurs combinaisons changent fréquemment.

Comment résoudre

Séparez les parties changeantes et non changeantes.

Code clé

BuilderCréer et fournir une instance.
directeur: Gérer les dépendances des instances créées et contrôler le processus de construction.

Exemple d'application

Chez KFC, les hamburgers, le cola, les frites, les ailes de poulet frites, etc. sont inchangés, mais leurs combinaisons changent fréquemment, produisant différents "combos".
En JavaStringBuilder。

Avantages

Séparer le processus de construction de la représentation rend le processus de construction plus flexible et permet de construire différentes représentations.
Il permet de mieux contrôler le processus de construction et de masquer les détails spécifiques de construction.
Grande réutilisabilité du code ; le même builder peut être réutilisé dans différents processus de construction.

Inconvénients

Si le produit possède peu d'attributs, le patron Builder peut entraîner une redondance de code.
Augmente le nombre de classes et d'objets dans le système.

Cas d'utilisation

L'objet à générer a une structure interne complexe.
Les attributs internes de l'objet à générer sont interdépendants.

Notes

La différence avec le patron de fabrique est que le patron de construction se concentre davantage sur l'ordre d'assemblage des parties.

Structure

Le patron de construction comprend les rôles principaux suivants :

Produit: L'objet complexe à construire. La classe produit contient généralement plusieurs parties ou attributs.
Monteur abstrait: Définit l'interface abstraite pour construire le produit, y compris les méthodes de construction des différentes parties du produit.
Monteur concret: Implémente l'interface du monteur abstrait, détermine spécifiquement comment construire les différentes parties du produit, et est chargé de renvoyer le produit final construit.
Directeur: Responsable d'appeler les méthodes du builder pour construire le produit. Le directeur ne comprend pas le processus de construction spécifique, il ne se préoccupe que de l'ordre et de la manière de construction du produit.

Implémentation

Supposons un cas métier pour un restaurant de restauration rapide, où un menu typique peut être composé d'un burger et d'une boisson fraîche. Le burger peut être un Veg Burger ou un Chicken Burger, et ils sont emballés dans une boîte en carton. La boisson fraîche peut être du Coca-Cola (coke) ou du Pepsi (pepsi), et ces boissons sont en bouteilles.

Nous allons créer une classe d'entité représentant des articles alimentaires (tels que des burgers et des boissons fraîches).ItemInterface et implémentationItemLa classe d'entité de l'interface, et une classe d'entité représentant l'emballage alimentaire.PackingInterface et implémentationEmballageLa classe d'entité de l'interface ; les burgers sont emballés dans des cartons, et les boissons fraîches sont en bouteille.

Ensuite, nous créons uneMealclasse, avecItemdeArrayListet l'un en combinantItempour créer différents types deMealde l'objetMealBuilder。BuilderPatternDemoUtilisation de la classeMealBuilderpour créer unMeal。

Étape 1

Créez des classes d'entités qui implémentent l'interface Packing.

Item.java

public Item public { public String name(); public Packing packing(); public float price(); }

Packing.java

public interface Packing { public String pack(); }

Étape 2

Créez des classes d'entités qui implémentent l'interface Packing.

Wrapper.java

public class Wrapper implements Packing { @Override public String pack() { return "Wrapper"; } }

Bottle.java

public class Bottle implements Packing { @Override public String pack() { return "Bottle"; } }

Étape 3

Créer une classe abstraite qui implémente l'interface Item, qui fournit une fonctionnalité par défaut.

Burger.java

public abstract class Burger implements Item { @Override public Packing packing() { return new Wrapper(); } @Override public abstract float price(); }

ColdDrink.java

public abstract class ColdDrink implements Item { @Override public Packing packing() { return new Bottle(); } @Override public abstract float price(); }

Étape 4

Créez des classes d'entité qui étendent Burger et ColdDrink.

VegBurger.java

public class VegBurger extends Burger { @Override public float price() { return 25.0f; } @Override public String name() { return "Burger végétarien"; } }

ChickenBurger.java

public class ChickenBurger extends Burger { @Override public float price() { return 50.5f; } @Override public String name() { return "Burger au poulet"; } }

Coke.java

public class Coke extends ColdDrink { @Override public float price() { return 30.0f; } @Override public String name() { return "Coke"; } }

Pepsi.java

public class Pepsi extends ColdDrink { @Override public float price() { return 35.0f; } @Override public String name() { return "Pepsi"; } }

Étape 5

Créez une classe Meal contenant les objets Item définis ci-dessus.

Meal.java

import java.util.ArrayList; import java.util.List; public class Meal { private List<Item> items = new ArrayList<Item>(); public void addItem(Item item){ items.add(item); } public float getCost(){ float cost = 0.0f; for (Item item : items) { cost += item.price(); } return cost; } public void showItems(){ for (Item item : items) { System.out.print("Article : "+item.name()); System.out.print(", Emballage : "+item.packing().pack()); System.out.println(", Prix : "+item.price()); } } }

Étape 6

Créez une classe MealBuilder, la classe de construction réelle chargée de créer des objets Meal.

MealBuilder.java

public class MealBuilder { public Meal prepareVegMeal (){ Meal meal = new Meal(); meal.addItem(new VegBurger()); meal.addItem(new Coke()); return meal; } public Meal prepareNonVegMeal (){ Meal meal = new Meal(); meal.addItem(new ChickenBurger()); meal.addItem(new Pepsi()); return repas; } }

Étape 7

BuiderPatternDemo utilise MealBuilder pour démontrer le patron Builder.

BuilderPatternDemo.java

public class BuilderPatternDemo { public static void main(String[] args) { MealBuilder mealBuilder = new MealBuilder(); Meal vegMeal = mealBuilder.prepareVegMeal(); System.out.println("Repas végétarien"); vegMeal.showItems(); System.out.println("Coût total : " +vegMeal.getCost()); Meal nonVegMeal = mealBuilder.prepareNonVegMeal(); System.out.println("\n\nRepas non végétarien"); nonVegMeal.showItems(); System.out.println("Coût total : " +nonVegMeal.getCost()); } }

Étape 8

Exécutez le programme, affichez le résultat :

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0


Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

Articles connexes

autres extensions

Patrons de conceptionAutres