学点设计模式-建造者模式

建造者模式

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

首先我们想了，奔驰、宝马都是一个产品，他们有共有的属性，牛叉公司关心的是单个模型，奔驰模
型A 是先有引擎声音，然后再启动；奔驰模型B 呢是先启动起来，然后再有引擎声音，这才是牛叉公司要
关关心的，那到我们老大这边呢，就是满足人家的要求，要什么顺序就立马能产生什么顺序的模型出来，
我呢就负责把老大的要求实现掉，而且还要是批量的，看不懂？没关系，继续看下去，首先由我生产出N
多个奔驰和宝马车辆模型，这些车辆模型的都有run 方法，但是具体到每一个模型的run 方法可能中间的
执行任务的顺序是不同的，老大说要啥顺序，我就给啥顺序，最终客户买走后只能是既定的模型，还是没
听明白，我们继续，我们先把我们最基本的对象Product 在类图中表明出来：

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

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 定义一个车辆模型的抽象类，所有的车辆模型都继承这里类 */public abstract class CarModel {// 这个参数是各个基本方法执行的顺序private ArrayList<String> sequence = new ArrayList<String>();/* * 模型是启动开始跑了 */protected abstract void start();// 能发动，那还要能停下来，那才是真本事protected abstract void stop();// 喇叭会出声音，是滴滴叫，还是哔哔叫protected abstract void alarm();// 引擎会轰隆隆的响，不响那是假的protected abstract void engineBoom();// 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑final public void run() {// 循环一遍，谁在前，就先执行谁for (int i = 0; i < this.sequence.size(); i++) {String actionName = this.sequence.get(i);if (actionName.equalsIgnoreCase("start")) { // 如果是start关键字，this.start(); // 开启汽车} else if (actionName.equalsIgnoreCase("stop")) { // 如果是stop关键字this.stop(); // 停止汽车} else if (actionName.equalsIgnoreCase("alarm")) { // 如果是alarm关键字this.alarm(); // 喇叭开始叫了} else if (actionName.equalsIgnoreCase("engine boom")) { // 如果是engine// boom关键字this.engineBoom(); // 引擎开始轰鸣}}}// 把传递过来的值传递到类内final public void setSequence(ArrayList<String> sequence) {this.sequence = sequence;}}

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

package com.cbf4life.BuilderPattern;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 奔驰车模型 */public class BenzModel extends CarModel {@Overrideprotected void alarm() {System.out.println("奔驰车的喇叭声音是这个样子的...");}@Overrideprotected void engineBoom() {System.out.println("奔驰车的引擎是这个声音的...");}@Overrideprotected void start() {System.out.println("奔驰车跑起来是这个样子的...");}@Overrideprotected void stop() {System.out.println("奔驰车应该这样停车...");}}

 

package com.cbf4life.BuilderPattern;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 宝马车模型 */public class BMWModel extends CarModel {@Overrideprotected void alarm() {System.out.println("宝马车的喇叭声音是这个样子的...");}@Overrideprotected void engineBoom() {System.out.println("宝马车的引擎是这个声音的...");}@Overrideprotected void start() {System.out.println("宝马车跑起来是这个样子的...");}@Overrideprotected void stop() {System.out.println("宝马车应该这样停车...");}}

两个实现类都完成，我们再来看牛叉公司要的要求，我先要1 个奔驰的模型，这个模型的要求是跑的时候，
先发动引擎，然后再挂档启动，然后停下来，不需要喇叭，那怎么实现呢：

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 最终客户开始使用这个模型 */public class Client {public static void main(String[] args) {/* * 客户告诉牛叉公司，我要这样一个模型，然后牛叉公司就告诉我老大 说要这样一个模型，这样一个顺序，然后我就来制造 */BenzModel benz = new BenzModel();ArrayList<String> sequence = new ArrayList<String>(); // 存放run的顺序sequence.add("engine boom"); // 客户要求，run的时候时候先发动引擎sequence.add("start"); // 启动起来sequence.add("stop"); // 开了一段就停下来// 然后我们把这个顺序给奔驰车：benz.setSequence(sequence);benz.run();}}

看，满足了牛叉公司的需求了，满足完了，还要下一个需求呀，然后是第2 件宝马模型，只要启动，停止，
其他的什么都不要，第3 件模型，先喇叭，然后启动，然后停止，第4 件...，直到把你逼疯为止，那怎么办？
我们修改程序，满足这种变态需求，好，看我如何修改，先修改类图：

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

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 要什么顺序的车，你说，我给建造出来 */public abstract class CarBuilder {// 建造一个模型，你要给我一个顺序要，就是组装顺序public abstract void setSequence(ArrayList<String> sequence);// 设置完毕顺序后，就可以直接拿到这个车辆模型public abstract CarModel getCarModel();}

 

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 各种设施都给了，我们按照一定的顺序制造一个奔驰车 */public class BenzBuilder extends CarBuilder {private BenzModel benz = new BenzModel();@Overridepublic CarModel getCarModel() {return this.benz;}@Overridepublic void setSequence(ArrayList<String> sequence) {this.benz.setSequence(sequence);}}

 

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 第 88 页 您的设计模式 给定一个顺序，返回一个宝马车 */public class BMWBuilder extends CarBuilder {private BMWModel bmw = new BMWModel();@Overridepublic CarModel getCarModel() {return this.bmw;}@Overridepublic void setSequence(ArrayList<String> sequence) {this.bmw.setSequence(sequence);}}

程序很简单，很实用，这就是我最希望的，简单而又实用，我欣赏这样的程序员。那我们再来看我们
Client.java 程序的修改：

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 最终客户开始使用这个模型 */public class ClientBenzBuilder {public static void main(String[] args) {/* * 客户告诉牛叉公司，我要这样一个模型，然后牛叉公司就告诉我老大 说要这样一个模型，这样一个顺序，然后我就来制造 */ArrayList<String> sequence = new ArrayList<String>(); // 存放run的顺序sequence.add("engine boom"); // 客户要求，run的时候时候先发动引擎sequence.add("start"); // 启动起来sequence.add("stop"); // 开了一段就停下来// 要一个奔驰车：BenzBuilder benzBuilder = new BenzBuilder();// 把顺序给这个builder类，制造出这样一个车出来benzBuilder.setSequence(sequence);// 制造出一个奔驰车BenzModel benz = (BenzModel) benzBuilder.getCarModel();// 奔驰车跑一下看看benz.run();}}

那如果我再想要个同样顺序的宝马车呢？很简单，Client.java 程序如下：

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 最终客户开始使用这个模型 */public class ClientBenzBuilder {public static void main(String[] args) {/* * 客户告诉牛叉公司，我要这样一个模型，然后牛叉公司就告诉我老大 说要这样一个模型，这样一个顺序，然后我就来制造 */ArrayList<String> sequence = new ArrayList<String>(); // 存放run的顺序sequence.add("engine boom"); // 客户要求，run的时候时候先发动引擎sequence.add("start"); // 启动起来sequence.add("stop"); // 开了一段就停下来// 要一个奔驰车：BenzBuilder benzBuilder = new BenzBuilder();// 把顺序给这个builder类，制造出这样一个车出来benzBuilder.setSequence(sequence);// 制造出一个奔驰车BenzModel benz = (BenzModel) benzBuilder.getCarModel();// 奔驰车跑一下看看benz.run();}}

看，是不是比刚开始直接访问产品类(Procuct)简单了很多吧，那这有个这样的需求，这四个过程
（start,stop,alarm,engineBoom）按照排列组合有很多种，那我们怎么满足这种需求呢？也就是要有个类
来安排这几个方法组合，就像导演安排演员一样，那个先出场那个后出场，那个不出场，我们这个也叫导演类，
那我们修改一下类图：

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

package com.cbf4life.BuilderPattern;import java.util.ArrayList;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 导演安排顺序，生产车辆模型 */public class Director {private ArrayList<String> sequence = new ArrayList();private BenzBuilder benzBuilder = new BenzBuilder();private BMWBuilder bmwBuilder = new BMWBuilder();/* * A类型的奔驰车模型，先start,然后stop,其他什么引擎了，喇叭一概没有 */public BenzModel getABenzModel() {// 清理场景，这里是一些初级程序员不注意的地方this.sequence.clear();// 这只ABenzModel的执行顺序this.sequence.add("start");this.sequence.add("stop");// 按照顺序返回一个奔驰车this.benzBuilder.setSequence(this.sequence);return (BenzModel) this.benzBuilder.getCarModel();}/* * B型号的奔驰车模型，是先发动引擎，然后启动，然后停止，没有喇叭 */public BenzModel getBBenzModel() {this.sequence.clear();this.sequence.add("engine boom");this.sequence.add("start");this.sequence.add("stop");this.benzBuilder.setSequence(this.sequence);return (BenzModel) this.benzBuilder.getCarModel();}/* * C型号的宝马车是先按下喇叭（炫耀嘛），然后启动，然后停止 */public BMWModel getCBMWModel() {this.sequence.clear();this.sequence.add("alarm");this.sequence.add("start");this.sequence.add("stop");this.bmwBuilder.setSequence(this.sequence);return (BMWModel) this.bmwBuilder.getCarModel();}/* * D类型的宝马车只有一个功能，就是跑，启动起来就跑，永远不停止，牛叉 */public BMWModel getDBMWModel() {this.sequence.clear();this.sequence.add("start");this.bmwBuilder.setSequence(this.sequence);return (BMWModel) this.benzBuilder.getCarModel();}/* * 这里还可以有很多方法，你可以先停止，然后再启动，或者一直停着不动，静态的嘛 导演类嘛，按照什么顺序是导演说了算 */}

大家看一下程序中有很多this 调用，这个我一般是这样要求项目组成员的，如果你要调用类中的成员变量
或方法，需要在前面加上this 关键字，不加也能正常的跑起来，但是不清晰，加上this 关键字，我就是要调
用本类中成员变量或方法，而不是本方法的中的一个变量，还有super 方法也是一样，是调用父类的的成员变
量或者方法，那就加上这个关键字，不要省略，这要靠约束，还有就是程序员的自觉性，他要是死不悔改，那咱
也没招。
上面每个方法都一个this.sequence.clear()，这个估计你一看就明白，但是做为一个系统分析师或是
技术经理一定要告诉告诉项目成员，ArrayList 和HashMap 如果定义成类的成员变量，那你在方法中调用一
定要做一个clear 的动作，防止数据混乱，这个如果你发生过一次问题的话，比如ArrayList 中出现一个“出
乎意料”的数据，而你又花费了几个通宵才解决这个问题，那你会有很深刻的印象。
然后 Client 程序就只与Director 打交道了，牛叉公司要A 类型的奔驰车1W 辆，B 类型的奔驰车100W
辆，C 类型的宝马车1000W 辆，D 类型的我不要：

package com.cbf4life.BuilderPattern;/** * @author cbf4Life [e-mail] I'm glad to share my knowledge with you *         all. 第 94 页 您的设计模式 这里是牛叉公司的天下，他要啥我们给啥 */public class ClientDirector {public static void main(String[] args) {Director director = new Director();// 1W辆A类型的奔驰车for (int i = 0; i < 10000; i++) {director.getABenzModel().run();}// 100W辆B类型的奔驰车for (int i = 0; i < 1000000; i++) {director.getBBenzModel().run();}// 1000W量C类型的宝马车for (int i = 0; i < 10000000; i++) {director.getCBMWModel().run();}}}

清晰，简单吧，我们写程序重构的最终目的就是这个，简单，清晰，代码是让人看的，不是写完就完事了，
我一直在教育我带的团队，Java 程序不是像我们前辈写那个二进制代码、汇编一样，写完基本上就自己能看懂，
别人看就跟看天书一样，现在的高级语言，要像写中文汉字一样，你写的，别人能看懂。
整个程序编写完毕，而且简洁明了，这就是建造者模式，中间有几个角色需要说明一下：
Client 就是牛叉公司，这个到具体的应用中就是其他的模块或者页面；
CarModel 以及两个实现类BenzModel 和BMWModel 叫做产品类(Product Class)，这个产品类实现
了模板方法模式，也就是有模板方法和基本方法，这个参考上一节的模板方法模式；
CarBuilder 以及两个实现类BenzBuilder 和BMWBuilder 叫做建造者(Builder Class)，在上面的
那个例子中就是我和我的团队，负责建造Benz 和BMW 车模，按照指定的顺序；
Director 类叫做导演类(Director Class),负责安排已有模块的顺序，然后告诉Builder 开始建造，
在上面的例子中就是我们的老大，Client 找到老大，说我要这个，这个，那个类型的车辆模型，然后老大就把
命令传递给我，我和我的团队就开始拼命的建造，于是一个项目建设完毕了。
大家看到这里估计就开始犯嘀咕了，这个建造者模式和工厂模式非常相似呀，Yes，是的，是非常相似，但
第 95 页
您的设计模式
是记住一点你就可以游刃有余的使用了：建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方
法已经实现了；而工厂方法则重点是创建，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。
建造者模式使用的场景，一是产品类非常的复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时
候使用建造者模式是非常合适，我曾在一个银行交易类项目中遇到了这个问题，一个产品的定价计算模型有N 多
种，每个模型有固定的计算步骤，计算非常复杂，项目中就使用了建造者模式；二是“ 在对象创建过程中会使
用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到”，这个是我没有遇到过的，创建过程
中不易得到？那为什么在设计阶段不修正这个问题，创建的时候都不易得到耶！

 

定义与结构
GOF 给建造模式的定义为：将一个复杂对象的构建与它的表示分离，使得同样的构建
过程可以创建不同的表示。这句话说得很抽象，不好理解，其实它的意思可以理解为：将构
造复杂对象的过程和组成对象的部件解耦。就像攒电脑一样，不管什么品牌的配件，只要兼
容就可以装上；同样，一样的配件，可以有好多组装的方式。这是对降低耦合、提高可复用
性精神的一种贯彻。
当要生成的产品有复杂的内部结构——比如由多个对象组成；而系统中对此产品的需求
将来可能要改变产品对象的内部结构的构成，比如说产品的一些属性现在由一个小对象组
成，而更改后的型号可能需要N 个小对象组成；而且不能将产品的内部构造完全暴露给客
户程序，一是为了可用性，二是为了安全等因素。满足上面的设计环境就可以考虑使用建造
模式来搭建框架了。

建造模式的组成
1) 抽象建造者角色：这个角色用来规范产品对象的各个组成成分的建造。一般而言，此角
色独立于应用程序的业务逻辑。
2) 具体建造者角色：担任这个角色的是于应用程序紧密相关的类，它们在指导者的调用下
创建产品实例。这个角色在实现抽象建造者角色提供的方法的前提下，达到完成产品组
装，提供成品的功能。
3) 指导者角色：调用具体建造者角色以创建产品对象。指导者并没有产品类的具体知识，
真正拥有产品类的具体知识的是具体建造者对象。
4) 产品角色：建造中的复杂对象。它要包含那些定义组件的类，包括将这些组件装配成产
品的接口。

应用优点
建造模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表
象是由产品自身来决定的；而在建造模式中则是“外部化”为由建造者来负责。这样定义一个
新的具体建造者角色就可以改变产品的内部表象，符合“开闭原则”。
建造模式使得客户不需要知道太多产品内部的细节。它将复杂对象的组建和表示方式封
装在一个具体的建造角色中，而且由指导者来协调建造者角色来得到具体的产品实例。
每一个具体建造者角色是毫无关系的。
建造模式可以对复杂产品的创建进行更加精细的控制。产品的组成是由指导者角色调用
具体建造者角色来逐步完成的，所以比起其它创建型模式能更好的反映产品的构造过程。

扩展
建造模式中很可能要用到组成成品的各种组件类，对于这些类的创建可以考虑使用工厂
方法或者原型模式来实现，在必要的时候也可以加上单例模式来控制类实例的产生。但是要
坚持一个大前提就是要使引入的模式给你的系统带来好处，而不是臃肿的结构。
建造模式在得到复杂产品的时候可能要引用多个不同的组件，在这一点上来看，建造模
式和抽象工厂模式是相似的。可以从以下两点来区分两者：创建模式着重于逐步将组件装配
成一个成品并向外提供成品，而抽象工厂模式着重于得到产品族中相关的多个产品对象；抽
象工厂模式的应用是受限于产品族的（具体参见《深入浅出工厂模式》），建造模式则不会。
由于建造模式和抽象工厂模式在实现功能上相似，所以两者使用的环境都比较复杂并且
需要更多的灵活性。