4、Android设计模式—（自由扩展你的项目）Builder模式

一、介绍，定义

Builder模式是一步步创建一个复杂对象的创建模式，允许用户在不知道内部构造细节的情况下，可以更精细的控制对象的构造流程。
讲一个复杂对象的构建与他的表示相分离。使得同样的构建过程可以创建不同的表示。

二、使用场景

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

三、Builder模式UML类图

3.png

Products产品类（产品的抽象类）
Builder类（规范产品的组建，但一般不实现具体过程，由子类实现具体组建过程）
ConcreteBuilder类（具体实现Builder类抽象方法）
Director类（统一组装类，多数情况下都会省略该类）。

四、Builder模式简单实现

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

计算机抽象类，即Product角色

public abstract class Computer{
protected String mBoard;
protected String mDisplay;
protected String nOS;

protected Computer(){
}
//设置主板
public void setBoard(String board){
mBoard=board;
}
//设置显示器
public void setDisplay(String display){
mDisplat=display;
}
//设置操作系统
public void setOS();
@Override
public String toString(){
return "Computer[mBoard="+mBoard+",mDisplay="+mDisplay+",mOS="+mOS+"]";
}
}

具体的Computer类，Macbook

public class Macbook extends Computer{
protect Macbook(){
}
@Override
public void setOS(){
mOS="Mac OS X 10.10";
}

抽象Builder类

public abstract class Builder{
//设置主机
protected abstract void buildBoard(String board);
//设置显示器
protected abstract void buildDisplay(String display);
//设置操作系统
protected abstract void buildOS();
//创建Computer
public abstract Computer creat();
}

具体的Build类，MacbookBuilder

public class MacbookBuilder extends Builder{
private Computer mComputer=new Macbook();

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

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

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

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

Director类，负责构造Computer

public class Director{
Builder mBuilder=null;
//@param builder
public Director(Builder builder){
mBuilder=builder;
}
//构建对象
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();
//Director
Dirctor 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,这样就使得setter方法可以链式调用.

五、Builder模式另一个例子

宝马汽车的组装，简单分为几步（组装汽车外壳、组装汽车中控、组装汽车发动机等机械部件、内饰）。
Product类：

public abstract class BMWCar {
    // 汽车外壳
    protected String mShell;
    // 汽车多媒体中控
    protected String mControl;
    // 汽车引擎和其他机械部件
    protected String mEngineAndOthers;
    // 汽车内饰
    protected String mDecoration;

    protected BMWCar(){

    }

    // 转配汽车外壳
    public void setShell(String mShell) {
        this.mShell = mShell;
    }

    // 装配汽车多媒体中控
    public void setControl(String mControl) {
        this.mCOntrol= mControl;
    }

    // 装配汽车机械部件
    public void setEngineAndOthers() {
    }

    // 装配汽车内饰
    public void setDecoration(String mDecoration) {
        this.mDecoration = mDecoration;
    }
}

这个类定义产品，但是并不去装配产品，只是定义一个规则，那么我们想要组装一台X6汽车，这里先抽象的设置X6和一般宝马汽车最大的不同是发动机和机械组件,所以一上来我们的生产工人先把各型号的发动机组装好，这个是技术活，当然给高级工程师，不需要装配工人介入了。

public class BMWX6Car extends BMWCar{
    protected BMWX6Car(){

    }

    // 抽象为X6区别就是发动机等主要机械组件不一样
    @Override
    public void setEngineAndOthers() {
        mEngineAndOthers = "宝马X6专用发动机";
    }
}

宝马汽车的主要部分已经好了，那么把这个大框架给到组装工人去做外层处理，再定义一个生产规则：（Builder类）

public abstract class Builder {
    // 设置外壳
    public abstract Builder buliderShell(String shell);

    // 设置中控系统
    public abstract Builder buliderControl(String control);

    // 装置机械组件
    public abstract Builder buliderEngineAndOthers();

    // 装配内饰
    public abstract Builder buliderDecoration(String decoration);

    // 出厂汽车
    public abstract BMWCar create();
}

这当时组装经理定义好了规则，下发给下一级员工。(下面说具体的Bulider类)

public class BMWX6Bulider extends Builder{
    private BMWCar mBMWCar = new BMWX6Car();

    @Override
    public Builder buliderShell(String shell) {
        mBMWCar.setShell(shell);
        return this;
    }

    @Override
    public Builder buliderControl(String control) {
        mBMWCar.setControl(control);
        return this;
    }

    @Override
    public Builder buliderEngineAndOthers() {
        mBMWCar.setEngineAndOthers();
        return this;
    }

    @Override
    public Builder buliderDecoration(String decoration) {
        mBMWCar.setDecoration(decoration);
        return this;
    }

    @Override
    public BMWCar create() {
        return mBMWCar;
    }
}

为了满足生产线流水工作，组长把这个组装过程封装了一下，只要员工按规矩来就能够组装好，而且组装过程变得非常简单，员工只需要把组装的原件放到指定位置就OK(Director类)。

public class Director {
    Builder mBulider = null;

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

    /**
     * 统一组装，简化生产步骤
     * @param shell
     * @param control
     * @param decoration
     * @return
     */
    public BMWCar createCar(String shell,String control,String decoration){
        return mBulider.buliderShell(shell)
                .buliderControl(control)
                .buliderEngineAndOthers()
                .buliderDecoration(decoration).create();
    }
}

六、优点缺点

优点：
良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节；
建造者独立，容易扩展；
缺点：
会产生多余的Builder对象以及Director对象，消耗内存。