设计模式之Builder模式

Builder模式介绍

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

Builder模式定义

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

Builder模式的使用场景

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

Builder模式的UML类图

角色介绍：

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

Builder.png

Builder模式的简单实现

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

/**
 * 计算机抽象类，即Produce角色
 */
public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOs;

    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 + '\'' +
                '}';
    }
}

/**
 * 具体的Computer类
 */
public class MacBook extends Computer {
    @Override
    public void setmOs() {
        mOs = "Mac OS";
    }
}

/**
 * 抽象Builder类
 */
public abstract class Builder {
    public abstract void builderBoard(String board);
    public abstract void builderDisplay(String display);
    public abstract void builderOS();
    public abstract Computer create();
}


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

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

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

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


/**
 * Director类，负责构造Computer
 */
public class Director {
    Builder builder = null;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct(String broad,String dispplay){
        builder.builderBoard(broad);
        builder.builderDisplay(dispplay);
        builder.builderOS();
    }
}

/**
 * 测试
 */
 @Test
 public void test(){
     //构建器
     MacbookBuilder builder = new MacbookBuilder();

     Director director = new Director(builder);
     //封装构建过程
     director.construct("英特尔主板","Retina显示器");
     System.out.println(builder.create().toString());
  }

/**
 *输出结果 Computer{mBoard='英特尔主板', mDisplay='Retina显示器', mOs='Mac OS'}
 */

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

在实际开发中，Director 角色经常会被省略，而直接使用一个Builder来进行对象的组装，这个Builder 通常为链式调用，它的关键点是每个setter方法都返回自身，也就是return this 这样就使得setter方法可以链式调用，代码如下：

        Computer computer = new MacbookBuilder()
                .setBoard("英特尔")
                .setDisplay("Retina显示器")
                .setOS()
                .create();
        System.out.println(computer.toString());

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

---

总结

Builder 模式在Android 开发中通常作为配置累的构建器将配置的构建和表示分离开来，同时也将配置从目标中隔离出来，避免过多的setter 方法，Builder 模式比较常见的实现形式是通过链式实现，这样代码更简洁，易懂。

优点

• 良好的封装性，使用建造者模式可以是客户端不必知道产品内部组成的细节。
• 建造者独立，容易扩展。

缺点

• 会产生多余的Builder 对象以及Direator 对象，消耗内存。

Demo

设计模式Demo

参考

《Android源码设计模式》