An in-depth analysis of the builder pattern in PHP

In the previous article " A brief discussion of the intermediary pattern in PHP" we introduced the intermediary pattern in PHP. The following article will take you to understand the builder pattern in the PHP design pattern. .

Builder mode can also be called generator mode. The original meaning of the word builder includes the meaning of builder, developer and creator. Obviously, this mode is another creation mode, used to create objects. So what are its characteristics? From an architectural point of view, building a house is not something that can be built immediately, but is built brick by brick. A house not only has bricks and tiles, but also various pipes, various wires, etc., and their various parts together form a house. It can be said that the builder pattern is a very vivid process of composing an object (house) from various components.

Gof class diagram and explanation

GoF definition: Separate the construction of a complex object from its representation, so that the same construction process can create different representations

GoF Class Diagram

Code Implementation

class Product
{
    private $parts = [];

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

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

Product class, you can put it Think of it as the house we want to build. The house at this time has no content, we need to add bricks and tiles to it.

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('部件A');
    }
    public function BuildPartB(): void
    {
        $this->product->Add('部件B');
    }
    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('部件X');
    }
    public function BuildPartB(): void
    {
        $this->product->Add('部件Y');
    }
    public function GetResult(): Product
    {
        return $this->product;
    }
}

Builder abstraction and its implementation. Different developers will always use different brands of materials. Here we have two different developers, but their purpose is the same, to build a house (Product).

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

Constructor, used to call the builder for production. That's right, it's our engineering team. It selects materials and builds. The same engineering team can take on different orders, but all they build are houses. Only the materials and appearance of this house are different, but the general craftsmanship is still the same.

$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();

Finally, let’s take a look at our implementation. Is it very simple? Just prepare the engineering team, prepare different builders, and then hand it over to the engineering team for production! !

• In fact, the main problem to be solved by this model is that a class may have a lot of configurations and attributes. Not all of these configurations and attributes must be configured. They can be configured through one-time instantiation. These things are very troublesome. At this time, you can consider making these configurations and properties into parts that can be added at any time. Get different objects through different attribute combinations.
• The original text of the above item in GoF is: it allows you to change the internal representation of a product; it separates the construction code and the presentation code; it allows you to have more fine-grained control over the construction process.
• To put it simply, the object is too complex, we can assemble it part by part!
• Anyone who knows a little about Android development will be familiar with creating a dialog object AlterDialog.builder
• In Laravel, the database component also uses the builder mode. You can look at the Database in the source code Is there a Builder.php in the \Eloquent and Database\Query directories

As we all know, mobile phone assembly is a complicated process, so we have corresponding models of mobile phones The drawings (Builder) are handed over to the workers (Director) on the assembly line, and they will use the accessories according to the drawings to produce the various models of mobile phones (Product) we need. It's obvious that we are all great builders, adding to our industry! ! !

Full code: https://github.com/zhangyue0503/designpatterns-php/blob/master/16.builder/source/builder.php

Example

As mentioned before, many Dialog dialog boxes in Android are implemented using the builder mode. As the owner of a mobile phone factory, customized Android system is also a very important part. Just like the X Mi, we started with MIUI and won the software market first, making everyone feel that this system is very easy to use, and then started developing mobile phones. This shows that software and hardware are indeed the two most important components of modern mobile phones, and neither one can survive without them. This time, we will use the builder mode to simply implement a set of dialog components!

Dialog class diagram

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

Description

• This time our product is a bit complicated, with title, content, attributes, buttons, etc.
• The construction process is actually the same, but here we mainly use different constructors. Things outside the ordinary dialog box can be clicked, but modal windows generally have a mask layer, that is, the background becomes transparent black, and things outside can no longer be clicked
• If you pass it directly every time If the constructor method instantiates the window class, there will be a lot of parameters to be passed. But now, we can combine it through the builder, so that the object has a polymorphic effect and can present different forms and functions

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

Author: Hardcore Project Manager

Recommended learning: "PHP Video tutorial》

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