设计模式之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封装了构建复杂产品对象的过程,对外隐藏构建细节。BuilderDirector 一起将一个复杂的构建与它的表示分离,使得同样的构建过程可以创建不同的对象。

在实际开发中,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源码设计模式》

推荐阅读更多精彩内容