Builder（建造者）模式

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角色扮演指挥者与建造者双重角色。