Explication détaillée du modèle de création de modèle de conception PHP

Cet article présente principalement le mode constructeur dans le mode conception PHP et utilise PHP pour implémenter le mode constructeur. Les amis intéressés peuvent s'y référer. J'espère que cela aide tout le monde.

Le mode Constructeur peut séparer la représentation interne d'un produit du processus de production du produit, afin que des produits avec des représentations internes différentes puissent être générés.
1. Diagramme de structure du mode Constructeur

2. Rôles principaux
Rôle de constructeur abstrait (Builder) : Définir une interface abstraite pour standardiser la construction de chaque composant du produit (c'est-à-dire standardiser la méthode d'implémentation du constructeur spécifique ). Les méthodes spécifiées doivent inclure des méthodes de construction et des méthodes de retour de résultats
Rôle Concrete Builder (ConcreteBuilder) : Implémenter les méthodes définies par le rôle de constructeur abstrait. Le constructeur spécifique est étroitement lié à la logique métier. L'application finira par créer le produit selon la logique métier en appelant la méthode de construction implémentée dans ce rôle. Une fois la construction terminée, l'instance de produit construite sera renvoyée via le résultat. méthode. Généralement créé en externe par un client ou une usine abstraite.
Rôle de directeur : Le rôle de ce rôle est d'appeler le rôle de constructeur spécifique pour créer des produits. Le réalisateur n'a pas de relation directe avec la catégorie de produit. C'est un rôle concret et abstrait qui parle à la catégorie de produit.
Rôle produit : L'objet complexe créé par le constructeur sous la direction du directeur
Le rôle de directeur traite directement avec le client, il comprend la logique métier du client, divise la demande du client pour créer un produit dans des demandes de composants de produit, puis appelez des rôles de produit spécifiques pour effectuer l'opération de génération. Cela sépare le client du constructeur de béton.
3. Avantages et inconvénients du modèle Builder
Avantages du modèle Builder : Le modèle Builder peut très bien séparer l'implémentation d'un objet de la logique "métier" associée Open, donc qu'il peut être très facile d'ajouter (ou de modifier) ​​l'implémentation sans modifier la logique des événements.
Inconvénients du pattern Builder : La modification de l'interface du builder entraînera une modification de toutes les classes d'exécution.
4. Scénarios d'utilisation et effets du mode Builder
Le mode Builder doit être utilisé dans les situations suivantes :
1. a une structure interne complexe.
2. Les propriétés des objets produit qui doivent être générés dépendent les unes des autres et le modèle de générateur peut forcer l'ordre de génération.
3. Dans le processus de création d'objets, certains autres objets du système seront utilisés, qui ne sont pas faciles à obtenir lors de la création d'objets produits.
L'utilisation du mode constructeur a principalement les effets suivants :
1. L'utilisation du mode constructeur permet de changer indépendamment l'apparence interne du produit. L'utilisation du modèle de construction élimine le besoin pour le client de connaître les détails de la composition interne du produit.
2. Chaque Constructeur est relativement indépendant et n'a rien à voir avec les autres Constructeurs.
3. Le produit final construit par le modèle est plus facile à contrôler.
5. Mode constructeur et autres modes
Mode usine abstraite (mode usine abstraite) : Dans le mode usine abstraite, chaque objet d'usine Lorsque appelé, un objet produit complet est renvoyé et le client peut ou non assembler ces produits en un produit plus grand et plus complexe. Le modèle de constructeur est différent. Il construit un produit complexe pièce par pièce, et le processus d'assemblage de ce produit se déroule à l'intérieur du constructeur. La différence entre les deux réside dans la question de savoir s’il existe un processus d’assemblage et où se déroule le processus d’assemblage. Ces deux modèles de conception peuvent être utilisés ensemble. En appelant un rôle de construction, le client appelle indirectement un autre rôle d'usine dans le modèle d'usine abstrait. Le mode Usine renvoie les pièces de différentes familles de produits, tandis que le mode Constructeur les assemble.

Mode stratégie : Le mode constructeur est très proche du mode stratégie en termes de structure. En fait, le mode constructeur est un cas particulier du mode stratégie. La différence entre les deux réside dans leurs intentions différentes. Le modèle de construction fonctionne sur le client pour créer de nouveaux objets petit à petit, tandis que le but du modèle de stratégie est de fournir une interface abstraite pour l'algorithme.

Mode constructeur et mode méthode modèle : Une fois que le mode constructeur a dégénéré et perdu le rôle de directeur, il peut se développer en mode méthode modèle (c'est-à-dire placer l'implémentation de l'algorithme de la construction processus dans le rôle de construction) ).

Modèle de constructeur et modèle de composition : le modèle de composition décrit la structure de composition d'une arborescence d'objets, tandis que le modèle de constructeur peut être utilisé pour décrire le processus de génération de l'arborescence d'objets.
Les 4 points ci-dessus proviennent de "Java et Patterns"
6. Exemple PHP en mode Builder

<?php
/**
 * 产品
 * 此处仅以一个产品类中的字符串演示产品
 */
class Product {　　　　　　　　　　　　　　　　　　　　　　　　　　
 /**
 * 产品的组成部分集合
 */
 private $_parts;
 
 public function __construct() {
 $this->_parts = array();
 }
 
 public function add($part) {
 return array_push($this->_parts, $part);
 }
 
 public function show() {
 echo "the product include:";
 array_map(&#39;printf&#39;, $this->_parts);
 }
}
 
/**
 * 抽象建造者 
 */
abstract class Builder {
 
 /**
 * 产品零件构造方法1
 */
 public abstract function buildPart1();
 
 
 /**
 * 产品零件构造方法2
 */
 public abstract function buildPart2();
 
 
 /**
 * 产品返还方法
 */
 public abstract function getResult();
}
 
/**
 * 具体建造者
 */
class ConcreteBuilder extends Builder {
 
 private $_product;
 
 public function __construct() {
 $this->_product = new Product();
 }
 
 public function buildPart1() {
 $this->_product->add("Part1");
 }
 
 public function buildPart2() {
 $this->_product->add("Part2");
 }
 
 public function getResult() {
 return $this->_product;
 }
}
 
/**
 * 导演者
 */
class Director {
 
 public function __construct(Builder $builder) {
 $builder->buildPart1();
 $builder->buildPart2();
 }
}
 
 
 
class Client {
 
 /**
 * Main program.
 */
 public static function main() {
 $buidler = new ConcreteBuilder();
 $director = new Director($buidler);
 $product = $buidler->getResult();
 $product->show();
 }
 
}
 
Client::main();
?>

Recommandations associées :

Explication détaillée du modèle d'adaptateur du modèle de conception PHP

Explication détaillée du modèle d'itérateur dans les modèles de conception PHP

Explication détaillée du modèle de décorateur dans les modèles de conception PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!