建造者模式（Builder Pattern）。

建造者模式也叫生成器模式，其定义如下：

讲一个复杂对象的构建与它的表示分离，使得同样地构建过程可以创建不同的表示。

在建造者模式中，有如下4个角色：

• Product产品类、

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

• Builder抽象建造者

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

• ConcreteBuilder具体建造者

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

• Director导演类

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

通用源代码：

产品类（通常它是一个组合或继承（如模板方法模式）产生的类）

public class Product {

public void doSomething(){

// 独立业务处理

}

}

抽象建造者

public abstract class Builder {

// 设置产品的不同部分，以获得不同的产品

public abstract void setPart();

// 建造产品

public abstract Product buildProduct();

}

其中，setPart方法时零件的配置，什么是零件？其他的对象，获得一个不同零件，或者不同的装配顺序就可能产生不同的产品。

具体建造者

public class ConcreteProduct extends Builder {

private Product product = new Product();

// 设置产品零件

public void setPart() {

// 产品内的逻辑处理

}

// 组建一个产品

public Product buildProduct() {

return product;

}

}

需要注意的是，如果有多个产品类就有几个具体的建造者，而且这多个产品类具有相同接口或抽象类。

导演类

public class Director {

private Builder builder = new ConcreteProduct();

// 构建不同的产品

public Product getAProduct() {
builder.setPart();

// 设置不同的零件，产生不同的产品

return builder.buildProduct();

}

}

导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个。

优点：

• 封装性

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

• 建造者独立，容易扩展

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

• 便于控制细节风险

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

使用场景：

• 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常适合。
• 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

注意事项：

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

扩展：

建造者怎么去创建一个对象？是零件的组装，组装顺序不同对象效能也不同，这才是建造者模式要表达的核心意义。

建造者模式与工厂模式的区别：建造者模式最主要的功能是基本方法的调用的顺序安排，也就是这些基本方法已经实现了，通俗的说就是零件的装配，顺序不同产生的对象 也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。

最佳实践：

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

案例代码：

车辆模型的抽象类

public abstract class CarModel {

// 这个参数是各个基本方法执行的顺序

private ArrayList<String> Sequence = new ArrayList<String>();

// 模型是启动开始跑了

protected abstract void start();

// 能发动，还要能停下来，那才是真本事

protected abstract void stop();

// 喇叭会出声音，是滴滴叫，还是哔哔叫

protected abstract void alarm();

// 引擎会轰隆隆地响，不响那是假的

protected abstract void engineBoom();

// 那模型应该会跑吧

final public void run() {

// 循环一遍，谁在前，就先执行谁

for(int i = 0; i < this.sequence.size(); i ++) {

String actionName = this.sequence.get(i);

if("start".equalsIgnoreCase(actionName)) {

this.start(); // 启动汽车

} else if ("stop".equalsIgnoreCase(actionName)) {

this.stop(); // 停止汽车

} else if ("alarm".equalsIgnoreCase(actionName)) {

this.alarm(); // 喇叭开始叫了

} else if ("engine boom".equalsIgnoreCase(actionName)) {

this.engineBoom(); // 如果是engine boom关键字 引擎开始轰鸣

}

}

} 


// 把传递过来的值传递到类内

final public void setSequence(ArrayList<String> sequence) {

this.sequence = sequence;

}

}

奔驰模型代码（宝马车模型代码省略）

public class BenzModel extends CarModel {

// 模型是启动开始跑了

protected void start() {

System.out.println("奔驰车的喇叭声音是这个样子的...");

}

// 能发动，还要能停下来，那才是真本事

protected void stop() {

System.out.println("奔驰车应该怎样停车...");

}

// 喇叭会出声音，是滴滴叫，还是哔哔叫

protected void alarm(){

System.out.println("奔驰车的喇叭声音是这个样子的....");

}

// 引擎会轰隆隆地响，不响那是假的

protected void engineBoom(){

System.out.println("奔驰车的引擎是这个声音的....");

}

}

抽象汽车组装者

public abstract class CarBuilder {

// 建造一个模型，你要给我一个顺序要求，就是组装顺序

public abstract void setSequence(ArrayList<String> sequence);

// 设置完毕顺序后，就可以直接拿到这个车辆模型

public abstract CarModel getCarModel();

}

奔驰车组装者（宝马车组装者省略）

public class BenzBuilder extends CarBuilder {

private BenzModel benz = new BenzModel();

public CarModel getCarModel() {

return this.benz;

}

public void setQuence(ArrayList<String> sequence) {

this.benz.setSequence(sequence);

}

}

场景类
 

public class Client{

public static void main(String[] args) {

/*

 * 客户告诉XX公司，我要这样一个模型，然后XX公司就告诉我老大

 * 说要这样一个模型，这样一个顺序，然后我来制造

 */

// 存放run的顺序

ArrayList<String> sequence = new ArrayList<String>();

sequence.add("engine boom"); // 客户要求，run时候先发动引擎

sequence.add("start"); // 启动起来

sequence.add("stop"); // 开了一段就停下来

// 要一个奔驰车：

BenzBuilder benzBuilder = new BenzBuilder();

// 把顺序给这个builder类，制造出这样一个车出来

benzBuilder.setSequence(sequence);

// 制造出一个奔驰车

BenzModel benz = (BenzModel) benzBuilder.getCarModel();

// 奔驰车跑一下看看

benz.run();

}

}

我们在做项目时，经常会有一个共识：需求是无底洞，是无理性的，不可能告诉它不增加需求就不增加。

导演类

public class Director {

private ArrayLIst<Stirng> sequence = new ArrayLIst();

private BenzBuilder benzBuilder = new BenzBuilder();

private BMWBuilder bmwBuilder = new BMWBuilder();

/*

 * A类型的奔驰车模型，先start，然后stop，其他什么引擎、喇叭一概没有

 */

public BenzModel getABenzModel() {

// 清理场景，这里是一些初级程序员不注意的地方

this.sequence.clear();

// ABenzModel的执行顺序

this.sequence.add("start");

this.sequence.add("stop");

// 按照顺序返回一个奔驰车

this.benzBuilder.setSequence(this.sequence);

return (BenzModel) this.benzBuilder.getCarModel();

}

/*

 * C型号的宝马车是先按下喇叭（炫耀啊），然后启动，然后停止

 */

public BMWModel getCBMWModel() {

this.sequence.clear()

this.sequence.add("alarm");

this.sequence.add("start");

this.sequence.add("stop");

this.bmwBuilder.setSequence(this.sequence);

return (BMWModel) this.bmwBuilder.getCarModel();

}

}

顺便说一下，大家看一下程序中有很多this调用。如果你要调用类中的成员变量或方法，需要在前面加上this关键字，不加也能正常的跑起来，但是不清晰，加上this关键字，我就是要调用本类中的成员变量或方法，而不是本方法中一个变量。还有super方法也是一样，是调用父类的成员变量或者方法，那就加上这个关键字，不要省略，这要靠约束，还有就是程序员的自觉性，他要是死不悔改，那咱也没招。

注意：上面每个方法都有一个this.sequence.clear()，估计你一看就明白。但是作为一个系统分析师或者技术经理一定要告诉项目成员，ArrayList和HashMap如果定义成类的成员变量，那你在方法中的调用一定要做一个clear的动作，以防止数据混乱。

导演类

public class Client {

public static void main(String[] args) {

Director director = new Director();

// 1万辆A类型的奔驰车

for(int i = 0; i < 10000; 0 ++) {

director.getABenzModel().run();

}


// 1000万辆C类型的奔驰车

for(int i = 0; i < 10000; 0 ++) {

director.getCBMWModel().run();

}


}

}

程序重构的最终目的就是：简单、清晰。

// 1万辆A类型的奔驰车

for(int i = 0; i < 10000; 0 ++) {

director.getABenzModel().run();

}