Une analyse approfondie du modèle de constructeur en PHP-tutoriel php-php.cn

Dans l'article précédent "Une brève discussion sur le modèle intermédiaire en PHP", nous avons présenté le modèle intermédiaire en PHP. Cet article vous amènera à comprendre le modèle de constructeur dans le modèle de conception PHP.

Une analyse approfondie du modèle de constructeur en PHP

Le mode constructeur peut également être appelé mode générateur. La signification originale du mot constructeur inclut la signification de constructeur, développeur et créateur. Bien évidemment, ce mode est un autre mode de création, utilisé pour créer des objets. Alors quelles sont ses caractéristiques ? D’un point de vue architectural, la construction d’une maison ne se construit pas immédiatement, mais se construit brique par brique. Une maison n'a pas seulement des briques et des tuiles, mais aussi divers tuyaux, divers fils, etc., et leurs différentes parties forment ensemble une maison. On peut dire que le modèle de constructeur est un processus très vivant de composition d'un objet (maison) à partir de divers composants.

Diagramme de classes Gof et explication

Définition GoF : 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

Diagramme de classes GoF

Une analyse approfondie du modèle de constructeur en PHP

Le le code implémente la classe de produits

class Product
{
    private $parts = [];

    public function Add(String $part): void
    {
        $this->parts[] = $part;
    }

    public function Show(): void
    {
        echo PHP_EOL . &#39;产品创建 ----&#39;, PHP_EOL;
        foreach ($this->parts as $part) {
            echo $part, PHP_EOL;
        }
    }
}

Copier après la connexion

Vous pouvez la considérer comme la maison que nous voulons construire. La maison n’a actuellement aucun contenu, nous devons y ajouter des briques et des tuiles.

interface Builder
{
    public function BuildPartA(): void;
    public function BuildPartB(): void;
    public function GetResult(): Product;
}

class ConcreteBuilder1 implements Builder
{
    private $product;

    public function __construct()
    {
        $this->product = new Product();
    }

    public function BuildPartA(): void
    {
        $this->product->Add(&#39;部件A&#39;);
    }
    public function BuildPartB(): void
    {
        $this->product->Add(&#39;部件B&#39;);
    }
    public function GetResult(): Product
    {
        return $this->product;
    }
}

class ConcreteBuilder2 implements Builder
{
    private $product;

    public function __construct()
    {
        $this->product = new Product();
    }

    public function BuildPartA(): void
    {
        $this->product->Add(&#39;部件X&#39;);
    }
    public function BuildPartB(): void
    {
        $this->product->Add(&#39;部件Y&#39;);
    }
    public function GetResult(): Product
    {
        return $this->product;
    }
}

Copier après la connexion

Abstraction du constructeur et sa mise en œuvre. Différents développeurs utiliseront toujours des marques de matériaux différentes. Ici, nous avons deux développeurs différents, mais leur objectif est le même : construire une maison (Produit).

class Director
{
    public function Construct(Builder $builder)
    {
        $builder->BuildPartA();
        $builder->BuildPartB();
    }
}

Copier après la connexion

Constructeur, utilisé pour appeler le constructeur pour la production. C'est vrai, c'est notre équipe d'ingénierie. Il sélectionne les matériaux et construit. La même équipe d’ingénierie peut prendre en charge différentes commandes, mais elle ne construit que des maisons. Seuls les matériaux et l’apparence de cette maison sont différents, mais le savoir-faire général est toujours le même.

$director = new Director();
$b1 = new ConcreteBuilder1();
$b2 = new ConcreteBuilder2();

$director->Construct($b1);
$p1 = $b1->getResult();
$p1->Show();

$director->Construct($b2);
$p2 = $b2->getResult();
$p2->Show();

Copier après la connexion

Enfin, jetons un coup d'œil à notre mise en œuvre. Est-ce très simple ? Il suffit de préparer l'équipe d'ingénierie, de préparer les différents constructeurs, puis de la confier à l'équipe d'ingénierie pour la production ! !

En fait, le principal problème à résoudre par ce modèle est qu'une classe peut avoir beaucoup de configurations et d'attributs. Il est très difficile de configurer ces éléments via un seul. instanciation temporelle. À ce stade, vous pouvez envisager de transformer ces configurations et propriétés en parties pouvant être ajoutées à tout moment. Obtenez différents objets grâce à différentes combinaisons d'attributs.
Le texte original de l'article ci-dessus dans GoF est : il permet de modifier la représentation interne d'un produit ; il sépare le code de construction et le code de présentation ; il permet d'avoir un contrôle plus fin sur le processus de construction ;
Pour faire simple, l'objet est trop complexe, on peut l'assembler pièce par pièce !
Si vous connaissez un peu le développement Android, vous le connaîtrez. Création d'un objet de dialogue AlterDialog.builder
Dans Laravel, le composant de base de données utilise également le modèle de générateur. Vous pouvez vérifier s'il en existe un dans DatabaseEloquent. et DatabaseQuery dans le code source. Builder.php

Tout le monde sait que l'assemblage de téléphones mobiles est un processus compliqué, nous avons donc des dessins correspondants (Builder) pour différents modèles de téléphones mobiles, et remettons les dessins et accessoires au ouvriers (Directeur) sur la chaîne de montage. Ils utiliseront des accessoires selon les dessins pour produire les différents modèles de téléphones portables (Produits) dont nous avons besoin. Il est évident que nous sommes tous de grands bâtisseurs qui contribuent à notre industrie ! ! !

Code complet : https://github.com/zhangyue0503/designpatterns-php/blob/master/16.builder/source/builder.php

Exemple

Comme mentionné précédemment, il existe de nombreuses boîtes de dialogue de dialogue dans Android Ils seront tous implémentés en utilisant le modèle constructeur. En tant que propriétaire d'une usine de téléphonie mobile, les systèmes Android personnalisés constituent également un élément très important. Tout comme le X Mi, nous avons commencé avec MIUI et avons d'abord gagné le marché des logiciels, faisant sentir à tout le monde que ce système est très facile à utiliser, puis avons commencé à développer des téléphones mobiles. Cela montre que les logiciels et le matériel sont en effet les deux composants les plus importants des téléphones mobiles modernes, et qu’aucun d’eux ne peut survivre sans eux. Cette fois, nous utiliserons le mode constructeur pour simplement implémenter un ensemble de composants de dialogue !

Diagramme de classes de dialogue

Une analyse approfondie du modèle de constructeur en PHP

Code source complet : https://github.com/zhangyue0503/designpatterns-php/blob/master/16.builder/source/builder-dialog.php

<?php

class Dialog
{
    private $attributes = [];
    private $buttons = [];
    private $title = &#39;&#39;;
    private $content = &#39;&#39;;

    public function AddAttributes($attr)
    {
        $this->attributes[] = $attr;
    }
    public function AddButtons($button)
    {
        $this->buttons[] = $button;
    }
    public function SetTitle($title)
    {
        $this->title = $title;
    }
    public function SetContent($content)
    {
        $this->content = $content;
    }

    public function ShowDialog(){
        echo PHP_EOL, &#39;显示提示框 === &#39;, PHP_EOL;
        echo &#39;标题：&#39; . $this->title, PHP_EOL;
        echo &#39;内容：&#39; . $this->content, PHP_EOL;
        echo &#39;样式：&#39; . implode(&#39;,&#39;, $this->attributes), PHP_EOL;
        echo &#39;按扭：&#39; . implode(&#39;,&#39;, $this->buttons), PHP_EOL;
    }
}

interface Builder
{
    public function BuildAttribute($attr);
    public function BuildButton($button);
    public function BuildTitle($title);
    public function BuildContent($content);
    public function GetDialog();
}

class DialogBuilder implements Builder{
    private $dialog;
    public function __construct(){
        $this->dialog = new Dialog();
    }
    public function BuildAttribute($attr){
        $this->dialog->AddAttributes($attr);
    }
    public function BuildButton($button){
        $this->dialog->AddButtons($button);
    }
    public function BuildTitle($title){
        $this->dialog->SetTitle($title);
    }
    public function BuildContent($content){
        $this->dialog->SetContent($content);
    }
    public function GetDialog(){
        return $this->dialog;
    }
}

class DialogDirector {
    public function Construct($title, $content){

        $builder = new DialogBuilder();

        $builder->BuildAttribute(&#39;置于顶层&#39;);
        $builder->BuildAttribute(&#39;居中显示&#39;);

        $builder->BuildButton(&#39;确认&#39;);
        $builder->BuildButton(&#39;取消&#39;);

        $builder->BuildTitle($title);
        $builder->BuildContent($content);
        
        return $builder;
    }
}

class ModalDialogDirector {
    public function Construct($title, $content){

        $builder = new DialogBuilder();

        $builder->BuildAttribute(&#39;置于顶层&#39;);
        $builder->BuildAttribute(&#39;居中显示&#39;);
        $builder->BuildAttribute(&#39;背景庶照&#39;);
        $builder->BuildAttribute(&#39;外部无法点击&#39;);

        $builder->BuildButton(&#39;确认&#39;);
        $builder->BuildButton(&#39;取消&#39;);

        $builder->BuildTitle($title);
        $builder->BuildContent($content);
        
        return $builder;
    }
}

$d1 = new DialogDirector();
$d1->Construct(&#39;窗口1&#39;, &#39;确认要执行操作A吗？&#39;)->GetDialog()->ShowDialog();

$d2 = new ModalDialogDirector();
$d2->Construct(&#39;窗口2&#39;, &#39;确认要执行操作B吗？&#39;)->GetDialog()->ShowDialog();

Copier après la connexion

Instructions

Cette fois, notre produit est un peu compliqué, avec le titre, le contenu, les attributs, les boutons, etc.
Le processus de construction est en fait le même, mais ici nous utilisons principalement des constructeurs différents. Les éléments en dehors de la boîte de dialogue ordinaire peuvent être cliqués, tandis que les fenêtres modales ont généralement un calque de masque, ce qui signifie que l'arrière-plan devient noir transparent et que les éléments à l'extérieur ne peuvent plus être cliqués
Si vous l'instancier directement via la méthode de construction à chaque fois classe window, il y aura beaucoup de paramètres à passer, mais maintenant, on peut les combiner via le constructeur, pour que l'objet ait un effet polymorphe et puisse présenter différentes formes et fonctions