设计模式学习-Builder模式

Builder模式介绍

Builder模式是一步一步创建一个复杂对象的创建型模式。该模式是为了将构造复杂对象的过程与它的部件解耦，使得构建过程和部件的表示隔离开。

Builder模式的定义

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

Builder模式的使用场景

1. 相同的方法，不同的执行顺序，产生不同的事件结果时。
2. 多个部件和零件，都可以装配到一个对象中，但是产生的结果又不相同时。
3. 产品类非常复杂，或者产品类的调用顺序不同产生了不同的作用时。
4. 当初始化一个对象特别复杂，如参数多，且参数很多都具有默认值。

Builder模式的UML类图

角色介绍：

• Product产品类-产品的抽象类；
• Builder-抽象Builder类，规范产品的组建，一般是由子类实现具体的组建过程；
• ConcreteBuilder-具体的Builder类；
• Director-统一组装过程。

Bilder模式的简单实现

计算机的组装过程较为复杂，并且组装过程不固定。故下列例子我们把计算机的组装简化为构建主机、设置操作系统、设置显示器3个部分，然后通过Director和具体的Builder来构建计算机对象。如下：

package Builder;

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 计算机抽象类，即Product角色
 * </pre>
 */
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 void setOS() {
    }

    @Override
    public String toString(){
        return "Computer:[mBoard="+mBoard+",mDisplay="+mDisplay+",mOS="+mOS+"]";
    }
}

package Builder;

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 具体Computer类
 * </pre>
 */
public class MacBook extends Computer{
    protected MacBook(){}

    @Override
    public void setOS(){
        mOS = "Mac OS X 10.10";
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 抽象Builder类
 * </pre>
 */
public abstract class Builder {
    //设置主机
    public abstract void buildBoard(String board);
    //设置显示器
    public abstract void buildDisplay(String display);
    //设置操作系统
    public abstract void buildOS();
    //创建Builder
    public abstract Computer create();
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 具体的Builder类，MacBookBuilder
 * </pre>
 */
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;
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 负责构造Computer
 * </pre>
 */
public class Director {
    Builder mBuilder ;
    public Director(Builder builder){
        mBuilder = builder;
    }

    public void construct(String board,String display){
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

/**
 * <pre>
 *     author : 残渊
 *     time   : 2019/03/22
 *     desc   : 测试代码
 * </pre>
 */
public class Test {
    public static void main(String[] args){
        Builder builder = new MacBookBuilder();
        Director pcDirector = new Director(builder);
        pcDirector.construct("英特尔主板","Retina显示器");
        System.out.println("Computer info:" +builder.create().toString());
    }
}

输出结果：

Computer info:Computer:[mBoard=英特尔主板,mDisplay=Retina显示器,mOS=Mac OS X 10.10]

上述例子中，通过具体的MacBuilder来构建Macbook对象，而Director封装了构建复杂对象的过程，对外隐藏构建细节。Builder和Director一起将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以构建不同的对象。

但需注意的是，在真正开发过程中，Director角色经常会被省略。而直接使用一个Builder来进行对象的组装，即Builder的链式调用，它的关键点就在于每个setter方法都会返回自身，也就是return this，代码大致如下：

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