Analyse approfondie de l'application du mode Builder dans la programmation de motifs de conception Java

Définition: séparez la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.
Type: Créer un schéma de classe de modèle de classe:

Quatre éléments

• Catégorie de produit: Il s'agit généralement d'un objet relativement complexe, ce qui signifie que le processus de création d'un objet est relativement compliqué, et il y a généralement une grande quantité de code. Dans ce diagramme de classe, la classe de produits est une classe concrète, pas une classe abstraite. Dans la programmation réelle, une classe de produits peut être composée d'une classe abstraite et de ses différentes implémentations, ou il peut être composé de plusieurs classes abstraites et de leurs implémentations.
• Résumé Builder: Le but d'introduire le constructeur abstrait est de transférer le processus de construction en béton dans ses sous-classes pour y parvenir. Cela facilite l'échelle. Il existe généralement au moins deux méthodes abstraites, l'une est utilisée pour construire un produit et l'autre est utilisée pour retourner le produit.
• Builder: Toutes les méthodes non implémentées de mise en œuvre des classes abstraites sont généralement deux tâches: la formation d'un produit; Retourner le produit construit.
• Classe du directeur: responsable de l'appel des constructeurs appropriés pour former des produits. La classe de directeur ne dépend généralement pas des classes de produits et les constructeurs interagissent directement avec la classe du directeur. D'une manière générale, la classe Director est utilisée pour encapsuler des parties variables d'un programme.

Implémentation de code

Classe de produits abstraits:

 Package Builder; import java.util.arraylist; classe abstraite de la classe abstraite AbstractProduct {// Record Exécution Order Private ArrayList <string> Part = new ArrayList <string> (); abstrait vide dosomething (); Abstract public void Dootherthing (); // Final, les sous-classes ne peuvent pas être remplacées par Final public void Executive () {for (int i = 0; i <this.part.size (); i ++) {string actionName = this.part.get (i); if (actionName.equals ("DoSomething")) {this.dosomething (); } else if (actionName.equals ("dootherthing")) {this.dootherthing (); }}} // final, les sous-classes ne peuvent pas être remplacées par le public final void setPart (arrayList <string> pièce) {this.part = pièce; }}

Catégorie de mise en œuvre du produit:

 Package Builder; Le produit de classe publique étend AbstractProduct {// sous-classe Description spécifique étapes public void dosomething () {System.out.println ("fera quelque chose ..."); } public void dootherthing () {System.out.println ("quelque chose a fait. }}

Classe abstraite du constructeur:

 Package Builder; import java.util.arraylist; Builder de classe abstrait public {// Définissez différentes parties du produit pour obtenir différents produits publics abstract void setPart (arrayList <string> pièce); // Création du produit public Abstract Product BuildProduct (); }

Classe d'implémentation du constructeur:

 Package Builder; import java.util.arraylist; Classe publique ConcreteProduct étend Builder {Product Product privé = nouveau produit (); public void setPart (arrayList <string> pièce) {this.product.setPart (pièce); } public produit buildProduct () {return this.product; }}

Catégorie de directeur:

 Package Builder; import java.util.arraylist; // Repackage l'ordre de production de différents produits et bloquez les détails du directeur de classe publique de haut niveau {private arrayList <string> part = new ArrayList <string> (); Private Builder Builder = New ConcreteProduct (); produit public getAProduct () {this.part.clear (); this.part.add ("dosomething"); this.part.add ("Dootherthing"); builder.setPart (pièce); Retour Builder.BuildProduct (); }}

Client:

 Package Builder; Client de classe publique {public static void main (String [] args) {Director Director = new Director (); System.out.println ("Généra 10 produits"); pour (int i = 1; i <11; i ++) {System.out.println ("thread" + i + "Products"); Director.getAproduct (). Executive (); System.out.println (); }}}

Avantages du modèle de constructeur
Tout d'abord, le modèle du constructeur a une très bonne encapsulation. L'utilisation du modèle de générateur peut encapsuler efficacement les changements. Dans le scénario de l'utilisation du modèle Builder, les catégories de produits générales et les catégories de générateur sont relativement stables. Par conséquent, encapsuler la logique commerciale principale dans la catégorie des administrateurs peut réaliser une meilleure stabilité dans l'ensemble.
Deuxièmement, le mode Builder est facile à développer. S'il y a une nouvelle exigence, cela peut être fait en mettant en œuvre une nouvelle classe de constructeur. Fondamentalement, il n'est pas nécessaire de modifier le code qui a été testé et adopté auparavant, il n'y aura donc aucun risque pour la fonction d'origine.

La différence entre le modèle de générateur et le modèle d'usine
Nous pouvons voir que le modèle du constructeur est très similaire au modèle d'usine. Dans l'ensemble, le modèle du constructeur n'a qu'un rôle de plus "directeur" que le modèle d'usine. Dans le diagramme de classe de modèle de générateur, si la classe de directeur est considérée comme le client final, la partie restante du diagramme peut être considérée comme un modèle d'usine simple.
Par rapport au modèle d'usine, le modèle de générateur est généralement utilisé pour créer des objets plus complexes. Parce que le processus de création d'objets est plus complexe, le processus de création d'objets est indépendant du processus de création d'objets pour former une nouvelle classe - la classe du directeur. En d'autres termes, le modèle d'usine résume l'ensemble du processus de création de l'objet dans la classe d'usine, et la classe d'usine fournit le produit final au client; Pendant que dans le modèle du constructeur, la classe Builder ne fournit généralement que la construction de chaque composant dans la classe de produits et offre le processus de construction spécifique à la classe du directeur. La classe de directeur est responsable de la formation de chaque composant en un produit en fonction de règles spécifiques, puis de livrer le produit formé au client.

Résumer
Le modèle du constructeur est similaire au modèle d'usine. Ils sont tous deux du modèle de constructeur et les scénarios applicables sont également très similaires. D'une manière générale, si la construction du produit est compliquée, veuillez utiliser le modèle d'usine; Si la construction du produit est plus compliquée, veuillez utiliser le modèle du constructeur.