第 10 章 建造者模式

<?php
header("Content-type: text/html; charset=UTF-8");

/**
* 建造者模式
*
* 又是一个周三，快要下班了，老大突然又拉住我，喜滋滋的告诉我“牛叉公司很满意我们做的模型，
* 又签订了一个合同，把奔驰、宝马的车辆模型都交给我我们公司制作了，不过这次又额外增加了一个新需
* 求：汽车的启动、停止、喇叭声音、引擎声音都有客户自己控制，他想什么顺序就什么顺序，这个没问题吧?”。
*
* 看着老大殷切的目光，我还能说啥，肯定的点头，“没问题！”，加班加点做呗，“再苦再累就当自己二
* 百五 再难再险就当自己二皮脸 与君共勉！”这句话说出了我的心声。那任务是接下来，我们怎么做实现呢？
*
* 首先我们想了，奔驰、宝马都是一个产品，他们有共有的属性，牛叉公司关心的是单个模型，奔驰模
* 型A 是先有引擎声音，然后再启动；奔驰模型B 呢是先启动起来，然后再有引擎声音，这才是牛叉公司要
* 关关心的，那到我们老大这边呢，就是满足人家的要求，要什么顺序就立马能产生什么顺序的模型出来，
* 我呢就负责把老大的要求实现掉，而且还要是批量的，看不懂？没关系，继续看下去，首先由我生产出N
* 多个奔驰和宝马车辆模型，这些车辆模型的都有run 方法，但是具体到每一个模型的run 方法可能中间的
* 执行任务的顺序是不同的，老大说要啥顺序，我就给啥顺序，最终客户买走后只能是既定的模型。
*/

//我们定义了一个CarModel 的抽象类，其中run 和setSequence 是由抽象类实现的，其他都是子类自己
//实现，那这个是否可以解决这个问题呢?应该可以，我们把代码实现出来，先看CarModel类：

/**
* 定义一个车辆模型的抽象类，所有的车辆模型都继承这里类
*/
abstract class CarModel {
    /**
     * 定义action关键字
     */
    const ACTION_START = 'start';
    const ACTION_STOP = 'stop';
    const ACTION_ALARM = 'alarm';
    const ACTION_ENGINEBOOM = 'engineBoom';
    
    
    /**
     * 这个参数是各个基本方法执行的顺序
     */
    protected $sequence = array();
    
    /**
     * 模型是启动开始跑了
     */
    protected abstract function start();
    
    /**
     * 能发动，那还要能停下来，那才是真本事
     */
    protected abstract function stop();
    
    /**
     * 喇叭会出声音，是滴滴叫，还是哔哔叫
     */
    protected abstract function alarm();
    
    /**
     * 引擎会轰隆隆的响，不响那是假的
     */
    protected abstract function engineBoom();
    
    /**
     * 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
     */
    final public function run() {
        //循环一遍，谁在前，就先执行谁
        foreach ($this->sequence as $actionName){
            if(self::ACTION_START == $actionName){ //如果是start关键字，
                $this->start(); //开启汽车
            }else if(self::ACTION_STOP == $actionName){ //如果是stop关键字
                $this->stop(); //停止汽车
            }else if(self::ACTION_ALARM == $actionName){ //如果是alarm关键字
                $this->alarm(); //喇叭开始叫了
            }else if(self::ACTION_ENGINEBOOM == $actionName){ //如果是engine boom关键字
                $this->engineBoom(); //引擎开始轰鸣
            }
        }
    }

    final public function setSequence($sequence){
        $this->sequence = (array) $sequence;
    }
}    

/**
* 其中setSequence 方法是允许客户自己设置一个顺序，是要先跑起来在有引擎声音还是先有引擎声音再
* 跑起来，还是说那个喇叭就不要响，对于一个具体的模型永远都固定的，那这个事由牛叉告诉我们，有1W 件事
* 这样的，1W 件事那样的顺序，目前的设计都能满足这个要求。
*
* run 方法使用了一个数组的遍历，确定那个是先执行，程序比较简单，不多说了，我们继续看两个实现类，
* 先看BenzModel类：
*/


// 增加了一个CarBuilder 的抽象类，以及两个实现类，其目的是你要什么排列顺序的车，我就给你什么顺
// 序的车，那我们先看CarBuilder类：

/**
* 要什么顺序的车，你说，我给建造出来
*/
abstract class CarBuilder {
    /**
     * 建造一个模型，你要给我一个顺序要，就是组装顺序
     */
    public abstract function setSequence(array $sequence);
    
    /**
     * 设置完毕顺序后，就可以直接拿到这个车辆模型
     */
    public abstract function getCarModel();
}


/**
* 奔驰车模型
*/
class BenzModel extends CarModel {
    protected function alarm() {
        echo "奔驰车的喇叭声音是这个样子的...<br>";
    }

    protected function engineBoom() {
        echo "奔驰车的引擎是这个声音的...<br>";
    }

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

    protected function stop() {
        echo "奔驰车应该这样停车...<br>";
    }
}


// 没啥特别的，不多说，再看BMWModel类：

/**
* 宝马车模型
*/
class BMWModel extends CarModel {
    protected function alarm() {
        echo "宝马车的喇叭声音是这个样子的...<br>";
    }

    protected function engineBoom() {
        echo "宝马车的引擎是这个声音的...<br>";
    }

    protected function start() {
        echo "宝马车跑起来是这个样子的...<br>";
    }
    
    protected function stop() {
        echo "宝马车应该这样停车...<br>";
    }
}

// 这个抽象类比较简单，程序上也以后注释说明，不多说，我们看两个实现类，先看BenzBuilder类

/**
* 各种设施都给了，我们按照一定的顺序制造一个奔驰车
*/
class BenzBuilder extends CarBuilder {
    private $benzModel = null;

    function __construct(){
        $this->benzModel = new BenzModel();
    }
    
    public function getCarModel() {
        return $this->benzModel;
    }

    public function setSequence(array $sequence) {
        $this->benzModel->setSequence($sequence);
    }
}

// 下面是BMWBuilder类:

/**
* 给定一个顺序，返回一个宝马车
*/
class BMWBuilder extends CarBuilder {
    private $BMWModel = null;

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

    public function setSequence(array $sequence) {
        $this->BMWModel->setSequence($sequence);
    }
}


/**
* 增加了Director 类，这个类是做了层封装，类中的方法说明如下：
* A 型号的奔驰车辆模型是只有启动（start）、停止(stop)方法，其他的引擎声音、喇叭都没有;
* B 型号的奔驰车是先发动引擎（engine boom）,然后启动(star),再然后停车(stop),没有喇叭；
* C 型号的宝马车是先喇叭叫一下（alarm），然后（start）,再然后是停车(stop)，引擎不轰鸣；
* D 型号的宝马车就一个启动(start)，然后一路跑到黑，永动机，没有停止方法，没有喇叭，没有引擎轰鸣；
* E 型号、F 型号…等等，可以有很多，启动(start)、停止(stop)、喇叭(alarm)、引擎轰鸣(engine boom)
* 这四个方法在这个类中可以随意的自由组合，有几种呢？好像是排列组合，这个不会算，高中数学没学好，反正
* 有很多种了，这里都可以实现。
*
* 我们看一下代码实现，Director类：
*/


/**
* 导演安排顺序，生产车辆模型
*/
class Director {
    private $sequence = array();
    private $benzBuilder = null;
    private $bmwBuilder = null;
    
    function __construct(){
        $this->benzBuilder = new BenzBuilder();
        
        $this->bmwBuilder = new BMWBuilder();
    
        $this->clearEnv();
    }

    /**
     * 初始化环境
     */
    private function clearEnv(){
        $this->sequence = array();
    }
    
    /**
     * A类型的奔驰车模型，先start,然后stop,其他什么引擎了，喇叭一概没有
     */
    public function getABenzModel(){
        //清理场景，这里是一些初级程序员不注意的地方
        $this->clearEnv();
        
        //这只ABenzModel的执行顺序
        array_push($this->sequence, CarModel::ACTION_START, CarModel::ACTION_STOP);
        
        //按照顺序返回一个奔驰车
        $this->benzBuilder->setSequence($this->sequence);
        
        return $this->benzBuilder->getCarModel();
    }
    
    /**
     * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭
     */
    public function getBBenzModel(){
        //清理场景，这里是一些初级程序员不注意的地方
        $this->clearEnv();
        
        //这只BBenzModel的执行顺序
        array_push($this->sequence, CarModel::ACTION_ENGINEBOOM, CarModel::ACTION_START, CarModel::ACTION_STOP);
        
        //按照顺序返回一个奔驰车
        $this->benzBuilder->setSequence($this->sequence);
        
        return $this->benzBuilder->getCarModel();
    }
    
    /**
     * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止
     */
    public function getCBMWModel(){
        //清理场景，这里是一些初级程序员不注意的地方
        $this->clearEnv();
        
        //这只CBMWModel的执行顺序
        array_push($this->sequence, CarModel::ACTION_ALARM, CarModel::ACTION_START, CarModel::ACTION_STOP);
        
        //按照顺序返回一个奔驰车
        $this->bmwBuilder->setSequence($this->sequence);
        
        return $this->bmwBuilder->getCarModel();
    }
    
    /**
     * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止，牛叉
     */
    public function getDBMWModel(){
        //清理场景，这里是一些初级程序员不注意的地方
        $this->clearEnv();
        
        //这只CBMWModel的执行顺序
        array_push($this->sequence, CarModel::ACTION_START);
        
        //按照顺序返回一个奔驰车
        $this->bmwBuilder->setSequence($this->sequence);
        
        return $this->bmwBuilder->getCarModel();
    }
    
    /**
     * 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛
     * 导演类嘛，按照什么顺序是导演说了算
     */
}


// 然后Client程序就只与Director 打交道了，牛叉公司要A 类型的奔驰车2辆，B 类型的奔驰车2辆，
// C 类型的宝马车2辆，D 类型的我不要：

// 这里是牛叉公司的天下，他要啥我们给啥，下面即Client程序：

$director = new Director();

//2辆A类型的奔驰车
echo "2辆A类型的奔驰车<br>";
for($i=0; $i<2; $i++){
    $director->getABenzModel()->run();
}

//2辆B类型的奔驰车
echo "<br>";
echo "2辆B类型的奔驰车<br>";
for($i=0; $i<2; $i++){
    $director->getBBenzModel()->run();
}

//2辆C类型的宝马车
echo "<br>";
echo "2辆C类型的宝马车<br>";
for($i=0; $i<2; $i++){
    $director->getCBMWModel()->run();
}

/**
* 整个程序编写完毕，而且简洁明了，这就是建造者模式，中间有几个角色需要说明一下：
*
* Client 就是牛叉公司，这个到具体的应用中就是其他的模块或者页面；
*
* CarModel 以及两个实现类BenzModel 和BMWModel 叫做产品类(Product Class)，这个产品类实现
* 了模板方法模式，也就是有模板方法和基本方法，这个参考上一节的模板方法模式；
*
* CarBuilder 以及两个实现类BenzBuilder 和BMWBuilder 叫做建造者(Builder Class)，在上面的
* 那个例子中就是我和我的团队，负责建造Benz 和BMW 车模，按照指定的顺序；
*
* Director 类叫做导演类(Director Class),负责安排已有模块的顺序，然后告诉Builder 开始建造，
* 在上面的例子中就是我们的老大，Client 找到老大，说我要这个，这个，那个类型的车辆模型，然后老大就把
* 命令传递给我，我和我的团队就开始拼命的建造，于是一个项目建设完毕了。
*
* 大家看到这里估计就开始犯嘀咕了，这个建造者模式和工厂模式非常相似呀，Yes，是的，是非常相似，但
* 是记住一点你就可以游刃有余的使用了：建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方
* 法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。

*/

运行结果：

2辆A类型的奔驰车
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...

2辆B类型的奔驰车
奔驰车的引擎是这个声音的...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...
奔驰车的引擎是这个声音的...
奔驰车跑起来是这个样子的...
奔驰车应该这样停车...

2辆C类型的宝马车
宝马车的喇叭声音是这个样子的...
宝马车跑起来是这个样子的...
宝马车应该这样停车...
宝马车的喇叭声音是这个样子的...
宝马车跑起来是这个样子的...
宝马车应该这样停车...