【java设计模式】之建造者（Builder）模式

忘是亡心i 2022-06-11 07:59 178阅读 0赞

我们还是举上一节的例子：生产汽车。上一节我们通过[模板方法模式][Link 1]控制汽车跑起来的动作，那么需求是无止境的，现在如果老板又增加了额外的需求：汽车启动、停止、鸣笛引擎声都由客户自己控制，他想要什么顺序就什么顺序，那该如何做呢？

# 1. 汽车无休止的改造 #

假如现在要生产两种车，奔驰和宝马，这两辆车都有共性，我们所需要关注的是单个车的运行过程，这才是老板所关心的点所在。我们先这样想，针对这个需求，我们要找到一个切入点，那就是产品类，每个车都是一个产品，那么在产品类中我们可以控制车的运行顺序，这样每个车都可以拥有自己想要的顺序了。基于此，我们设计如下类图：

![20160505195518510][]

我们看到CarModel中有个setSequence方法，通过传入一个ArrayList来控制运行顺序，run方法根据这个ArrayList中保存的顺序执行，然后奔驰车和宝马车分别继承这个CarModel即可，这貌似是很好的实现，它很像上一节的模板方法模式，只是多了个方法可以设置运行顺序。我们看一下CarModel具体代码的实现：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** CarModel \{  
2.        
3.      **private** ArrayList<String> sequence = **new** ArrayList<String>(); //维护一个ArrayList保存执行命令关键字  
4.        
5.      **protected** **abstract** **void** start();  
6.      **protected** **abstract** **void** stop();  
7.      **protected** **abstract** **void** alarm();  
8.      **protected** **abstract** **void** engineBoom();  
9.        
10.     **final** **public** **void** run() \{  
11.         **for**(**int** i = 0; i < **this**.sequence.size(); i ++) \{ //根据ArrayList中保存的顺序执行相应的动作  
12.             String actionName = **this**.sequence.get(i);  
13.             **if**(actionName.equalsIgnoreCase("start")) \{  
14.                 **this**.start(); //启动汽车  
15.             \} **else** **if**(actionName.equalsIgnoreCase("stop")) \{  
16.                 **this**.stop(); //停止汽车  
17.             \} **else** **if**(actionName.equalsIgnoreCase("alarm")) \{  
18.                 **this**.alarm(); //汽车鸣笛  
19.             \} **else** **if**(actionName.equalsIgnoreCase("engine boom")) \{  
20.                 **this**.engineBoom(); //汽车轰鸣  
21.             \}  
22.         \}  
23.     \}  
24.       
25.     **final** **public** **void** setSequence(ArrayList<String> sequence) \{ //获得执行顺序的命令，即一个ArrayList  
26.         **this**.sequence = sequence;  
27.     \}  
28. \}

CarModel中的setSequence方法允许客户自己设置一个顺序，我们看看子类的实现：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** BenzModel **extends** CarModel \{  
2.    
3.      @Override  
4.      **protected** **void** start() \{  
5.          System.out.println("奔驰启动……");  
6.      \}  
7.    
8.      @Override  
9.      **protected** **void** stop() \{  
10.         System.out.println("奔驰停止……");  
11.     \}  
12.   
13.     @Override  
14.     **protected** **void** alarm() \{  
15.         System.out.println("奔驰鸣笛……");  
16.     \}  
17.   
18.     @Override  
19.     **protected** **void** engineBoom() \{  
20.         System.out.println("奔驰轰鸣");  
21.     \}  
22.   
23. \}  
24. //宝马就略了……一样的

下面我们增加一个测试类实现该需求：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** Client \{  
2.    
3.      **public** **static** **void** main(String\[\] args) \{  
4.          BenzModel benz = **new** BenzModel();  
5.          //存放run顺序  
6.          ArrayList<String> sequence = **new** ArrayList<String>();  
7.          sequence.add("engine boom"); //老板说：跑之前先轰鸣比较帅！  
8.          sequence.add("start");  
9.          sequence.add("stop");  
10.         //我们把这个顺序赋予奔驰  
11.         benz.setSequence(sequence);  
12.         benz.run();  
13.     \}  
14. \}

这样好像已经顺利完成了任务了，但是别忘了，我们这只是满足了一个需求，如果下一个需求是宝马车只轰鸣，再下一个需求是奔驰车只跑不停……等等……那岂不是要一个个写测试类来实现？显然这不是我们想要的。

我们可以这样做：为每种产品模型定义一个建造者，你要啥顺序直接告诉建造者，由建造者来建造即可，于是我们重新设计类图：

![20160505201832734][]

我们增加了一个CarBuilder类，由它来组装各个车模型，要什么类型的顺序就由相关的子类去完成即可，我们来看看CarBuilder的代码：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **abstract** **class** CarBuilder \{  
2.      //建造一个模型，你要给我一个顺序要求  
3.      **public** **abstract** **void** setSequence(ArrayList<String> sequence);  
4.      //设置完毕顺序后，就可以直接拿到这个车辆模型了  
5.      **public** **abstract** CarModel getCarModel();  
6.  \}

很简单，每个车辆模型都要有确定的运行顺序，然后才能返回一个车辆模型，奔驰车和宝马车组装者的代码如下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** BenzBuilder **extends** CarBuilder \{  
2.    
3.      **private** BenzModel benz = **new** BenzModel(); //奔驰车模型  
4.        
5.      @Override  
6.      **public** **void** setSequence(ArrayList<String> sequence) \{  
7.          **this**.benz.setSequence(sequence); //设置奔驰车模型的运行顺序  
8.      \}  
9.    
10.     @Override  
11.     **public** CarModel getCarModel() \{  
12.         **return** **this**.benz; //将这个模型返回  
13.     \}  
14. \}  
15. //宝马车一样，不写了……

现在两辆车的组装者都写好了，现在我们写一个测试类来测试一下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** Client \{  
2.    
3.      **public** **static** **void** main(String\[\] args) \{  
4.    
5.          //存放run顺序  
6.          ArrayList<String> sequence = **new** ArrayList<String>();  
7.          sequence.add("engine boom");  
8.          sequence.add("start");  
9.          sequence.add("stop");  
10.         //要用这个顺序造一辆奔驰  
11.         BenzBuilder benzBuilder = **new** BenzBuilder();  
12.         //把顺序给奔驰组装者  
13.         benzBuilder.setSequence(sequence);  
14.         //奔驰组装者拿到顺序后就给你生产一辆来  
15.         BenzModel benz = (BenzModel) benzBuilder.getCarModel();  
16.         benz.run();  
17.     \}  
18.   
19. \}

如果我要生产一辆宝马车，只需要换成宝马车的组装者即可，这样我们不用直接访问产品类了，全部访问组装者就行，是不是感觉到很方便，我管你怎么生产，我扔给你个顺序，你给我弄辆车出来，要的就是这种效果！

可是人的需求是个无底洞，特别是老板，他哪天不爽了，又要换顺序，这样还是挺麻烦的，四个过程（start、stop、alarm、engine boom）按排列组合也有很多中情况，我们不能保证老板想要哪种顺序，咋整？无奈，我们只能使出最后的杀手锏了，找个设计师过来指挥各个时间的先后顺序，然后为每种顺序指定一个代码，你说一种我们立刻就给你生产！我们再修改一下类图……

![20160505203715252][]

类图看着有点复杂，其实不然，只是在原来的基础上增加了一个Director类充当着设计师的角色，负责按照指定的顺序生产模型，比如我们要一个A顺序的奔驰车，B顺序的奔驰车，A顺序的宝马车，B顺序的宝马车……等等，我们来看下Director类的代码：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** Director \{  
2.      **private** ArrayList<String> sequence = **new** ArrayList<String>();  
3.      **private** BenzBuilder benzBuilder = **new** BenzBuilder();  
4.      **private** BWMBuilder bwmBuilder = **new** BWMBuilder();  
5.        
6.      //A顺序的奔驰车  
7.      **public** BenzModel getABenzModel() \{  
8.          **this**.sequence.clear();  
9.          **this**.sequence.add("start");  
10.         **this**.sequence.add("stop");  
11.         //返回A顺序的奔驰车  
12.         **this**.benzBuilder.setSequence(sequence);  
13.         **return** (BenzModel) **this**.benzBuilder.getCarModel();  
14.     \}  
15.       
16.     //B顺序的奔驰车  
17.     **public** BenzModel getBBenzModel() \{  
18.         **this**.sequence.clear();  
19.         **this**.sequence.add("engine boom");  
20.         **this**.sequence.add("start");  
21.         **this**.sequence.add("stop");  
22.         //返回B顺序的奔驰车  
23.         **this**.benzBuilder.setSequence(sequence);  
24.         **return** (BenzModel) **this**.benzBuilder.getCarModel();  
25.     \}  
26.       
27.     //C顺序的宝马车  
28.     **public** BenzModel getCBWMModel() \{  
29.         **this**.sequence.clear();  
30.         **this**.sequence.add("start");  
31.         **this**.sequence.add("alarm");  
32.         **this**.sequence.add("stop");  
33.         //返回C顺序的宝马车  
34.         **this**.bwmBuilder.setSequence(sequence);  
35.         **return** (BenzModel) **this**.bwmBuilder.getCarModel();  
36.     \}  
37.   
38.     //D顺序的宝马车  
39.     **public** BenzModel getDBWMModel() \{  
40.         **this**.sequence.clear();  
41.         **this**.sequence.add("engine boom");  
42.         **this**.sequence.add("start");  
43.         //返回D顺序的宝马车  
44.         **this**.bwmBuilder.setSequence(sequence);  
45.         **return** (BenzModel) **this**.bwmBuilder.getCarModel();  
46.     \}  
47.       
48.     //还有很多其他需求，设计师嘛，想啥需求就给你弄啥需求  
49. \}

有了这样一个设计师，我们的测试类就更容易处理了，比如现在老板要10000辆A类奔驰车，100000辆B类奔驰车，20000C类型宝马车，D类型不要：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **class** Client \{  
2.    
3.      **public** **static** **void** main(String\[\] args) \{  
4.    
5.          Director director = **new** Director();  
6.            
7.          **for**(**int** i = 0; i < 10000; i ++) \{  
8.              director.getABenzModel();  
9.          \}  
10.           
11.         **for**(**int** i = 0; i < 100000; i ++) \{  
12.             director.getBBenzModel();  
13.         \}  
14.           
15.         **for**(**int** i = 0; i < 20000; i ++) \{  
16.             director.getCBWMModel();  
17.         \}  
18.     \}  
19.   
20. \}

是不是很清晰很简单，我们重构代码的最终第就是简单清晰。这就是建造者模式。

# 2. 建造者模式的定义 #

我们来看看建造者模式的一般定义：Separate the construction of a complex object from its representation so that the same construction process can create different representations. 即：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。比如上面的例子，我们可以用同样的顺序构造不同的车。建造者模式的通用类图如下：

![20160505210036657][]

Product是最终的产品类，Builder是建造者，Director是指挥者。Director负责安排已有模块的顺序，然后告诉Builder开始建造。

# 3. 建造者模式的优点 #

1）封装性：使用建造者模式可以是客户端不必知道产品内部组成的细节。

2）建造者独立，容易扩展：BenzBuilder和BMWBuilder是相互独立的，对系统扩展非常有利。

3）便于控制细节风险：由于具体的建造者是独立的，因此可以对建造者过程逐步细化，而不对其他的模块产生任何影响。

# 4. 建造者模式的使用场景 #

1）相同的方法，不同的执行顺序，产生不同的事件结果时，可以使用建造者模式。

2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不想同时，可以使用建造者模式。

3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这时候可以使用建造者模式。

4）在对象创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到，也可以采用建造者模式封装该对象的创建过程。这种场景只能是一个补偿的方法，因为一个对象不容易获得，而在设计阶段竟然没有发现，而要通过设计这模式来柔化创建过程，本身设计已经出问题了。

到这里，我们会发现，建造者模式和工厂方法模式有点像。但是两者有区别：建造者模式关注的是零件类型和装配工艺（顺序），而工厂模式是创建一个对象，这是最大不同的地方。

创建者模式就介绍这么多吧，如有错误之处，欢迎留言指正~

相关阅读：[http://blog.csdn.net/column/details/des-pattern.html][http_blog.csdn.net_column_details_des-pattern.html]

**\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_****\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_**

\-----乐于分享，共同进步！

\-----更多文章请看：[http://blog.csdn.net/eson\_15][http_blog.csdn.net_eson_15]

[Link 1]: http://blog.csdn.net/eson_15/article/details/51323902
[20160505195518510]: /images/20220611/2130c93949c741fba0cb0b80e7f571d8.png
[view plain]: http://blog.csdn.net/eson_15/article/details/51325765#
[20160505201832734]: /images/20220611/755a6b45331e474abae155ae7f9708c8.png
[20160505203715252]: /images/20220611/4e687ee74bba47a2b77447e211df50d8.png
[20160505210036657]: /images/20220611/dcf9d00920964be4838b37c125bfd36b.png
[http_blog.csdn.net_column_details_des-pattern.html]: http://blog.csdn.net/column/details/des-pattern.html
[http_blog.csdn.net_eson_15]: http://blog.csdn.net/eson_15

发表评论取消回复

表情：

评论列表（有 0 条评论，178人围观）

还没有评论，来说两句吧...

相关阅读

相关设计模式之建造者模式（builder）

基本概念和功能它是使用在创建复杂对象时，一个复杂对象可能含有多个部件，每个部件需要单独创建，然后组成在一起形成这个复杂对象。而且部件组合的时候具有很大的灵活性，比如：1

小鱼儿/ 2024年03月26日 15:42/ 0 赞/ 34 阅读

相关设计模式——建造者(Builder)模式

![0f7b2669cfee4c1098c5506d6193b1ae.png][] 建造者模式（Builder Pattern），又叫生成器模式，是一种对象构建模式它可以将

刺骨的言语ヽ痛彻心扉/ 2024年03月23日 22:53/ 0 赞/ 34 阅读

相关设计模式-建造者模式（Builder）

建造者模式（Builder），又叫生成器模式，将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式可以将一个产品的内部表象和产品的生成过程分

ゝ一世哀愁。/ 2022年07月27日 12:36/ 0 赞/ 154 阅读

相关【java设计模式】之建造者（Builder）模式

我们还是举上一节的例子：生产汽车。上一节我们通过[模板方法模式][Link 1]控制汽车跑起来的动作，那么需求是无止境的，现在如果老板又增加了额外的需求：汽车启动、停止、

忘是亡心i/ 2022年06月11日 07:59/ 0 赞/ 179 阅读

相关设计模式： Builder 建造者模式

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。使得多个简单的对象一步一步构建成一个复杂的对象。建造者模式是一步一步创建一个复杂的对象，

不念不忘少年蓝@/ 2022年06月02日 02:42/ 0 赞/ 147 阅读

相关设计模式——建造者模式（Builder）

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。其实建造者模式就是前面抽象工厂模

曾经终败给现在/ 2022年05月24日 07:28/ 0 赞/ 135 阅读

相关 java设计模式五之Builder建造者设计模式

前言： Builder建造者设计模式，用来隐藏复合对象的创建过程，把复合对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

浅浅的花香味﹌/ 2022年05月23日 13:46/ 0 赞/ 185 阅读

相关设计模式之建造者模式(Builder Pattern)

建造者模式也叫做生成器模式，在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。建造者模式定义 Separate the construct

快来打我*/ 2022年04月18日 01:25/ 0 赞/ 152 阅读

相关 [设计模式]建造者模式（Builder）

1. 意图将一个复杂对象的构建于它的表示分离，使得同样的构建过程可以创建不同的表示。并且因为构建过程是标准化的，所以当需要标准化构建过程时也可以

ゞ浴缸里的玫瑰/ 2022年03月27日 13:28/ 0 赞/ 247 阅读

相关设计模式--建造者模式（Builders）

建造者模式（Builders）在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 OPU、主板、内存、硬盘、

﹏ヽ暗。殇╰゛Y/ 2021年10月01日 04:22/ 0 赞/ 312 阅读