设计模式 | 建造者模式

2020-07-20 17:13:01 浏览数 (1)

说明

这个设计模式主要是解决复杂对象的创建问题, 使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。例如，一辆汽车由轮子，发动机以及其他零件组成，对于普通人而言，我们使用的只是一辆完整的车，这时，我们需要加入一个构造者，让他帮我们把这些组件按序组装成为一辆完整的车。

  • 例如

有个订单：奔驰、宝马的车辆模型都交给我我们公司制作了，不过这次又额外增加了一个需求: 汽车的启动、停止、喇叭声音、引擎声音都由客户自己控制，他想什么顺序就什么顺序。

首先，奔驰、宝马都是一个产品，他们有共有的属性，但是可能奔驰是先有引擎声音 然后再启动。宝马呢是先启动后有引擎声音

示例

代码语言：javascript复制
<?php
/**
 * Created by 憧憬.
 */

abstract class CarModel
{

    private $sequence = [];


    // 启动
    abstract protected function start();

    // 停止
    abstract protected function stop();

    // 哔哔叫
    abstract protected function alarm();

    // 引擎轰轰响
    abstract protected function engineBoom();

    // 启动模型

    final public function run()
    {

        $count = count($this->sequence);

        for ($i = 0; $i <= $count; $i  ) {
            $actionName = $this->sequence[$i];

            switch ($actionName) {
                case 'start':
                    $this->start();
                    break;

                case 'stop':
                    $this->stop();
                    break;

                case 'alarm':
                    $this->alarm();
                    break;

                case 'engineBoom' :
                    $this->engineBoom();
                    break;
            }

        }
    }


    // 允许客户端自己设置启动顺序 想先干嘛 就往数组里面指定
    final public function setSequence($sequence)
    {
        $this->sequence = $sequence;
    }
}


/**
 * 奔驰车的实现
 * Class BenzModel
 */
class BenzModel extends CarModel
{

    protected function start()
    {
        echo '奔驰车跑起来是这个样子的..';
    }

    protected function stop()
    {
        echo '奔驰车应该这样停车..';
    }

    protected function alarm()
    {
        echo '奔驰车的声音是这个样子';
    }

    protected function engineBoom()
    {
        echo '奔驰车的引擎是这个声音的';
    }

}


/**
 * 宝马车的实现
 * Class BMWModel
 */
class BMWModel extends CarModel
{

    protected function start()
    {
        echo '宝马车跑起来是这个样子的..';
    }

    protected function stop()
    {
        echo '宝马车应该这样停车..';
    }

    protected function alarm()
    {
        echo '宝马车的声音是这个样子';
    }

    protected function engineBoom()
    {
        echo '宝马车的引擎是这个声音的';
    }


}


// 我先要个奔驰的模型，这个模型的要求是跑的时候， 先发动引擎，然后再挂档启动，然后停下来，不需要喇叭，那怎么实现呢？

$benzModel = new BenzModel();

$benzModel->setSequence(['engineBoom', 'start', 'stop']);
$benzModel->run();

echo PHP_EOL;
/**
 * 上面虽然实现了基本随意更换构建汽车的过程，然后还有其他车实现，例如:
 * 宝马的车只要启动和停止，其余什么都不要， 还有其他车，先喇叭，然后启动，然后停止，.....
 * 这样就导致一直去访问产品类 代码产生了耦合
 */


/**
 * 约束需要什么顺序的车
 * Class CarBuilder
 */
abstract class CarBuilder
{

    //建造一个模型，你要给我一个顺序要，就是组装顺序
    abstract public function setSequence($sequence);

    // 设置完毕顺序后，就可以直接拿到这个车辆模型
    abstract public function getCarModel();
}


/**
 * 奔驰的构建者
 * Class BenzBuilder
 */
class BenzBuilder extends CarBuilder
{

    private $benz;


    public function __construct()
    {
        $this->benz = new BenzModel();
    }


    public function getCarModel()
    {
        return $this->benz;
    }

    // 设置启动构造顺序
    public function setSequence($sequence)
    {
        $this->benz->setSequence($sequence);
    }
}

/**
 * 宝马构建者
 * Class BMWBuilder
 */
class BMWBuilder extends CarBuilder
{

    private $bmw;


    public function __construct()
    {
        $this->bmw = new BMWModel();
    }


    public function getCarModel()
    {
        return $this->bmw;
    }

    // 设置启动构造顺序
    public function setSequence($sequence)
    {
        $this->bmw->setSequence($sequence);
    }
}


// 构建一个奔驰的
$benzBuilder = new BenzBuilder();
$benzBuilder->setSequence(['engineBoom', 'start', 'stop']);
$benzBuilder->getCarModel()->run();

// 那如果需要再构造一个宝马的也是一样的 这样就不需要直接访问产品类了
echo PHP_EOL;


$bmwBuilder = new BMWBuilder();
$bmwBuilder->setSequence(['engineBoom', 'start', 'stop']);
$bmwBuilder->getCarModel()->run();


/**
 * 那这有个这样的需求，这四个过程 (start,stop,alarm,engineBoom)按照排列组合有很多种，
 * 那我们怎么满足这种需求呢?也就是要有个类 来安排这几个方法组合，
 * 就像导演安排演员一样，那个先出场那个后出场，那个不出场，我们这个也叫导演类，
 */

//型号的奔驰车辆模型是只有启动(start)、停止(stop)方法，其他的引擎声音、喇叭都没有;
//B 型号的奔驰车是先发动引擎(engine boom),然后启动(star),再然后停车(stop),没有喇叭;
//C 型号的宝马车是先喇叭叫一下(alarm)，然后(start),再然后是停车(stop)，引擎不轰鸣;
//D 型号的宝马车就一个启动(start)，然后一路跑到黑，永动机，没有停止方法，没有喇叭，没有引擎轰鸣; E 型号、F 型号...等等，可以有很多，启动(start)、停止(stop)、喇叭(alarm)、引擎轰鸣(engine boom)


class Director
{
    private $sequence;

    private $benzBuilder;
    private $bmwBuilder;

    public function __construct()
    {
        $this->sequence = [];
        $this->benzBuilder = new BenzBuilder();
        $this->bmwBuilder = new BMWBuilder();
    }

    // A类型奔驰 先start,然后stop,其他什么引擎了，喇叭一概没有
    public function getAbenzModel()
    {
        $this->sequence = [];

        $this->sequence = ['start', 'stop'];

        $this->benzBuilder->setSequence($this->sequence);

        return $this->benzBuilder->getCarModel();
    }


    // B类型奔驰 是先发动引擎，然后启动，然后停止，没有喇叭
    public function getBbenzModel()
    {
        $this->sequence = [];

        $this->sequence = ['engineBoom', 'start', 'stop'];

        $this->benzBuilder->setSequence($this->sequence);

        return $this->benzBuilder->getCarModel();
    }


    // C型号的宝马车是先按下喇叭(炫耀嘛)，然后启动，然后停止
    public function getCBMWModel()
    {
        $this->sequence = [];

        $this->sequence = ['alarm', 'start', 'stop'];

        $this->bmwBuilder->setSequence($this->sequence);

        return $this->bmwBuilder->getCarModel();
    }


    // D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止，牛叉
    public function getDBMWModel()
    {
        $this->sequence = [];

        $this->sequence = ['start'];

        $this->bmwBuilder->setSequence($this->sequence);

        return $this->bmwBuilder->getCarModel();
    }

}

// 然后 Client 程序就只与 Director 打交道了

class Client {
    public static function main()
    {
        $director = new Director();

        //1W辆A类型的奔驰车
        for ($i = 0; $i < 10000; $i  ) {
            $director->getABenzModel()->run();
        }

        //100W辆B类型的奔驰车
        for ($i = 0; $i < 1000000;
             $i  ) {
            $director->getBBenzModel()->run();
        }

        //1000W量C类型的宝马车
        for ($i = 0; $i < 10000000; $i  ) {
            $director->getCBMWModel()->run();
        }
    }
}

Client::main();

清晰简单，角色说明一下

  • Client 客户端
  • CarModel 以及两个实现类 BenzModel 和 BMWModel 叫做产品类
  • CarBuilder 以及两个实现类 BenzBuilder 和 BMWBuilder 叫做建造者
  • Director 类叫做导演类(Director Class),负责安排已有模块的顺序，然后告诉 Builder 开始建造，

注意，这个建造者模式和工厂模式非常相似 但是记住一点你就可以游刃有余的使用了: 建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方 法已经实现了;而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的

使用场景

建造者模式使用的场景，产品类非常的复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式是非常合适。 我曾在一个银行交易类项目中遇到了这个问题，一个产品的定价计算模型有 N 多 种，每个模型有固定的计算步骤，计算非常复杂，项目中就使用了建造者模式;

这篇文章参考自24种设计模式介绍与六大设计原则

本文为作者原创，手码不易，允许转载，转载后请以链接形式说明文章出处。

builder 设计模式

0 人点赞