很多时候我们会构建非常复杂的类，内部初始化构成需要进行很多复杂交互操作，比如需要去数据库查询数据后作为属性初始值，或者说我们想控制它的内部初始化的过程，将构建过程分离出来。
建造者模式是创建模式之一，看到“建造”就明白这肯定是个不断累加的过程，比如说你想自己装一台笔记本，那你得装cpu、内存、硬盘、显卡、散热…需要很多东西来支持最后这个产品的完成，并且在组装过程中每一步要有一定的顺序，如果组装配件的品质不一样，最后得到的产品也会不一样。
简单来说就是通过一切些方式（继承、重载），动态创建具有多种属性的对象。
上面介绍已经说过了，就是在构建复杂对象的时候，比如持有数据的对象，或者内部数据需要以一定顺序加载的时候。让构建的过程透明，使用者运行很少的代码就能创建一个十分复杂的对象。
懂了吧。。。
我们假设要生产一台“电脑”，请翻到计算机组成原理第一节，大声告诉我冯·诺依曼计算机由哪几部分组成？
时隔几年还是忘不了大学时光呀
我们先看看咱们要做一个什么样的产品
/**
* what: 这是咱们的计算机 <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class Computer {
//运算器
private Calculator calculator;
//控制器
private Controller controller;
//存储器
private Storage storage;
//操作系统
private Os os;
//输入输出设备
private InputOutput io;
public Calculator getCalculator() {
return calculator;
}
public void setCalculator(Calculator calculator) {
this.calculator = calculator;
}
public Controller getController() {
return controller;
}
public void setController(Controller controller) {
this.controller = controller;
}
public Storage getStorage() {
return storage;
}
public void setStorage(Storage storage) {
this.storage = storage;
}
public Os getOs() {
return os;
}
public void setOs(Os os) {
this.os = os;
}
public InputOutput getIo() {
return io;
}
public void setIo(InputOutput io) {
this.io = io;
}
}
代码里Calculator、Controller …等类都是自己创建的，里面没什么方法，只是做标识，完整代码我已经上传了，下文里有链接
首先我们需要定义一个Builder，其实可以抽象类也可以接口,这个类定义了所有具体建造者应该做哪些事情
/**
* what: 建造者，咱们的技术经理<br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public abstract class AbstractBuilder {
//构建运算器
abstract void buildCalculator();
//构建控制器
abstract void buildController();
//构建输入输出设备
abstract void buildInputOutput();
//构建操作系统
abstract void buildOs();
//构造存储器
abstract void buildStorage();
//生产电脑
abstract Computer createComputer();
}
然后我们要创建具体的Builder来生产咱们的产品，这里为了举例我写了两个builder，一个用来生产联想电脑，一个用来生产mac
/**
* what: 咱们组装一台联想电脑. <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class LenovoBuilder extends AbstractBuilder{
private Computer lenovoComputer = new Computer();
@Override
void buildCalculator() {
lenovoComputer.setCalculator(new LenovoCalculator());
}
@Override
void buildController() {
lenovoComputer.setController(new LenovoController());
}
@Override
void buildInputOutput() {
lenovoComputer.setIo(new LenovoIo());
}
@Override
void buildOs() {
lenovoComputer.setOs(new LenovoOs());
}
@Override
void buildStorage() {
lenovoComputer.setStorage(new LenovoStorage());
}
@Override
Computer createComputer() {
return lenovoComputer;
}
}
/**
* what: 咱们组装一台Mac. <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class MacBuilder extends AbstractBuilder{
private Computer macComputer = new Computer();
@Override
void buildCalculator() {
macComputer.setCalculator(new MacCalculator());
}
@Override
void buildController() {
macComputer.setController(new MacController());
}
@Override
void buildInputOutput() {
macComputer.setIo(new MacIo());
}
@Override
void buildOs() {
macComputer.setOs(new MacOs());
}
@Override
void buildStorage() {
macComputer.setStorage(new MacStorage());
}
@Override
Computer createComputer() {
return macComputer;
}
}
可以看到上面两个具体builder类在实现抽象方法时调用了不同的组件来构建产品，即实际生产的是哪一种产品取决于是哪个具体builder在构建产品，我们还需要一个Director来和用户(client)沟通
/**
* what: 产品经理开始忽悠客户了 <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class Director {
private AbstractBuilder builder = null;
public Director(AbstractBuilder builder){
//指定当前实际builder
this.builder = builder;
}
public Computer createComputer(){
//组装电脑
builder.buildCalculator();
builder.buildController();
builder.buildInputOutput();
builder.buildOs();
builder.buildStorage();
//生产电脑
return builder.createComputer();
}
}
OK，现在顾客可以通过产品经理(Director)来或者指定产品了：
/**
* what: 客户要买电脑了，肯定找咱们产品经理呀 <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class Client {
public static void main(String[] args) {
//先来一台联想的
Computer lenovoComputer = buyComputer(new LenovoBuilder());
//再来一台Mac
Computer macComputer = buyComputer(new MacBuilder());
}
private static Computer buyComputer(AbstractBuilder builder){
Director director = new Director(builder);
return director.createComputer();
}
}
点击获取完整代码
提取码: 5qce
除了上述用法之外，建造者模式还常用于优化构造函数参数过多，可读性不高的情况。优化前：
/**
* what: 多参数优化演示 <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class Computer {
private String calculator;
private String controller;
private String inputoutput;
private String os;
private String storage;
private Computer(){
}
Computer(String calculator,String controller,String inputoutput,String os,String storage){
this.calculator = calculator;
this.controller = controller;
this.inputoutput = inputoutput;
this.os = os;
this.storage = storage;
}
}
我们再来看看优化后：
/**
* what: 优化后 <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class ComputerPlus {
private String calculator;
private String controller;
private String inputoutput;
private String os;
private String storage;
private ComputerPlus(){
}
public final static class Builder{
private String calculator;
private String controller;
private String inputoutput;
private String os;
private String storage;
public Builder(){
}
public Builder calculator(String calculator){
this.calculator = calculator;
return this;
}
public Builder controller(String controller){
this.controller = controller;
return this;
}
public Builder inputoutput(String inputoutput){
this.inputoutput = inputoutput;
return this;
}
public Builder os(String os){
this.os = os;
return this;
}
public Builder storage(String storage){
this.storage = storage;
return this;
}
public ComputerPlus createComputerPlus(){
return new ComputerPlus(this);
}
}
}
利用静态内部类来存储配置并组装目标对象，会让代码可读性提高不少，下面来看看使用时的差别：
/**
* what: 优化测试. <br/>
* how: (如何使用). <br/>
*
* @author ycf created on 2020/7/13
*/
public class Test {
public static void main(String[] args) {
//优化前
Computer computer = new Computer("1","2","3","4","5");
//优化后可读性大大提高
ComputerPlus computerPlus = new ComputerPlus.Builder()
.calculator("1")
.controller("2")
.inputoutput("3")
.os("4")
.storage("5")
.createComputerPlus();
}
}
是不是显得优雅多了 ？
当然建造者模式缺点也显而易见，和抽象工厂一样的代码膨胀问题，不过这也算是牺牲空间换取时间了吧。并且在拓展性上不如抽象工厂，要求创建的产品的相似性比较高的时候使用。
好的，对建造者模式的讲解就到这里了，如有错误欢迎指正！O(∩_∩)O