JAVA设计模式-06-建造者模式

参考：http://blog.****.net/pengjunlee/article/details/51569959

部分经典内容引用：
点击打开链接：http://www.cnblogs.com/lwbqqyumidi/p/3742562.html

前言

听完本节课之后顿时头大了，感觉有点像工厂方法模式，查看了网上很多文章也是众说纷纭，看到了corn的这篇文章才有点拨开云雾见晴天的感觉。

一、什么是建造者模式

建造者（Builder）模式也叫生成器模式，是由GoF提出的23种设计模式中的一种，其设计意图是：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
GoF给出的描述很简短，不易理解，我是这样理解的：我们要创建的对象会包含有各种各样的属性（可以是对象，也可以不是对象，就好比汽车的零配件），这些属性就叫做这个对象的表示，有了属性之后我们还需要将这些属性按照一定的规则或者顺序组装起来才能创造出对象来（这就好比用汽车零件组装汽车），而这个组装的过程就是对象的构建，Builder模式将对象的表示与对象的构建分别交由建造者和指挥者去负责，整个对象的创建过程对客户端是隐藏的，客户端只需要去调用建造者和指挥者去创建对象，而不必关系这个对象都有哪些属性，以及各个属性之间是怎么样进行组装的，达到了责任划分和封装的目的。

二、建造者模式的结构

建造者模式适合于创建比较复杂的对象，所谓复杂有两个方向：
- 创建过程复杂，创建的步骤有严格的顺序。
- 创建对象的结构复杂，创建对象包含的属性数量多。
针对以上两类的复杂对象Builder模式也分别演化出了两种表现形式。

第一种：

通过Product、ConcreteBuilder、Builder和Director形成的建造者模式。

从上图可以看出，这种Builder模式包含4个角色：产品(Product)，具体建造者(ConcreteBuilder)，建造者(Builder)，指挥者(Director)
产品：需要创建的对象产品
建造者：本质为抽象类，里面的抽象方法供具体建造者重写。
具体建造者：创建产品的实例并且实现建造者多个方法对产品进行装配。
指挥者：有条不紊的按顺序调用建造者抽象类及其方法。
我们都知道计算机重装系统是一件很复杂的事情，首先你要备份重要数据、格式化硬盘，安装操作系统，然后再拷贝数据，安装驱动，安装常用软件，等等...，接下来我们就以重装计算机操作系统为例来体会一下Builder模式的作用。
我们需要一个类来说明安装后的系统要包含哪些东西，这个类就是我们要创建的产品类。

[java] view plain copy

1. public class SysApplication {  
2.     // 系统中的文件数据  
3.     private String data;  
4.     // 操作系统  
5.     private String operationSystem;  
6.     // 驱动  
7.     private String driver;  
8.     // 包含哪些有用的软件  
9.     private String usefulSoftware;  
10.     public String getData() {  
11.         return data;  
12.     }  
13.     public void setData(String data) {  
14.         this.data = data;  
15.     }  
16.     public String getOperationSystem() {  
17.         return operationSystem;  
18.     }  
19.     public void setOperationSystem(String operationSystem) {  
20.         this.operationSystem = operationSystem;  
21.     }  
22.     public String getDriver() {  
23.         return driver;  
24.     }  
25.     public void setDriver(String driver) {  
26.         this.driver = driver;  
27.     }  
28.     public String getUsefulSoftware() {  
29.         return usefulSoftware;  
30.     }  
31.     public void setUsefulSoftware(String usefulSoftware) {  
32.         this.usefulSoftware = usefulSoftware;  
33.     }  
34. }  

再创建一个ISysInstallBuilder接口把重装系统过程中我们要做的事情都罗列出来，这个接口就扮演了Builder模式中的建造者角色。

[java] view plain copy

1. public interface ISysInstallBuilder {  
2.     // 备份数据  
3.     public void backupdata();  
4.     // 格式化硬盘  
5.     public void formatDisk();  
6.     // 复制数据  
7.     public void copyData();  
8.     // 安装操作系统  
9.     public void installOperationSystem();  
10.     // 安装驱动  
11.     public void installDriver();  
12.     // 安装有用的软件  
13.     public void installUsefulSoftware();  
14.     // 获取安装好的系统  
15.     public SysApplication getSystemApplication();  
16. }  

接下来我们来实现安装Windows XP系统的具体建造者类WinXpInstallBuilder，以后需要安装Windows XP系统就用它。

[java] view plain copy

1. public class WinXpInstallBuilder implements ISysInstallBuilder {  
2.     private SysApplication systemApplication = new SysApplication();  
3.     @Override  
4.     public void backupdata() {  
5.         // 此处填写数据备份相关代码  
6.         System.out.println("备份数据");  
7.     }  
8.     @Override  
9.     public void formatDisk() {  
10.         // 此处填写硬盘格式化相关代码  
11.         System.out.println("格式化硬盘");  
12.     }  
13.     @Override  
14.     public void copyData() {  
15.         // 此处填写复制数据相关代码  
16.         System.out.println("复制数据");  
17.         this.systemApplication.setData("原系统备份的数据");  
18.     }  
19.     @Override  
20.     public void installOperationSystem() {  
21.         // 此处填写安装Windows XP操作系统相关代码  
22.         System.out.println("安装Windows XP操作系统");  
23.         this.systemApplication.setOperationSystem("Windows XP");  
24.     }  
25.     @Override  
26.     public void installDriver() {  
27.         // 此处填写安装Windows XP驱动相关代码  
28.         System.out.println("安装Windows XP驱动");  
29.         this.systemApplication.setDriver("Windows XP驱动");  
30.     }  
31.     @Override  
32.     public void installUsefulSoftware() {  
33.         // 此处填写安装Windows XP操作系统下常用软件相关代码  
34.         System.out.println("安装Windows XP操作系统下常用软件");  
35.         this.systemApplication.setUsefulSoftware("Windows XP操作系统下常用软件");  
36.     }  
37.     @Override  
38.     public SysApplication getSystemApplication() {  
39.         // 将安装好的系统返回  
40.         return this.systemApplication;  
41.     }  
42. }  

现在我们有了一个具体建造者类WinXpInstallBuilder，接下来我们尝试着用它来重装一下系统。

[java] view plain copy

1. public class MainClass {  
2.     public static void main(String[] args) {  
3.         // 创建一个WinXpInstallBuilder  
4.         ISysInstallBuilder builder = new WinXpInstallBuilder();  
5.         // 调用WinXpInstallBuilder，开始装系统了  
6.         builder.backupdata();  
7.         builder.copyData();  
8.         builder.formatDisk();  
9.         builder.installDriver();  
10.         builder.installOperationSystem();  
11.         builder.installUsefulSoftware();  
12.         // 获取到安装好的系统  
13.         SysApplication sysApplication = builder.getSystemApplication();  
14.         System.out.println("----------系统信息如下----------");  
15.         System.out.println("数据：" + sysApplication.getData());  
16.         System.out.println("驱动：" + sysApplication.getDriver());  
17.         System.out.println("操作系统：" + sysApplication.getOperationSystem());  
18.         System.out.println("软件：" + sysApplication.getUsefulSoftware());  
19.     }  
20. }  

运行程序打印结果如下：

[html] view plain copy

1. 备份数据  
2. 复制数据  
3. 格式化硬盘  
4. 安装Windows XP驱动  
5. 安装Windows XP操作系统  
6. 安装Windows XP操作系统下常用软件  
7. ----------系统信息如下----------  
8. 数据：原系统备份的数据  
9. 驱动：Windows XP驱动  
10. 操作系统：Windows XP  
11. 软件：Windows XP操作系统下常用软件  

细心的你可能发现了，我安装的这个系统是有问题的，我把系统安装步骤的顺序搞乱了，复制数据应该放在格式化硬盘并安装好操作系统之后，安装驱动应该放在安装操作系统之后。
由于安装系统的步骤比较复杂，虽然我已经很小心翼翼可还是把安装步骤给搞错了，怎样才能让系统按照正确的步骤安装而不会搞乱顺序呢？到了指挥者出场的时刻了。

[java] view plain copy

1. public class SysInstallDirector {  
2.     private ISysInstallBuilder builder;  
3.     public SysInstallDirector(ISysInstallBuilder builder) {  
4.         this.builder = builder;  
5.     }  
6.     public void installSystem() {  
7.         builder.backupdata();  
8.         builder.formatDisk();  
9.         builder.installOperationSystem();  
10.         builder.installDriver();  
11.         builder.installUsefulSoftware();  
12.         builder.copyData();  
13.     }  
14. }  

接下来我们再使用指挥者装一次系统试试。

[java] view plain copy

1. public class Client{  
2.     public static void main(String[] args) {  
3.         // 创建一个WinXpInstallBuilder  
4.         ISysInstallBuilder builder = new WinXpInstallBuilder();  
5.         //创建一个指挥者  
6.         SysInstallDirector director = new SysInstallDirector(builder);  
7.         //建造者在指挥者的指挥下开始安装系统了  
8.         director.installSystem();  
9.         // 从建造者手里获取到安装好的系统  
10.         SysApplication sysApplication = builder.getSystemApplication();  
11.         System.out.println("----------系统信息如下----------");  
12.         System.out.println("数据：" + sysApplication.getData());  
13.         System.out.println("驱动：" + sysApplication.getDriver());  
14.         System.out.println("操作系统：" + sysApplication.getOperationSystem());  
15.         System.out.println("软件：" + sysApplication.getUsefulSoftware());  
16.     }  
17. }  

运行程序打印结果如下：

[html] view plain copy

1. 数据备份  
2. 硬盘格式化  
3. 安装Windows XP操作系统  
4. 安装Windows XP驱动  
5. 安装Windows XP操作系统下常用软件  
6. 复制数据  
7. ----------系统信息如下----------  
8. 数据：原系统备份的数据  
9. 驱动：Windows XP驱动  
10. 操作系统：Windows XP  
11. 软件：Windows XP操作系统下常用软件  

在有了指挥者的帮忙后，系统按照正确的顺序安装完成了。
接下来我们再实现一个安装Win7系统的具体建造者类Win7InstallBuilder。

[java] view plain copy

1. public class Win7InstallBuilder implements ISysInstallBuilder {  
2.     private SysApplication systemApplication = new SysApplication();  
3.     @Override  
4.     public void backupdata() {  
5.         // 此处填写数据备份相关代码  
6.         System.out.println("数据备份");  
7.     }  
8.     @Override  
9.     public void formatDisk() {  
10.         // 此处填写硬盘格式化相关代码  
11.         System.out.println("硬盘格式化");  
12.     }  
13.     @Override  
14.     public void copyData() {  
15.         // 此处填写复制数据相关代码  
16.         System.out.println("复制数据");  
17.         this.systemApplication.setData("原系统备份的数据");  
18.     }  
19.     @Override  
20.     public void installOperationSystem() {  
21.         // 此处填写安装安装Win7操作系统相关代码  
22.         System.out.println("安装Win7操作系统");  
23.         this.systemApplication.setOperationSystem("Win7");  
24.     }  
25.     @Override  
26.     public void installDriver() {  
27.         // 此处填写安装安装Win7驱动相关代码  
28.         System.out.println("安装Win7驱动");  
29.         this.systemApplication.setDriver("Win7驱动");  
30.     }  
31.     @Override  
32.     public void installUsefulSoftware() {  
33.         // 此处填写安装安装Win7操作系统下常用软件相关代码  
34.         System.out.println("安装Win7操作系统下常用软件");  
35.         this.systemApplication.setUsefulSoftware("Win7操作系统下常用软件");  
36.     }  
37.     @Override  
38.     public SysApplication getSystemApplication() {  
39.         // 将安装好的系统返回  
40.         return this.systemApplication;  
41.     }  
42. }  

在客户端中测试一下安装Win7系统。

[java] view plain copy

1. public class Client{  
2.     public static void main(String[] args) {  
3.         // 创建一个Win7InstallBuilder  
4.         ISysInstallBuilder builder = new Win7InstallBuilder();  
5.         // 创建一个指挥者  
6.         SysInstallDirector director = new SysInstallDirector(builder);  
7.         // 建造者在指挥者的指挥下开始安装系统了  
8.         director.installSystem();  
9.         // 从建造者手里获取到安装好的系统  
10.         SysApplication sysApplication = builder.getSystemApplication();  
11.         System.out.println("----------系统信息如下----------");  
12.         System.out.println("数据：" + sysApplication.getData());  
13.         System.out.println("驱动：" + sysApplication.getDriver());  
14.         System.out.println("操作系统：" + sysApplication.getOperationSystem());  
15.         System.out.println("软件：" + sysApplication.getUsefulSoftware());  
16.     }  
17. }  

运行程序打印结果如下：

[html] view plain copy

1. 数据备份  
2. 硬盘格式化  
3. 安装Win7操作系统  
4. 安装Win7驱动  
5. 安装Win7操作系统下常用软件  
6. 复制数据  
7. ----------系统信息如下----------  
8. 数据：原系统备份的数据  
9. 驱动：Win7驱动  
10. 操作系统：Win7  
11. 软件：Win7操作系统下常用软件  

Win7系统也被正确安装，Builder模式通过指挥者和建造者将要创建的对象属性和属性的装配过程进行分离，一样的创建过程由于传入的具体建造者不同最终创建出了完全不同的对象，而且无需再担忧把组装顺序搞混了。

第二种：

通过静态内部类实现复杂对象的无序构造。

创建一个个人信息类PersonalInfo，其中包含个人信息包括：电话号码，地址，姓名，年龄，性别，身份证号。

[java] view plain copy

1. public class PersonalInfo {  
2.     private String name;  
3.     private int age;  
4.     private String gender;  
5.     private String address;  
6.     private String iDNumber;  
7.     private String phoneNumber;  
8.     public String getPhoneNumber() {  
9.         return phoneNumber;  
10.     }  
11.     public String getAddress() {  
12.         return address;  
13.     }  
14.     public String getName() {  
15.         return name;  
16.     }  
17.     public int getAge() {  
18.         return age;  
19.     }  
20.     public String getGender() {  
21.         return gender;  
22.     }  
23.     public String getIDNumber() {  
24.         return iDNumber;  
25.     }  
26.     public static class Builder {  
27.         private String name;  
28.         private int age;  
29.         private String gender;  
30.         private String address;  
31.         private String iDNumber;  
32.         private String phoneNumber;  
33.         public Builder(String name) {  
34.             this.name = name;  
35.         }  
36.         public Builder phoneNumber(String phoneNumber) {  
37.             this.phoneNumber = phoneNumber;  
38.             return this;  
39.         }  
40.         public Builder address(String address) {  
41.             this.address = address;  
42.             return this;  
43.         }  
44.         public Builder age(int age) {  
45.             this.age = age;  
46.             return this;  
47.         }  
48.         public Builder gender(String gender) {  
49.             this.gender = gender;  
50.             return this;  
51.         }  
52.         public Builder iDNumber(String iDNumber) {  
53.             this.iDNumber = iDNumber;  
54.             return this;  
55.         }  
56.         public PersonalInfo build() {  
57.             return new PersonalInfo(this);  
58.         }  
59.     }  
60.     private PersonalInfo(Builder builder) {  
61.         this.address = builder.address;  
62.         this.age = builder.age;  
63.         this.gender = builder.gender;  
64.         this.iDNumber = builder.iDNumber;  
65.         this.name = builder.name;  
66.         this.phoneNumber = builder.phoneNumber;  
67.     }  
68. }  

在客户端中使用此类创建个人信息测试一下。

[java] view plain copy

1. public class Client{  
2.     public static void main(String[] args) {  
3.         PersonalInfo personalInfo = new PersonalInfo.Builder("姬如雪")  
4.                 .address("幻音坊").age(19).gender("女").build();  
5.         System.out.println("------------个人信息----------------");  
6.         System.out.println("姓名："+personalInfo.getName());  
7.         System.out.println("住址："+personalInfo.getAddress());  
8.         System.out.println("年龄："+personalInfo.getAge());  
9.         System.out.println("性别："+personalInfo.getGender());  
10.     }  
11. }  

运行程序打印结果如下：

[html] view plain copy

1. ------------个人信息----------------  
2. 姓名：姬如雪  
3. 住址：幻音坊  
4. 年龄：19  
5. 性别：女  

此种方式通过级联方式去创建对象，可自由控制创建对象的属性个数，减少了重复代码，使对象的创建更加形象直观。

三、建造者模式应用场景

如果碰到以下情况，可以考虑使用建造者模式：
- 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
- 当构造过程必须允许被构造的对象有不同的表示时。
- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象