Builder模式——自由扩展你的项目

● Builder模式介绍

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

        因为一个复杂的对象有很多大量组成部分，如汽车，有车轮、方向盘、发动机，还有各种小零件等，如何将这些部件装配成一辆汽车，这个装配过程很漫长，也很复杂，对于这种情况，为了在构建过程中对外部隐藏实现细节，就可以使用Builder模式将部件和组装过程分离，使得构建过程和部件都可以自由扩展，两者之间的耦合度也降到最低。

● Builder模式定义

        将一个复杂对象构建于它的表示分离，使得同样的构建过程可以创建不同的表示。

● Builder模式的使用场景

        （1）相同的方法，不同的执行顺序，产生不同的事件结果时；

        （2）多个部件或零件，都可以装配都一个对象中，但产生的运行结果又不相同时；

        （3）产品类非常复杂，或者产品类中的调用顺序不同产生不同的作用，这个时候使用创作者模式非常合适；

（4）当初始化一个对象特别复杂，如参数多，且多参数都具有默认值时；

● Builder模式的UML类图

        UML类图如下图所示：

         角色介绍：

        Product——产品类产品的抽象类；

        Builder——抽象Builder类，规范产品的组建，一般子类实现具体的组建过程；

        ConerteBuilder——具体的Builder类；

        Diretor——统一组装过程。

● 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) {
        mBoard = board;
    }

    //设置显示器
    public void setDisplay(String display){
        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 {

    public Macbook() {
    }

    @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 mComputer = new Macbook();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        mComputer.setOS();
    }

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

//Director类，负责构造Cmputer
public class Director {
    Builder mBuilder = null;

    /**
     * @param builder
     */
    public Director(Builder builder) {
        mBuilder = builder;
    }

    /**
     * 构造对象
     * @param board
     * @param display
     */
    public void construct(String board, String display) {
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

//测试代码
public class Test {
    public static void main(String[] args) {
        //构造器
        Builder builder = new MacbookBuilder();
        //Diector
        Director pcDirector = new Director(builder);
        //封装构造过程，4核、内存2GB、Mac系统
        pcDirector.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，这样就使得setrer方法可以链式调用，代码大致如下

new TestBuilder().setA("A").setB("B").create();

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