Une analyse approfondie du modèle de combinaison en PHP

Dans l'article précédent "Comprendre le modèle de poids mouche en PHP dans un article", nous avons présenté le modèle de poids mouche en PHP. Cet article vous amènera à comprendre le modèle de combinaison dans les modèles de conception PHP.

La gestion plate est populaire dans les entreprises Internet, c'est-à-dire que le niveau de gestion doit être inférieur ou maximum à trois niveaux. En tant que codeur de bas niveau, la différence entre votre PDG et votre rang est de trois niveaux. Cependant, de nombreuses entreprises traditionnelles entretiennent des relations hiérarchiques très profondes. Du point de vue de la structure des données, cette structure organisationnelle regroupée par fonction ressemble beaucoup à un arbre. Le rôle du modèle de combinaison que nous présentons aujourd’hui est très similaire au modèle au niveau de la structure organisationnelle de l’entreprise.

Diagramme de classes Gof et explication

Définition GoF : les objets sont combinés dans une structure arborescente pour représenter une hiérarchie "partie-tout". Composite permet aux utilisateurs d'utiliser des objets uniques et des objets composites de manière cohérente

Diagramme de classes GoF

Implémentation du code

abstract class Component
{
    protected $name;

    public function __construct($name){
        $this->name = $name;
    }
    
    abstract public function Operation(int $depth);

    abstract public function Add(Component $component);

    abstract public function Remove(Component $component);
}

Déclarations de nœuds composites abstraites, implémentant toutes les classes le cas échéant Le comportement par défaut de l'interface publique est être la classe parent de tous les nœuds enfants.

class Composite extends Component
{
    private $componentList;

    public function Operation($depth)
    {
        echo str_repeat('-', $depth) . $this->name . PHP_EOL;
        foreach ($this->componentList as $component) {
            $component->Operation($depth + 2);
        }
    }

    public function Add(Component $component)
    {
        $this->componentList[] = $component;
    }

    public function Remove(Component $component)
    {
        $position = 0;
        foreach ($this->componentList as $child) {
            ++$position;
            if ($child == $component) {
                array_splice($this->componentList, ($position), 1);
            }
        }
    }

    public function GetChild(int $i)
    {
        return $this->componentList[$i];
    }
}

Classe d'implémentation de nœud spécifique, enregistre les références aux nœuds subordonnés et définit le comportement réel du nœud.

class Leaf extends Component
{
    public function Add(Component $c)
    {
        echo 'Cannot add to a leaf' . PHP_EOL;
    }
    public function Remove(Component $c)
    {
        echo 'Cannot remove from a leaf' . PHP_EOL;
    }
    public function Operation(int $depth)
    {
        echo str_repeat('-', $depth) . $this->name . PHP_EOL;
    }
}

Leaf node, le nœud final sans nœuds enfants.

• Du point de vue du code, il s'agit complètement de l'implémentation d'un arbre
• Tous les nœuds enfants et nœuds feuilles peuvent traiter les données, mais le nœud feuille est le point final
• Vous espérez que les utilisateurs pourront ignorer la différence entre les nœuds combinés objets et objets uniques, et unifier Lorsque vous utilisez efficacement tous les objets dans la structure de combinaison, vous devez envisager d'utiliser le modèle de combinaison
• L'utilisateur n'a pas besoin de se soucier de savoir s'il doit traiter un nœud feuille ou un composant de combinaison, et il n'est pas nécessaire de écrivez quelques énoncés de jugement de sélection pour définir la combinaison
• Les modèles de composition permettent aux clients d'utiliser des structures composites et des objets uniques de manière cohérente

En continuant avec l'exemple au début de l'article, dans notre structure organisationnelle, lorsqu'une tâche atteint la personne la plus basse , il passera par plusieurs niveaux. Je préfère toujours la méthode traditionnelle de gestion d’entreprise. Habituellement, un directeur correspond à plusieurs superviseurs, un superviseur correspond à plusieurs managers, un manager correspond à plusieurs chefs d'équipe et un chef d'équipe correspond à plusieurs employés. Lorsqu'un avis est émis, le personnel de chaque niveau doit répondre et continuer à distribuer l'avis aux employés subalternes tout en obtenant les commentaires de ces derniers. De cette façon, nous avons, sans le savoir, achevé l’application pratique du modèle de combinaison. Soudain, je me sens bien et j'ai l'impression que ma vie a atteint son apogée ! !

Code complet : https://github.com/zhangyue0503/designpatterns-php/blob/master/14.composite/source/composite.php

Exemple

Messagerie texte SMS, nous pouvons utiliser cette fonction sur et encore une fois Utilisé. Cette fois ne fait pas exception. Cette fois, la fonction du backend de notre site Web est d'envoyer des messages texte aux utilisateurs de différentes sous-stations et de différentes sources. Ici, nous nous concentrons toujours uniquement sur l'envoi de messages texte. Nous espérons vous offrir des utilisateurs avec des rôles de canal différents mais des comportements unifiés. Une telle fonction ne semble pas difficile, n'est-ce pas ?

Diagramme des classes d'envoi de SMS

Code source complet : https://github.com/zhangyue0503/designpatterns-php/blob/master/14.composite/source/composite-msg.php

<?php

abstract class Role
{
    protected $userRoleList;
    protected $name;
    public function __construct(String $name)
    {
        $this->name = $name;
    }

    abstract public function Add(Role $role);

    abstract public function Remove(Role $role);

    abstract public function SendMessage();
}

class RoleManger extends Role
{
    public function Add(Role $role)
    {
        $this->userRoleList[] = $role;
    }

    public function Remove(Role $role)
    {
        $position = 0;
        foreach ($this->userRoleList as $n) {
            ++$position;
            if ($n == $role) {
                array_splice($this->userRoleList, ($position), 1);
            }
        }
    }

    public function SendMessage()
    {
        echo "开始发送用户角色：" . $this->name . &#39;下的所有用户短信&#39;, PHP_EOL;
        foreach ($this->userRoleList as $role) {
            $role->SendMessage();
        }
    }
}

class Team extends Role
{

    public function Add(Role $role)
    {
        echo "小组用户不能添加下级了！", PHP_EOL;
    }

    public function Remove(Role $role)
    {
        echo "小组用户没有下级可以删除！", PHP_EOL;
    }

    public function SendMessage()
    {
        echo "小组用户角色：" . $this->name . &#39;的短信已发送！&#39;, PHP_EOL;
    }
}

// root用户
$root = new RoleManger(&#39;网站用户&#39;);
$root->add(new Team(&#39;主站用户&#39;));
$root->SendMessage();

// 社交版块
$root2 = new RoleManger(&#39;社交版块&#39;);
$managerA = new RoleManger(&#39;论坛用户&#39;);
$managerA->add(new Team(&#39;北京论坛用户&#39;));
$managerA->add(new Team(&#39;上海论坛用户&#39;));

$managerB = new RoleManger(&#39;sns用户&#39;);
$managerB->add(new Team(&#39;北京sns用户&#39;));
$managerB->add(new Team(&#39;上海sns用户&#39;));

$root2->add($managerA);
$root2->add($managerB);
$root2->SendMessage();

Explication

• Lorsque je souhaite envoyer des utilisateurs de sections de forum, je peux librement ajouter des nœuds feuilles de diverses stations locales pour contrôler les objets d'envoi
• Vous pouvez considérer l'envoi de l'intégralité de $root2 dans son ensemble, différentes sections et les régions sont considérées comme des parties
• Cette combinaison peut s'étendre vers le bas jusqu'à la fin du nœud profond de la feuille. Bien sûr, ce degré est contrôlé par vous-même, c'est très clair

Adresse originale : https://juejin.cn. /post/6844903967407734792

Auteur : Hardcore Project Manager

Apprentissage recommandé : "Tutoriel vidéo 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!