一、模式解析
建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。
以上是对建造者模式的官方定义，简单说就是对于复杂对象的创建，由一个建造者封装了对象组件的生成，由专门的指挥者来负责指挥对象生产和组件装配，调用者仅需要通知指挥者建造者进行生产，即可从对象本身获取完整对象。
要点为：
1、 模式的主要参与者为：抽象建造者，具体建造者，指挥者。
2、具体建造者负责具体实施生产
3、指挥者仅负责提供解决方案和流程
4、最终的产品创建细节和产品交付由具体建造者负责
二、模式代码
定义产品的模块组成
package build.patten; /**
* 产品的组成部分
* @author zjl
* @time 2016-1-29
*
*/
public class Part {
public String name; public Part(String name) {
super();
this.name = name;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.name.toString();
}
}
2、定义产品，产品由三个部分组成，因此保存一个组成部分的列表
package build.patten; import java.util.ArrayList;
import java.util.List; /**
* 产品，可以包含A,B,C三个部分
* @author zjl
* @time 2016-1-29
*
*/
public class Product {
List<Part> parts=new ArrayList<Part>();
@Override
public String toString() {
// TODO Auto-generated method stub
return parts.toString();
} }
3、抽象的建造者，规定了对产品各部分的建造接口
package build.patten;
public interface IBuild {
public void buildPartA();
public void buildPartB();
public void buildPartC();
public Product getResult();
}
4、具体建造者，实现抽象建造者的方法，可以有一个或多个
package build.patten;
public class ConcreteBuild implements IBuild {
Product product=new Product();
@Override
public void buildPartA() {
// TODO Auto-generated method stub
product.parts.add(new Part("partA"));
}
@Override
public void buildPartB() {
// TODO Auto-generated method stub
product.parts.add(new Part("partB"));
}
@Override
public void buildPartC() {
// TODO Auto-generated method stub
product.parts.add(new Part("partC"));
}
@Override
public Product getResult() {
// TODO Auto-generated method stub
return product;
}
}
4、指挥者类，负责告诉建造者，应该以什么样的逻辑完成产品的创建
package build.patten;
public class Director {
IBuild build;
public Director(IBuild build){
this.build=build;
}
public void build(){
this.build.buildPartA();
this.build.buildPartB();
this.build.buildPartC();
}
}
5、客户端
package build.patten;
public class Client {
public static void main(String[] args) {
IBuild build=new ConcreteBuild();
Director director=new Director(build);
director.build();
Product product=build.getResult();
System.out.println(product);
}
}
6、运行结果，也就是创建的产品
[partA, partB, partC]
三、应用场景
建造者模式由于需要中间的指挥者来完成对产品各部分的建设，其实在工作中用的还是比较少，不过最近正在装修，似乎可以找到类似的原型：
在装修的过程中，我们将房子交给装修公司后，由设计师和工人来共同完成对房子的装修，其中设计师负责进行设计，规定房子如何装；具体干活：比如泥工，木工，电工均由工人完成。
整个装修过程比较复杂，因此我们选取简单的一块，比如门的设计和安装来举例：我的房子是两室一厨一卫，所以共需要四个门，门的牌子和材质可以有不同的选择，设计师负责进行选择，工人仅需要安装即可。
四、场景代码
1、定义门，
package build.example;
public class Door {
//名称
public String name;
//材料
public String type;
//位置
public String pos;
public Door(String name,String pos){
this.name=name;
this.pos=pos;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return pos+"的位置安装厂家为"+name+"的"+type+"门";
}
}
定义房子，也就是最终交付的成果
package build.example; import java.util.ArrayList;
import java.util.List; /**
* 房子装修，可以请装修工人对房子进行装修
* 不同人的房子可能装法不同
* 假设装修两室一厅，共四个门，厨卫+两个卧室
* @author zjl
* @time 2016-1-29
*
*/
public class House {
List<Door> doors=new ArrayList<Door>();
@Override
public String toString() {
// TODO Auto-generated method stub
return doors.toString();
}
}
3、定义工人，工人会装木门，也会装合金门
package build.example;
/**
* 抽象的装修工人，定义了装修工人会的技能
* 此处仅以装门来考虑
* @author zjl
* @time 2016-1-29
*
*/
public abstract class AbstractWorker { public abstract void fixMumen(Door door);
public abstract void fixHejinmen(Door door);
public abstract House getHouse(); }
4、定义一个具体的工人，每个工人手艺不一样，所以可以选择的工人很多，但他们都必须会装门
package build.example;
public class ConcreteWorkerA extends AbstractWorker {
public House house=new House();
@Override
public House getHouse(){
return house;
}
@Override
public void fixMumen(Door door) {
door.type="木";
house.doors.add(door);
}
@Override
public void fixHejinmen(Door door) {
door.type="合金";
house.doors.add(door);
}
}
5、设计师，负责设计门如何安装
package build.example;
/**
* 设计师，负责设计门的的种类和选材
* @author zjl
* @time 2016-1-29
*
*/
public class Designer {
AbstractWorker worker;
public Designer(AbstractWorker worker){
this.worker=worker;
}
public void bulid() {
worker.fixMumen(new Door("A厂家", "厨房"));
worker.fixMumen(new Door("A厂家", "厕所"));
worker.fixHejinmen(new Door("A厂家", "主卧"));
worker.fixHejinmen(new Door("A厂家", "次卧"));
} }
6、我自己，只负责催进度和要结果
package build.example;
public class Client {
public static void main(String[] args) {
AbstractWorker worker=new ConcreteWorkerA();
Designer designer=new Designer(worker);
designer.bulid();
House house=worker.getHouse();
System.out.println(house);
}
}
7、生产结果
[厨房的位置安装厂家为A厂家的木门,
厕所的位置安装厂家为A厂家的木门,
主卧的位置安装厂家为A厂家的合金门,
次卧的位置安装厂家为A厂家的合金门]
五、模式疑问：
1、产品的交付，在模式标准中有建造者进行完成，似乎感觉由指挥者直接完成整个产品的返回似乎也可以，具体区别以后补充
2、指挥者的存在是建造者模式的关键，将顺序剥离了建造者，其实我们完全可以将建造顺序和过程封装到抽象建造者内，此时建造者模式就变成了模板模式。
3、针对第二点，为什么有了原型模式后，还会有建造者模式，其实建造者模式可以有多个指挥者，不同的指挥者可以设计出不同的建造顺序和逻辑，从而产生出不同的产品，例如我们装修时，找不同的设计师，设计出不同的风格，那么用的材料和牌子也会不同，此时原型模式由于在父类中规定了建造流程，反而无法达到此效果。