Java设计模式之建造者（Builder）模式

Java设计模式之建造者（Builder）模式

1. 建造者模式介绍：
   Builder模式是一步一步创建一个复杂对象的创建性模式，它允许用户在不知道内部构建细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的不见解耦，使得构建过程和部件表示隔离起来。

   因为一个复杂的对象又很多大量组成部分，如电脑，有主板，显卡，显示器，CPU，电源，还有各种小零件等，如何将这些部件装配成一台可以使用的电脑，这个配装过程需要一定的时间，也很复杂，对于这种情况，为了在构建过程中对外部隐藏实现细节，就可以使用建造者模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。
   　

2. 建造者模式的定义：
   　
   将一个复杂对象那个的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

3. 建造者模式的使用场景：
   　
   　3.1相同的方法，不同的执行顺序，产生不同的事件结果时

   　3.2多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
   　
   　3.3产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个时候使用建造者模式非常适合。
   　
   　3.4当初始化一个对象特别复杂，如参数多，切很多参数都具有默认值时。

4. 建造者模式的UML类图：
   　
   角色介绍：
   　
   Product产品类——产品的抽象类；
   　
   Builder——抽象Builder类，规范产品的组建，一般是由子类实现具体的组建过程；
   　　
   ConcreteBuilder——具体的Builder类；
   　
   Director——统一组装过程
   　
   　
5. 建造者模式的简单实现：
   　
   　计算机的组装过程较为复杂，并且组装顺序是不固定的，为了易于理解，我们把计算机组装的过程简化为构建主机，设置操作系统、设置显示器3各部分，然后通过Director和具体的Builder来构建计算机对象，如下代码：
   　
   Computer.java

/**
 计算机抽象类，相当于Product角色
 */
public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

    protected Computer(){

    }
    //设置主板
    public void setmBoard(String mBoard) {
        this.mBoard = mBoard;
    }
    //设置显示器
    public void setmDisplay(String mDisplay) {
        this.mDisplay = mDisplay;
    }
    //设置操作系统
    public abstract void setmOS();

    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOS='" + mOS + '\'' +
                '}';
    }
}

Windows.java

/**
 具体的Computer类，Windows
 */
public class Windows extends Computer {
    protected Windows(){

    }

    @Override
    public void setmOS() {
        mOS = "Windows10";
    }

}

Builder.java

/**
 * 抽象Builder类
 */
public abstract class Builder {
    //设置主机
    public abstract void builderBoard(String borad);
    //设置显示器
    public abstract void builderDisplay(String display);
    //设置操作系统
    public abstract void builderOS();

    //创建Computer
    public abstract Computer create();
}

WindowsBuilder.java

/**
 * 具体的Builder类，WindowsBuilder
 */
public class WindowsBuilder extends Builder {
    private Computer mComputer = new Windows();
    @Override
    public void builderBoard(String borad) {
        mComputer.setmBoard(borad);
    }

    @Override
    public void builderDisplay(String display) {
        mComputer.setmDisplay(display);
    }

    @Override
    public void builderOS() {
        mComputer.setmOS();
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

Director.java

/**
 * Director类，负责构造Computer
 */
public class Director {
    Builder mBuilder;
    public Director(Builder mBuilder){
        this.mBuilder = mBuilder;
    }

    /**
     * 构建对象
     * @param board
     * @param display
     */
    public void construct(String board, String display){
        mBuilder.builderBoard(board);
        mBuilder.builderDisplay(display);
        mBuilder.builderOS();
    }
}

Test.java

/**
 * 测试代码
 */
public class Test {
    public static void main(String[] args) {
        //构造器
        Builder builder = new WindowsBuilder();
        Director pcDirector = new Director(builder);
        //封装构建过程，
        pcDirector.construct("华硕主板","Retina显示器");
        System.out.println("Computer Info : " + builder.create().toString());
    }
}

上述实例中，通过具体的WindowsBuilder来构建Windows对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使用同样的构造过程可以创建不同的对象。
值得注意的是，在显示开发过程中，Director角色经常会被省略。而直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this，这样就使得setter方法可以链式调用，代码大致如下：

new TestBuilder().setA(“A”).setB(“B”).create()；

通过这种形式不仅去除了Director角色，整个结构也更加简单，也能对Product对象的组装过程有更精细的控制。