当前位置：首页 > PHP教程 > php高级应用 > 列表

PHP设计模式之建造者模式（Builder）原理与用法案例详解

发布:smiling　来源: PHP粉丝网 　添加日期：2022-01-28 10:33:38　浏览: 评论：0　

本文实例讲述了PHP设计模式之建造者模式（Builder）原理与用法，分享给大家供大家参考，具体如下：

这个建造者模式，我们也可以称为生成器模式，核心思想是将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式，简单点来说就是为了消除其它对象复杂的创建过程。

例如：汽车，他的发动机引擎有好多品牌，轮胎也有各种材质，内饰更是千奇百怪；鸟，他的头、翅膀以及脚有各种颜色和形状，在创建这种复杂对象的时候，我们建议使用建造者模式。

先来看一个案例来感受下什么是建造者模式：

有一个用户的UserInfo类，创建这个类，需要创建用户的姓名，年龄，金钱等信息，才能获得用户具体的信息结果。

创建一个UserInfoBuilder 用户建造者类，这个类，将UserInfo复杂的创建姓名，年龄，金钱等操作封装起来，简化用户类的创建过程

完事代码如下：

  1. //建造者模式，目的是消除其它对象复杂的创建过程 
  2. /* 描述一个用户的类，包含用户姓名，年龄，金钱 */ 
  3. class UserInfo { 
  4.     protected $userName = '';  
  5.     protected $userAge = ''; 
  6.     protected $userMoney = ''; 
  7.     public function setUserName($userName) { 
  8.         $this->userName = $userName; 
  9.     } 
  10.     public function setUserAge($userAge) { 
  11.         $this->userAge = $userAge; 
  12.     } 
  13.     public function setUserMoney($userMoney) { 
  14.         $this->userMoney = $userMoney; 
  15.     } 
  16.     public function getPeople() { 
  17.         echo "这个人的姓名是：" . $this->setUserName . ',年龄是：' . $this->userAge . ', 金钱：' . $this->userMoney; 
  18.     } 
  19. } 
  20. /* 实例化，并且创建这个用户的时候，是很痛苦的，需要设置用户名，年龄和金钱*/ 
  21. $peopleInfo = array( 
  22.     'userName' => 'initphp', 
  23.     'userAge' => 28, 
  24.     'userMoney' => '100元' 
  25.     ); 
  26. $UserInfo = new UserInfo; 

下面需要一步步的设置用户信息，才能得到用户详细信息，过程纠结而痛苦

$UserInfo->setUserName($peopleInfo['userName']);

$UserInfo->setUserAge($peopleInfo['userAge']);

$UserInfo->setUserMoney($peopleInfo['userMoney']);

$UserInfo->getPeople();

UserInfoBuilder 用户信息建造者类，将UserInfo的创建过程封装掉，开发者使用起来心情舒畅

  1. <?php 
  2. //建造者模式，目的是消除其它对象复杂的创建过程 
  3. include("UserInfo.php"); 
  4. class UserInfoBuilder { 
  5.     protected $obj; 
  6.     public function __construct() { 
  7.         $this->obj = new UserInfo; 
  8.     } 
  9.     public function buildPeople($peopleInfo) { 
  10.         $this->obj->setUserName($peopleInfo['userName']); 
  11.         $this->obj->setUserAge($peopleInfo['userAge']); 
  12.         $this->obj->setUserMoney($peopleInfo['userMoney']); 
  13.     }  
  14.     public function getPeople() { 
  15.         $this->obj->getPeople(); 
  16.     } 
  17. } 
  18. /* 创建过程被封装了，用户使用简单了 */ 
  19. $peopleInfo = array( 
  20.     'userName' => 'initphp', 
  21.     'userAge' => 28, 
  22.     'userMoney' => '100元' 
  23.     ); 
  24. $UserInfoBuilder = new UserInfoBuilder; 
  25. $UserInfoBuilder->buildPeople($peopleInfo); //直接一个build 
  26. $UserInfoBuilder->getPeople(); 

大概了解了之后，咱们就来继续看。

一般情况下，建造者模式一般有以下四种角色：

1.产品角色，产品角色定义自身的组成属性

2.抽象建造者，抽象建造者定义了产品的创建过程以及如何返回一个产品

3.具体建造者，具体建造者实现了抽象建造者创建产品过程的方法，给产品的具体属性进行赋值定义

4.指挥者，指挥者负责与调用客户端交互，决定创建什么样的产品

这四个角色也可以按照如下方式来理解：

抽象建造者(Builder)角色：定义一个抽象接口，规范产品各个组成成分的建造（即规范具体建造者的方法实现）。其中所规范的方法中必须包括建造方法和结果返回方法

具体建造者(ConcreteBuilder)角色：实现抽象建造者角色所定义的方法。具体建造者与业务逻辑关联性较大，应用程序最终会通过调用此角色中所实现的建造方法按照业务逻辑创建产品，在建造完成后通过结果返回方法返回建造的产品实例。一般在外部由客户或一个抽象工厂创建。

导演者(Director)角色：此角色的作用是调用具体的建造者角色建造产品。导演者与产品类没有直接关系，与产品类交谈的是具体抽象角色。

产品(Product)角色：在指导者的指导下由建造者所创建的那个复杂的对象导演者角色与客户端直接打交道，它理解客户端的业务逻辑，将客户端创建产品的请求拆分成对产品组成部分的请求，然后调用具体产品角色执行建造操作。它分离了客户端与具体建造者。

再来看个实例：

  1. <?php 
  2. /** 
  3.  * Created by PhpStorm. 
  4.  * User: Jiang 
  5.  * Date: 2015/4/25 
  6.  * Time: 9:31 
  7.  */ 
  8. /**具体产品角色 鸟类 
  9.  * Class Bird 
  10.  */ 
  11. class Bird 
  12. { 
  13.   public $_head; 
  14.   public $_wing; 
  15.   public $_foot; 
  16.   function show() 
  17.   { 
  18.     echo "头的颜色:{$this->_head}<br/>"; 
  19.     echo "翅膀的颜色:{$this->_wing}<br/>"; 
  20.     echo "脚的颜色:{$this->_foot}<br/>"; 
  21.   } 
  22. } 
  23. /**抽象鸟的建造者(生成器) 
  24.  * Class BirdBuilder 
  25.  */ 
  26. abstract class BirdBuilder 
  27. { 
  28.   protected $_bird; 
  29.   function __construct() 
  30.   { 
  31.     $this->_bird=new Bird(); 
  32.   } 
  33.   abstract function BuildHead(); 
  34.   abstract function BuildWing(); 
  35.   abstract function BuildFoot(); 
  36.   abstract function GetBird(); 
  37. } 
  38. /**具体鸟的建造者(生成器)  蓝鸟 
  39.  * Class BlueBird 
  40.  */ 
  41. class BlueBird extends BirdBuilder 
  42. { 
  43.   function BuildHead() 
  44.   { 
  45.     // TODO: Implement BuilderHead() method. 
  46.     $this->_bird->_head="Blue"; 
  47.   } 
  48.   function BuildWing() 
  49.   { 
  50.     // TODO: Implement BuilderWing() method. 
  51.     $this->_bird->_wing="Blue"; 
  52.   } 
  53.   function BuildFoot() 
  54.   { 
  55.     // TODO: Implement BuilderFoot() method. 
  56.     $this->_bird->_foot="Blue"; 
  57.   } 
  58.   function GetBird() 
  59.   { 
  60.     // TODO: Implement GetBird() method. 
  61.     return $this->_bird; 
  62.   } 
  63. } 
  64. /**玫瑰鸟 
  65.  * Class RoseBird 
  66.  */ 
  67. class RoseBird extends BirdBuilder 
  68. { 
  69.   function BuildHead() 
  70.   { 
  71.     // TODO: Implement BuildHead() method. 
  72.     $this->_bird->_head="Red"; 
  73.   } 
  74.   function BuildWing() 
  75.   { 
  76.     // TODO: Implement BuildWing() method. 
  77.     $this->_bird->_wing="Black"; 
  78.   } 
  79.   function BuildFoot() 
  80.   { 
  81.     // TODO: Implement BuildFoot() method. 
  82.     $this->_bird->_foot="Green"; 
  83.   } 
  84.   function GetBird() 
  85.   { 
  86.     // TODO: Implement GetBird() method. 
  87.     return $this->_bird; 
  88.   } 
  89. } 
  90. /**指挥者 
  91.  * Class Director 
  92.  */ 
  93. class Director 
  94. { 
  95.   /** 
  96.    * @param $_builder   建造者 
  97.    * @return mixed     产品类：鸟 
  98.    */ 
  99.   function Construct($_builder) 
  100.   { 
  101.     $_builder->BuildHead(); 
  102.     $_builder->BuildWing(); 
  103.     $_builder->BuildFoot(); 
  104.     return $_builder->GetBird(); 
  105.   } 
  106. } 
  107. //调用代码 
  108. header("Content-Type:text/html;charset=utf-8"); 
  109. //------------------------生成器模式测试代码------------------ 
  110. require_once "./Builder/Builder.php"; 
  111. $director=new Director(); 
  112. echo "蓝鸟的组成：<hr/>"; 
  113. $blue_bird=$director->Construct(new BlueBird()); 
  114. $blue_bird->Show(); 
  115. echo "<br/>Rose鸟的组成：<hr/>"; 
  116. $rose_bird=$director->Construct(new RoseBird()); 
  117. $rose_bird->Show(); 

建造者模式它的优点很明显，就是它可以很好的将一个对象的实现与相关的“业务”逻辑分离开来，从而可以在不改变事件逻辑的前提下,使增加(或改变)实现变得非常容易，缺点也是同样，那就是建造者接口的修改会导致所有执行类的修改。

关于这个建造者模式，它还有以下三个扩展模式：

抽象工厂模式(abstract factory模式)：在抽象工厂模式中，每一次工厂对象被调用时都会返还一个完整的产品对象，而客户端可能会将这些产品组装成一个更大更复杂的产品，也可能不会。建造者模式则不同，它一点一点地建造出一个复杂的产品，而这个产品的组装过程发生在建造者内部。二者的区别在于是否有组装过程，组装过程发生的位置。这两个设计模式可以连起来用，客户端通过调用一个建造角色，间接调用另一个抽象工厂模式的工厂角色。工厂模式返还不同产品族的零件，而建造者模式则把它们组装起来。

策略模式(strategy模式)：建造者模式在结构上很接近于策略模式，事实上建造者模式是策略模式的一种特殊情况。二者的区别在于用意不同。建造者模式作用于客户端一点一点的建造新的对象，而策略模式的目的是为算法提供抽象的接口。

建造者模式与模板方法模式：建造者模式在退化、失去导演者角色后，可以发展到模板方法模式(即将建造过程的算法实现放在建造角色中)。

以下情况应当使用建造者模式：

1、 需要生成的产品对象有复杂的内部结构。

2、 需要生成的产品对象的属性相互依赖，建造者模式可以强迫生成顺序。

3、 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

使用建造者模式主要有以下效果：

1、 建造者模式的使用使得产品的内部表象可以独立的变化。使用建造者模式可以使客户端不必知道产品内部组成的细节。

2、 每一个Builder都相对独立，而与其它的Builder无关。

3、 模式所建造的最终产品更易于控制。

咱们接下来，来尝试设计一个车的组装过程，这个是网上经典的案例，如下：

  1. <?php 
  2. /**  
  3.  * 建造者模式 
  4.  */ 
  5. //需要建造的产品(product) 
  6. class Car 
  7. {/*{{{*/ 
  8.   public $name; 
  9.   public $engine;//发动机 
  10.   public $chassis;//底盘 
  11.   public $body;//车身 
  12.   public $equipment;//电器设备 
  13.   public function setName($name) 
  14.   { 
  15.     $this->name = $name; 
  16.   } 
  17.   public function setEngine($engine) 
  18.   { 
  19.     $this->engine = $engine; 
  20.   } 
  21.   public function setChassis($chassis) 
  22.   { 
  23.     $this->chassis = $chassis; 
  24.   } 
  25.   public function setBody($body) 
  26.   { 
  27.     $this->body = $body; 
  28.   } 
  29.   public function setEquipment($equipment) 
  30.   { 
  31.     $this->equipment = $equipment; 
  32.   } 
  33.   public function show() 
  34.   { 
  35.     echo "名称:".$this->name."\r\n"; 
  36.     echo "引擎:".$this->engine."\r\n"; 
  37.     echo "底盘:".$this->chassis."\r\n"; 
  38.     echo "车身:".$this->body."\r\n"; 
  39.     echo "电子设备:".$this->equipment."\r\n"; 
  40.   } 
  41. }/*}}}*/ 
  42. //builder 
  43. interface IBuilder 
  44. {/*{{{*/ 
  45.   public function builderName(); 
  46.   public function builderEngine(); 
  47.   public function builderChassis(); 
  48.   public function builderBody(); 
  49.   public function builderEquipment(); 
  50.   public function getCar(); 
  51. }/*}}}*/ 
  52. //红旗车builder 
  53. class RedBuilder implements IBuilder 
  54. {/*{{{*/ 
  55.   public $car; 
  56.   public function __construct() 
  57.   { 
  58.     $this->car = new Car(); 
  59.   } 
  60.   public function builderName() 
  61.   { 
  62.     $this->car->setName('红旗');  
  63.   } 
  64.   public function builderEngine() 
  65.   { 
  66.     $this->car->setEngine('国产发动机');  
  67.   } 
  68.   public function builderChassis() 
  69.   { 
  70.     $this->car->setChassis('超大底盘');  
  71.   } 
  72.   public function builderBody() 
  73.   { 
  74.     $this->car->setBody('超大');  
  75.   } 
  76.   public function builderEquipment() 
  77.   { 
  78.     $this->car->setEquipment('电子设备');  
  79.   } 
  80.   public function getCar() 
  81.   { 
  82.     return $this->car; 
  83.   } 
  84. }/*}}}*/ 
  85. //QQ车builder 
  86. class QQBuilder implements IBuilder 
  87. {/*{{{*/ 
  88.   public $car; 
  89.   public function __construct() 
  90.   { 
  91.     $this->car = new Car(); 
  92.   } 
  93.   public function builderName() 
  94.   { 
  95.     $this->car->setName('QQ');  
  96.   } 
  97.   public function builderEngine() 
  98.   { 
  99.     $this->car->setEngine('国产发动机');  
  100.   } 
  101.   public function builderChassis() 
  102.   { 
  103.     $this->car->setChassis('小底盘');  
  104.   } 
  105.   public function builderBody() 
  106.   { 
  107.     $this->car->setBody('小');  
  108.   } 
  109.   public function builderEquipment() 
  110.   { 
  111.     $this->car->setEquipment('电子设备');  
  112.   } 
  113.   public function getCar() 
  114.   { 
  115.     return $this->car; 
  116.   } 
  117. }/*}}}*/ 
  118. //组装者(director) 
  119. class CarDirector 
  120. {/*{{{*/ 
  121.   public function make(IBuilder $builder) 
  122.   { 
  123.     $builder->builderName(); 
  124.     $builder->builderEngine(); 
  125.     $builder->builderChassis(); 
  126.     $builder->builderBody(); 
  127.     $builder->builderEquipment(); 
  128.     return $builder->getCar(); 
  129.   } 
  130. }/*}}}*/ 
  131. class Client 
  132. {/*{{{*/ 
  133.   public static function main($argv) 
  134.   { 
  135.     $director = new CarDirector();  
  136.     $redBuilder = new RedBuilder(); 
  137.     $car = $director->make($redBuilder); 
  138.     $car->show(); 
  139.     echo "\r\n"; 
  140.     $qqBuilder = new QQBuilder(); 
  141.     $car = $director->make($qqBuilder); 
  142.     $car->show(); 
  143.   } 
  144. }/*}}}*/ 
  145. Client::main($argv); 
  146. ?> 

咱们可以观察到，建造者模式与工厂模式是极为相似的，并且总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色，在建造者模式中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。

与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

好啦，本次记录就到这里了。

Tags: PHP建造者模式 Builder

分享到：

推荐文章

热门文章

最新评论文章