建造者模式也叫生成器模式,其定义如下:
讲一个复杂对象的构建与它的表示分离,使得同样地构建过程可以创建不同的表示。
在建造者模式中,有如下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();
}