An in-depth analysis of the combination pattern in PHP

In the previous article "Understanding the Flyweight Mode in PHP" we introduced the Flyweight Mode in PHP. This article will take you to understand the combination mode in PHP design patterns.

Flat management is popular in Internet companies, that is, the management level should be less than or no more than three levels. As a low-level code farmer, your CEO and your rank are also The difference is within 3 layers. However, many traditional enterprises have very deep hierarchical relationships. From a data structure perspective, this organizational structure grouped by function is very much like a tree. The combination model we introduced today is very similar to the model at the enterprise organizational structure level.

Gof class diagram and explanation

GoF definition: combine objects into a tree structure to represent a "part-whole" hierarchy. Composite enables users to use single objects and composite objects consistently

GoF Class Diagram

Code implementation

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);
}

The abstracted composite node declaration implements the default behavior of the public interface of all classes where appropriate and is the parent class of all child nodes.

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];
    }
}

Specific node implementation class, saves references to subordinate nodes, and defines actual node behavior.

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, the final node without child nodes.

• From the code point of view, it is completely the implementation of a tree
• All child nodes and leaf nodes can process data, but the leaf node is the end point
• When you hope that users can ignore the difference between a composite object and a single object and use all objects in the composite structure uniformly, you should consider using the composite mode
• The user does not need to care whether to process a leaf node or a composite component , there is no need to write some selection judgment statements to define the combination
• The combination mode allows customers to use the combination structure and a single object consistently

Continue at the end of the article As an example at the beginning, in our organizational structure, when a task reaches the lowest person, it will go through multiple levels. I still prefer the traditional corporate management method. Usually one director corresponds to multiple supervisors, one supervisor corresponds to multiple managers, one manager corresponds to multiple team leaders, and one team leader corresponds to multiple employees. When a notice is issued, staff at each level must respond and continue to distribute the notice to subordinate employees while obtaining feedback from subordinates. In this way, we have unknowingly completed the application of the combination model in practice. Suddenly I feel great, and I feel like my life has reached its peak! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/14.composite/source/composite.php

Example

SMS SMS, we can use this function over and over again. This time is no exception. This time, the function of our website backend is to send text messages to users from different substations and from different sources. Here, we still only focus on sending text messages. We hope to give you users with different channel roles but unified behaviors. You can just send them. Such a function does not seem difficult, right?

SMS sending class diagram

Full source code: 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();

Description

• When I want to send the user of the forum section At this time, I can freely add leaf nodes of each local station to control the sending objects
• You can regard the entire sending of $root2 as a whole, and different sections and regions as parts
• This combination can extend downward until the end of the deep leaf node. Of course, this degree is controlled by yourself, it is very clear

Original address: https://juejin .cn/post/6844903967407734792

Author: Hardcore Project Manager

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of An in-depth analysis of the combination pattern in PHP. For more information, please follow other related articles on the PHP Chinese website!