为什么学习建造者（Builder）模式和建造者（Builder）模式主要解决的问题

最新推荐文章于 2025-06-29 15:40:25 发布

大阳彼岸

最新推荐文章于 2025-06-29 15:40:25 发布

阅读量630

点赞数

分类专栏：【--------解决代码耦合度的问题-------】【降低耦合度1--java设计模式】

【--------解决代码耦合度的问题-------】同时被 2 个专栏收录

29 篇文章

订阅专栏

【降低耦合度1--java设计模式】

7 篇文章

订阅专栏

本文以汽车生产为例，介绍了建造者模式。从满足汽车运行顺序的不同需求出发，逐步优化设计，引入建造者和指挥者。阐述了建造者模式的定义，即将复杂对象构建与表示分离。还说明了其优点，如封装性、易扩展等，以及适用场景，并对比了与工厂方法模式的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转载 https://blog.youkuaiyun.com/eson_15/article/details/51325765

我们还是举上一节的例子：生产汽车。上一节我们通过模板方法模式控制汽车跑起来的动作，那么需求是无止境的，现在如果老板又增加了额外的需求：汽车启动、停止、鸣笛引擎声都由客户自己控制，他想要什么顺序就什么顺序，那该如何做呢？

1. 汽车无休止的改造

假如现在要生产两种车，奔驰和宝马，这两辆车都有共性，我们所需要关注的是单个车的运行过程，这才是老板所关心的点所在。我们先这样想，针对这个需求，我们要找到一个切入点，那就是产品类，每个车都是一个产品，那么在产品类中我们可以控制车的运行顺序，这样每个车都可以拥有自己想要的顺序了。基于此，我们设计如下类图：

我们看到CarModel中有个setSequence方法，通过传入一个ArrayList来控制运行顺序，run方法根据这个ArrayList中保存的顺序执行，然后奔驰车和宝马车分别继承这个CarModel即可，这貌似是很好的实现，它很像上一节的模板方法模式，只是多了个方法可以设置运行顺序。我们看一下CarModel具体代码的实现：

public abstract class CarModel {
private ArrayList<String> sequence = new ArrayList<String>(); //维护一个ArrayList保存执行命令关键字
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 ++) { //根据ArrayList中保存的顺序执行相应的动作
String actionName = this.sequence.get(i);
if(actionName.equalsIgnoreCase("start")) {
this.start(); //启动汽车
} else if(actionName.equalsIgnoreCase("stop")) {
this.stop(); //停止汽车
} else if(actionName.equalsIgnoreCase("alarm")) {
this.alarm(); //汽车鸣笛
} else if(actionName.equalsIgnoreCase("engine boom")) {
this.engineBoom(); //汽车轰鸣
}
}
}
final public void setSequence(ArrayList<String> sequence) { //获得执行顺序的命令，即一个ArrayList
this.sequence = sequence;
}
}

CarModel中的setSequence方法允许客户自己设置一个顺序，我们看看子类的实现：

public class BenzModel extends CarModel {
@Override
protected void start() {
System.out.println("奔驰启动……");
}
@Override
protected void stop() {
System.out.println("奔驰停止……");
}
@Override
protected void alarm() {
System.out.println("奔驰鸣笛……");
}
@Override
protected void engineBoom() {
System.out.println("奔驰轰鸣");
}
}
//宝马就略了……一样的

下面我们增加一个测试类实现该需求：

public class Client {
public static void main(String[] args) {
BenzModel benz = new BenzModel();
//存放run顺序
ArrayList<String> sequence = new ArrayList<String>();
sequence.add("engine boom"); //老板说：跑之前先轰鸣比较帅！
sequence.add("start");
sequence.add("stop");
//我们把这个顺序赋予奔驰
benz.setSequence(sequence);
benz.run();
}
}

这样好像已经顺利完成了任务了，但是别忘了，我们这只是满足了一个需求，如果下一个需求是宝马车只轰鸣，再下一个需求是奔驰车只跑不停……等等……那岂不是要一个个写测试类来实现？显然这不是我们想要的。

我们可以这样做：为每种产品模型定义一个建造者，你要啥顺序直接告诉建造者，由建造者来建造即可，于是我们重新设计类图：

我们增加了一个CarBuilder类，由它来组装各个车模型，要什么类型的顺序就由相关的子类去完成即可，我们来看看CarBuilder的代码：

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(); //奔驰车模型
@Override
public void setSequence(ArrayList<String> sequence) {
this.benz.setSequence(sequence); //设置奔驰车模型的运行顺序
}
@Override
public CarModel getCarModel() {
return this.benz; //将这个模型返回
}
}
//宝马车一样，不写了……

现在两辆车的组装者都写好了，现在我们写一个测试类来测试一下：

public class Client {
public static void main(String[] args) {
//存放run顺序
ArrayList<String> sequence = new ArrayList<String>();
sequence.add("engine boom");
sequence.add("start");
sequence.add("stop");
//要用这个顺序造一辆奔驰
BenzBuilder benzBuilder = new BenzBuilder();
//把顺序给奔驰组装者
benzBuilder.setSequence(sequence);
//奔驰组装者拿到顺序后就给你生产一辆来
BenzModel benz = (BenzModel) benzBuilder.getCarModel();
benz.run();
}
}

如果我要生产一辆宝马车，只需要换成宝马车的组装者即可，这样我们不用直接访问产品类了，全部访问组装者就行，是不是感觉到很方便，我管你怎么生产，我扔给你个顺序，你给我弄辆车出来，要的就是这种效果！

可是人的需求是个无底洞，特别是老板，他哪天不爽了，又要换顺序，这样还是挺麻烦的，四个过程（start、stop、alarm、engine boom）按排列组合也有很多中情况，我们不能保证老板想要哪种顺序，咋整？无奈，我们只能使出最后的杀手锏了，找个设计师过来指挥各个时间的先后顺序，然后为每种顺序指定一个代码，你说一种我们立刻就给你生产！我们再修改一下类图……

类图看着有点复杂，其实不然，只是在原来的基础上增加了一个Director类充当着设计师的角色，负责按照指定的顺序生产模型，比如我们要一个A顺序的奔驰车，B顺序的奔驰车，A顺序的宝马车，B顺序的宝马车……等等，我们来看下Director类的代码：

public class Director {
private ArrayList<String> sequence = new ArrayList<String>();
private BenzBuilder benzBuilder = new BenzBuilder();
private BWMBuilder bwmBuilder = new BWMBuilder();
//A顺序的奔驰车
public BenzModel getABenzModel() {
this.sequence.clear();
this.sequence.add("start");
this.sequence.add("stop");
//返回A顺序的奔驰车
this.benzBuilder.setSequence(sequence);
return (BenzModel) this.benzBuilder.getCarModel();
}
//B顺序的奔驰车
public BenzModel getBBenzModel() {
this.sequence.clear();
this.sequence.add("engine boom");
this.sequence.add("start");
this.sequence.add("stop");
//返回B顺序的奔驰车
this.benzBuilder.setSequence(sequence);
return (BenzModel) this.benzBuilder.getCarModel();
}
//C顺序的宝马车
public BenzModel getCBWMModel() {
this.sequence.clear();
this.sequence.add("start");
this.sequence.add("alarm");
this.sequence.add("stop");
//返回C顺序的宝马车
this.bwmBuilder.setSequence(sequence);
return (BenzModel) this.bwmBuilder.getCarModel();
}
//D顺序的宝马车
public BenzModel getDBWMModel() {
this.sequence.clear();
this.sequence.add("engine boom");
this.sequence.add("start");
//返回D顺序的宝马车
this.bwmBuilder.setSequence(sequence);
return (BenzModel) this.bwmBuilder.getCarModel();
}
//还有很多其他需求，设计师嘛，想啥需求就给你弄啥需求
}

有了这样一个设计师，我们的测试类就更容易处理了，比如现在老板要10000辆A类奔驰车，100000辆B类奔驰车，20000C类型宝马车，D类型不要：

public class Client {
public static void main(String[] args) {
Director director = new Director();
for(int i = 0; i < 10000; i ++) {
director.getABenzModel();
}
for(int i = 0; i < 100000; i ++) {
director.getBBenzModel();
}
for(int i = 0; i < 20000; i ++) {
director.getCBWMModel();
}
}
}

是不是很清晰很简单，我们重构代码的最终第就是简单清晰。这就是建造者模式。

2. 建造者模式的定义

我们来看看建造者模式的一般定义：Separate the construction of a complex object from its representation so that the same construction process can create different representations. 即：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。比如上面的例子，我们可以用同样的顺序构造不同的车。建造者模式的通用类图如下：