设计模式（八）——建造者模式

一、什么是建造者模式
建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。
建造者模式通常包括下面几个角色：
1、Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2、ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
3、Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4、Product：要创建的复杂对象。
应用实例：
1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 
2、JAVA 中的 StringBuilder。
使用场景： 
1、需要生成的对象具有复杂的内部结构。 
2、需要生成的对象内部属性本身相互依赖。
与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。


二、实例演示
这里以游戏开发中人物的构造过程为例。在游戏中创建一个形象时，需要对每个部位进行创建。简化而言，需要创建头部，身体和四肢。
1、Product（要创建的复杂对象）：
建立一个人物对象Person

1. public class Person {  
2.    
3.     private String head;  
4.     private String body;  
5.     private String foot;  
6.    
7.     public String getHead() {  
8.         return head;  
9.     }  
10.    
11.     public void setHead(String head) {  
12.         this.head = head;  
13.     }  
14.    
15.     public String getBody() {  
16.         return body;  
17.     }  
18.    
19.     public void setBody(String body) {  
20.         this.body = body;  
21.     }  
22.    
23.     public String getFoot() {  
24.         return foot;  
25.     }  
26.    
27.     public void setFoot(String foot) {  
28.         this.foot = foot;  
29.     }  
30. }  

2、Builder（给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建）：

1. public interface PersonBuilder {  
2.     void buildHead();  
3.     void buildBody();  
4.     void buildFoot();  
5.     Person buildPerson();//组装  
6. }  

3、ConcreteBuilder（实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例）：

1. public class ManBuilder implements PersonBuilder {  
2.    
3.     Person person;  
4.    
5.     public ManBuilder() {  
6.         person = new Person();//创建一个person实例，用于调用set方法  
7.     }  
8.    
9.     public void buildBody() {  
10.         person.setBody("建造身体部分");  
11.     }  
12.    
13.     public void buildFoot() {  
14.         person.setFoot("建造四肢部分");  
15.     }  
16.    
17.     public void buildHead() {  
18.         person.setHead("建造头部部分");  
19.     }  
20.    
21.     public Person buildPerson() {  
22.         return person;//返回一个person实例  
23.     }  
24.    
25. }  

4、Director（调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建）：

1. public class PersonDirector {  
2.     public Person constructPerson(PersonBuilder pb) {  
3.         //按照 身体--->头部--->四肢 的顺序创建人物  
4.         pb.buildHead();  
5.         pb.buildBody();  
6.         pb.buildFoot();  
7.         return pb.buildPerson();  
8.     }  
9. }  

5、测试

[java] view plaincopyprint?

1. public class Test {  
2.     public static void main(String[] args) {  
3.         PersonDirector pd = new PersonDirector();  
4.         Person person = pd.constructPerson(new ManBuilder());  
5.         System.out.println(person.getBody());  
6.         System.out.println(person.getFoot());  
7.         System.out.println(person.getHead());  
8.     }  
9. }  

三、总结

在《Effective Java》书中第二条，就提到“遇到多个构造器参数时要考虑用构建器”，其实这里的构建器就属于建造者模式，只是里面把四个角色都放到具体产品里面了。而建造者模式主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。