Builder 模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。
Builder模式定义
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
Builder模式使用场景
（1）相同的方法，不同的执行顺序，产生不同的事件结果时。
（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时
（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用建造者模式非常合适
（4）当初始化一个对象特别复杂，如参数多，且很多参数都有默认值时
Builder模式的 UML 类图
UML 类图如图1所示
图1
Builder模式的简单实现
计算机的组装过程较为复杂，并且组装顺序是不固定的，为了易于理解，把计算机组装的过程简化为构建主机、设置操作系统、设置显示器 3 个部分，然后通过 Director 和具体的 Builder 来构建计算机对象。如下面示例。
//计算机抽象类，即 Product 角色
public abstract class Computer {
protected String mBoard;
protected String mDisplay;
protected String mOS;
protected Computer() {
}
//设置主板
public void setBoard(String board) {
this.mBoard = board;
}
//设置显示器
public void setDisplay(String display) {
this.mDisplay = display;
}
//设置操作系统
public abstract void setOS();
@Override
public String toString() {
return "Computer [mBoard=" + mBoard + ", mDisplay=" + mDisplay + ", mOS=" + mOS + "]";
}
}
//具体的 Computer 类，Macbook
public class Macbook extends Computer {
@Override
public void setOS() {
mOS = "Mac OS X 10.10";
}
}
//抽象 Builder 类
public abstract class Builder {
//设置主机
public abstract void buildBoard(String board);
//设置显示器
public abstract void buildDisplay(String display);
//设置操作系统
public abstract void buildOS();
//创建Computer
public abstract Computer create();
}
//具体的 Builder 类，MacbookBuilder
public class MacbookBuilder extends Builder {
private Computer computer = new Macbook();
@Override
public void buildBoard(String board) {
computer.setBoard(board);
}
@Override
public void buildDisplay(String display) {
computer.setDisplay(display);
}
@Override
public void buildOS() {
computer.setOS();
}
@Override
public Computer create() {
return computer;
}
}
//Director 类，负责构建 Computer
public class Director {
private Builder builder = null;
public Director(Builder builder) {
this.builder = builder;
}
//构建对象
public void construct(String board, String display) {
builder.buildBoard(board);
builder.buildDisplay(display);
builder.buildOS();
}
}
//测试代码
public class Test {
public static void main(String[] args) {
//构建器
Builder builder = new MacbookBuilder();
// Director
Director director = new Director(builder);
//封装构建过程
director.construct("英特尔主板", "Retina 显示器");
System.out.println("Computer info : " + builder.create().toString());
}
}
输出结果：
Computer info : Computer [mBoard=英特尔主板, mDisplay=Retina 显示器, mOS=Mac OS X 10.10]
上述示例中，通过具体的 MacbookBuilder 来构建 Macbook 对象，而 Director 封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder 与 Director 一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。
在现实开发过程中，Director 角色经常会被忽略。而直接使用一个 Builder 来进行对象的组装，这个 Builder 通常为链式调用，它的关键点是每个 setter 方法都返回自身，也就是 return this，这样就使的 setter 方法可以链式调用，代码如下：
public class ComputerTest {
private String mBoard;
private String mDisplay;
private String mOS;
public ComputerTest(String mBoard, String mDisplay, String mOS) {
this.mBoard = mBoard;
this.mDisplay = mDisplay;
this.mOS = mOS;
}
@Override
public String toString() {
return "Computer [mBoard=" + mBoard + ", mDisplay=" + mDisplay + ", mOS=" + mOS + "]";
}
public static class Builder {
private String mBoard;
private String mDisplay;
private String mOS;
public Builder setBoard(String board) {
this.mBoard = board;
return this;
}
public Builder setDisplay(String display) {
this.mDisplay = display;
return this;
}
public Builder setOS(String os) {
this.mOS = os;
return this;
}
public ComputerTest create() {
return new ComputerTest(mBoard, mDisplay, mOS);
}
}
}
//测试代码
public class Test {
public static void main(String[] args) {
ComputerTest builder = new ComputerTest.Builder()
.setBoard("英特尔主板")
.setDisplay("Retina 显示器")
.setOS("Mac OS X 10.10")
.create();
System.out.println("Computer info : " + builder.toString());
}
}
通过这种形式不仅去除了 Director 角色，整个结构也更加简单，也能对 Product 对象的组装过程有更精细的控制。
优点
- 在建造者模式中， 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
- 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象 。
- 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
- 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。
缺点
- 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
- 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。
模式扩展
建造者模式的简化:
- 省略抽象建造者角色：如果系统中只需要一个具体建造者的话，可以省略掉抽象建造者。
- 省略指挥者角色：在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略指挥者角色，让Builder角色扮演指挥者与建造者双重角色。
