建造者模式（Builder Pattern）
1. 建造者模式的定义
建造者模式（Builder Pattern）也叫做生成器模式，其定义如下：
Separate the construction of a complex object from its representation so that the same construction process can create different representations.（将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示）。
在建造者模式中，有如下4个角色：
- Product产品类
通常是实现了模板方法模式，也就是有模板方法和基本方法，这个参考模板方法模式。例子中的ModelA和ModelB就属于产品类。
● Builder抽象建造者
规范产品的组建，一般是由子类实现。例子中的ModelBuilder就属于抽象建造者。
● ConcreteBuilder具体建造者
实现抽象类定义的所有方法，并且返回一个组建好的对象。例子中的ModelABuilder和ModelBBuilder就属于具体建造者。
● Director导演类
负责安排已有模块的顺序，然后告诉Builder开始建造。
1.1 代码示例
抽象对象
package com.qqxhb.pattern;
import java.util.ArrayList;
/**
* 抽象模型类
*
* @author Administrator
*
*/
public abstract class AbstractModel {
private ArrayList<String> orderList = new ArrayList<String>();
/**
* 初始方法
*/
protected abstract void init();
/**
* 主要业务处理
*/
protected abstract void handle();
/**
* 处理结束方法
*/
protected abstract void destroy();
public final void start() {
for (String action : orderList) {
if ("init".equals(action)) {
this.init();
} else if ("handle".equals(action)) {
this.handle();
} else {
this.destroy();
}
}
}
/**
* 设置方法执行顺序
*
* @param orderList
*/
public final void setOrder(ArrayList<String> orderList) {
this.orderList = orderList;
}
}
package com.qqxhb.pattern;
import java.util.ArrayList;
/**
* 模型构建抽象类
*
* @author Administrator
*
*/
public abstract class ModelBuilder {
/**
* 设置模型构建顺序
*
* @param orderList
*/
public abstract void setOrder(ArrayList<String> orderList);
/**
* 获取构建的模型
*
* @return
*/
public abstract AbstractModel getModel();
}
实现类
package com.qqxhb.pattern.impl;
import com.qqxhb.pattern.AbstractModel;
public class ModelA extends AbstractModel {
@Override
protected void init() {
System.out.println("init ModelA");
}
@Override
protected void handle() {
System.out.println("handle ModelA");
}
@Override
protected void destroy() {
System.out.println("destroy ModelA");
}
}
package com.qqxhb.pattern.impl;
import com.qqxhb.pattern.AbstractModel;
public class ModelB extends AbstractModel {
@Override
protected void init() {
System.out.println("init ModelB");
}
@Override
protected void handle() {
System.out.println("handle ModelB");
}
@Override
protected void destroy() {
System.out.println("destroy ModelB");
}
}
package com.qqxhb.pattern.impl;
import java.util.ArrayList;
import com.qqxhb.pattern.AbstractModel;
import com.qqxhb.pattern.ModelBuilder;
/**
* 模型A构造类
*
* @author Administrator
*
*/
public class ModelABuilder extends ModelBuilder {
private ModelA modelA = new ModelA();
@Override
public void setOrder(ArrayList<String> orderList) {
this.modelA.setOrder(orderList);
}
@Override
public AbstractModel getModel() {
return this.modelA;
}
}
package com.qqxhb.pattern.impl;
import java.util.ArrayList;
import com.qqxhb.pattern.AbstractModel;
import com.qqxhb.pattern.ModelBuilder;
/**
* 模型B构造器
*
* @author Administrator
*
*/
public class ModelBBuilder extends ModelBuilder {
private ModelB modelB = new ModelB();
@Override
public void setOrder(ArrayList<String> orderList) {
this.modelB.setOrder(orderList);
}
@Override
public AbstractModel getModel() {
return this.modelB;
}
}
调用客户端
package com.qqxhb.pattern;
import java.util.ArrayList;
import com.qqxhb.pattern.impl.ModelA;
import com.qqxhb.pattern.impl.ModelABuilder;
import com.qqxhb.pattern.impl.ModelB;
import com.qqxhb.pattern.impl.ModelBBuilder;
public class Director {
private ArrayList<String> orderList = new ArrayList<String>();
private ModelBBuilder modelBBuilder = new ModelBBuilder();
private ModelABuilder modelABuilder = new ModelABuilder();
/**
* 获取init->handle->destroy顺序的模型B
*
* @return
*/
public ModelB getModelB1() {
this.orderList.clear();
this.orderList.add("init");
this.orderList.add("handle");
this.orderList.add("destroy");
this.modelBBuilder.setOrder(this.orderList);
return (ModelB) this.modelBBuilder.getModel();
}
/**
* 获取destroy->init->handle顺序的模型B
*
* @return
*/
public ModelB getModelB2() {
this.orderList.clear();
this.orderList.add("destroy");
this.orderList.add("init");
this.orderList.add("handle");
this.modelBBuilder.setOrder(this.orderList);
return (ModelB) this.modelBBuilder.getModel();
}
/**
* 获取init->handle->destroy顺序的模型A
*
* @return
*/
public ModelA getModelA1() {
this.orderList.clear();
this.orderList.add("init");
this.orderList.add("handle");
this.orderList.add("destroy");
this.modelABuilder.setOrder(this.orderList);
return (ModelA) this.modelABuilder.getModel();
}
/**
* 获取destroy->init->handle顺序的模型A
*
* @return
*/
public ModelA getModelA2() {
this.orderList.clear();
this.orderList.add("destroy");
this.orderList.add("init");
this.orderList.add("handle");
this.modelABuilder.setOrder(this.orderList);
return (ModelA) this.modelABuilder.getModel();
}
}
package com.qqxhb.pattern;
public class Client {
public static void main(String[] args) {
Director director = new Director();
System.out.println("创建2个1号模型A..........");
for (int i = 0; i < 2; i++) {
director.getModelA1().start();
}
System.out.println("创建2个2号模型A..........");
for (int i = 0; i < 2; i++) {
director.getModelA2().start();
}
System.out.println("创建2个2号模型B..........");
for (int i = 0; i < 2; i++) {
director.getModelB2().start();
}
System.out.println("创建2个1号模型B..........");
for (int i = 0; i < 2; i++) {
director.getModelB1().start();
}
}
}
导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。当然，在建造者模式比较庞大时，导演类可以有多个。
2. 建造者模式的应用
2.1 优点
- 封装性
使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就不需要关心每一个具体的模型内部是如何实现的。 - 建造者独立，容易扩展
ModelABuilder和ModelBBuilder是相互独立的，对系统的扩展非常有利。 - 便于控制细节风险
由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
2.2 使用场景
- 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。
- 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
- 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。
- 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。
2.3 注意事项
建造者模式最主要的功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象也不同；而工厂方法则重点是创建，创建零件是它的主要职责，组装顺序则不是它关心的。
扫一扫
1723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
