设计模式 | 建造者模式

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