23种设计模式（5）：建造者模式

一：建造者模式的定义

--->建造者模式(Builder Pattern)也叫做生成器模式,其定义如下:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示

● Product产品类

通常是实现了模板方法模式,也就是有模板方法和基本方法,这个参考模板方法模式。例子中的BenzModel和BMWModel就属于产品类。

● Builder抽象建造者

规范产品的组建,一般是由子类实现。例子中的CarBuilder就属于抽象建造者。

● ConcreteBuilder具体建造者

实现抽象类定义的所有方法,并且返回一个组建好的对象。例子中的BenzBuilder和BMWBuilder就属于具体建造者。

● Director导演类

负责安排已有模块的顺序,然后告诉Builder开始建造

二：建造者模式的优点

● 封装性

使用建造者模式可以使客户端不必知道产品内部组成的细节,如例子中我们就不需要关心每一个具体的模型内部是如何实现的,产生的对象类型就是CarModel。

● 建造者独立,容易扩展

BenzBuilder和BMWBuilder是相互独立的,对系统的扩展非常有利。

● 便于控制细节风险

由于具体的建造者是独立的,因此可以对建造过程逐步细化,而不对其他的模块产生任何影响。

三：建造者模式的使用场景

● 相同的方法,不同的执行顺序,产生不同的事件结果时,可以采用建造者模式。

● 多个部件或零件,都可以装配到一个对象中,但是产生的运行结果又不相同时,则可以使用该模式。

● 产品类非常复杂,或者产品类中的调用顺序不同产生了不同的效能,这个时候使用建造者模式非常合适。

● 在对象创建过程中会使用到系统中的一些其他对象,这些对象在产品对象的创建过程中不易得到时,也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法,因为一个对象不容易获得,而在设计阶段竟然没有发觉,而要通过创建者模式柔化创建过程,本身已经违反设计的最初目标。

四：建造者模式的注意事项

--->建造者模式关注的是零件类型和装配工艺(顺序),这是它与工厂方法模式最大不同的地方,虽然同为创建类模式,但是注重点不同。

--->这个建造者模式和工厂模式非常相似呀,是的,非常相似,但是记住一点你就可以游刃有余地使用了:建造者模式最主要的功能是基本方法的调用顺序安排,也就是这些基本方法已经实现了,通俗地说就是零件的装配,顺序不同产生的对象也不同;而工厂方法则重点是创建,创建零件是它的主要职责,组装顺序则不是它关心的。

--->再次说明,在使用建造者模式的时候考虑一下模板方法模式,别孤立地思考一个模式,僵化地套用一个模式会让你受害无穷!

五：建造者模式的例子



模板方法模式的模板算法抽象类

1
package com.yeepay.sxf.template6;

2
3 import java.util.ArrayList;
4
5 /**
6  * 算法模板类
7  * @author sxf
8  *
9  */
10 public abstract class CarModel {
11
12     //具体核心算法步骤执行顺序的调度
13     private ArrayList<String> sequence;
14     //汽车启动算法
15     protected abstract void start();
16     //汽车停止算法
17     protected abstract void stop();
18     //汽车喇叭鸣叫算法
19     protected abstract void alarm();
20     //引擎哄哄响算法
21     protected abstract void engineBoom();
22
23     //算法组装实现方法
24     final public void run(){
25         //循环一边，谁在前执行谁
26         for(int i=0;i<this.sequence.size();i++){
27             String actionName=this.sequence.get(i);
28             if(actionName.equalsIgnoreCase("start")){
29                 this.start();
30             }else if(actionName.equalsIgnoreCase("stop")){
31                 this.stop();
32             }else if(actionName.equalsIgnoreCase("alarm")){
33                 this.alarm();
34             }else if(actionName.equalsIgnoreCase("engineBoom")){
35                 this.engineBoom();
36             }
37         }
38     }
39     /**
40      * 给予执行算法
41      * @param sequence
42      */
43     final public void setSequence(ArrayList<String> sequence){
44         this.sequence=sequence;
45     }
46 }

奔驰算法类



1
package com.yeepay.sxf.template6;

2 /**
3  * 奔驰车的具体算法实现
4  * @author sxf
5  *
6  */
7 public class BenzModel extends CarModel {
8
9     @Override
10     protected void start() {
11         System.out.println("BenzModel.start(==》奔驰车算法启动)");
12     }
13
14     @Override
15     protected void stop() {
16         System.out.println("BenzModel.stop(==》奔驰车算法停止)");
17     }
18
19     @Override
20     protected void alarm() {
21         System.out.println("BenzModel.alarm(==》奔驰算法喇叭鸣叫)");
22     }
23
24     @Override
25     protected void engineBoom() {
26         System.out.println("BenzModel.engineBoom(==》奔驰算法发动机轰鸣)");
27     }
28
29
30 }

宝马算法类

1 package com.yeepay.sxf.template6;
2 /**
3  * 宝马车算法实现
4  * @author sxf
5  *
6  */
7 public class BMWModel extends CarModel{
8
9     @Override
10     protected void start() {
11         System.out.println("BMWModel.start(==》宝马车算法启动)");
12     }
13
14     @Override
15     protected void stop() {
16         System.out.println("BMWModel.stop(==》宝马车算法停止)");
17     }
18
19     @Override
20     protected void alarm() {
21         System.out.println("BMWModel.alarm(==》宝马车算法喇叭鸣叫)");
22     }
23
24     @Override
25     protected void engineBoom() {
26         System.out.println("BMWModel.engineBoom(==>宝马车算法引擎轰鸣)");
27     }
28
29 }

建造者模式的建造抽象类

1
package com.yeepay.sxf.template6;

2
3 import java.util.ArrayList;
4
5 /**
6  * 汽车算法构建抽象
7  * @author sxf
8  *
9  */
10 public abstract class CarBuilder {
11     /**
12      * 建造一个模型，你要给我一个顺序要求，就是组装的算法
13      * @param sequence
14      */
15     public abstract void setSequence(ArrayList<String> sequence);
16     /**
17      * 获取组装好的算法体
18      * @return
19      */
20     public abstract CarModel getCardModel();
21 }
22

奔驰算法建造类实现

1 package com.yeepay.sxf.template6;
2
3 import java.util.ArrayList;
4
5 /**
6  * 奔驰车算法的构建实现
7  * @author sxf
8  *
9  */
10 public class BenzBuilder extends CarBuilder{
11     //奔驰的算法体
12     private BenzModel benz=new BenzModel();
13
14     //给奔驰具体的算法执行
15     @Override
16     public void setSequence(ArrayList<String> sequence) {
17         this.benz.setSequence(sequence);
18     }
19
20     //获取奔驰的算法体
21     @Override
22     public CarModel getCardModel() {
23         return this.benz;
24     }
25
26
27 }

宝马算法建造类实现

1 package com.yeepay.sxf.template6;
2
3 import java.util.ArrayList;
4 /**
5  * 宝马算法构建类
6  * @author sxf
7  *
8  */
9 public class BMWBuilder extends CarBuilder{
10     //宝马的算法体
11     private BMWModel bmwModel=new BMWModel();
12
13     //给宝马算法体具体的算法执行
14     @Override
15     public void setSequence(ArrayList<String> sequence) {
16         this.bmwModel.setSequence(sequence);
17     }
18     //获取宝马的算法体
19     @Override
20     public CarModel getCardModel() {
21         return this.bmwModel;
22     }
23
24
25 }

导演类

1 package com.yeepay.sxf.template6;
2
3 import java.util.ArrayList;
4
5 /**
6  * 导演类
7  * @author sxf
8  *
9  */
10 public class Director {
11     private ArrayList<String> sequence=new ArrayList<String>();
12     private BenzBuilder benzBuilder=new BenzBuilder();
13     private BMWBuilder bmwBuilder=new BMWBuilder();
14
15     /**
16      * 获取A类型奔驰的算法体
17      * @return
18      */
19     public BenzModel getABenzModel(){
20         //清理算法执行顺序
21         this.sequence.clear();
22         this.sequence.add("start");
23         this.sequence.add("stop");
24         this.benzBuilder.setSequence(sequence);
25         return (BenzModel) this.benzBuilder.getCardModel();
26
27     }
28
29     /**
30      * 获取B类奔驰的算法体
31      * @return
32      */
33     public BenzModel getBBenzModel(){
34         //清理算法执行顺序
35         this.sequence.clear();
36         this.sequence.add("start");
37         this.sequence.add("stop");
38         this.sequence.add("alarm");
39         this.benzBuilder.setSequence(sequence);
40         return (BenzModel) this.benzBuilder.getCardModel();
41     }
42     /**
43      * 获取A类型宝马的算法体
44      * @return
45      */
46     public BMWModel getABMWModel(){
47         this.sequence.clear();
48         this.sequence.add("start");
49         this.sequence.add("alarm");
50         this.sequence.add("stop");
51         this.bmwBuilder.setSequence(sequence);
52         return (BMWModel) this.bmwBuilder.getCardModel();
53     }
54 }

客户端测试类

1
package com.yeepay.sxf.template6;

2 /**
3  * 客户端
4  * @author sxf
5  *
6  */
7 public class Client {
8
9     public static void main(String[] args) {
10         //获取导演类
11         Director director=new Director();
12
13         //由导演类获取A类型奔驰算法，并执行
14         CarModel aBenz=director.getABenzModel();
15         aBenz.run();
16
17         //由导演类获取A类型宝马算法，并执行
18         CarModel aBMW=director.getABMWModel();
19         aBMW.run();
20     }
21 }

原文转载于http://www.cnblogs.com/shangxiaofei/p/5100125.html