android源码中和第三方框架中常见的Builder模式

Builder模式

Builder模式也是Java中常用的设计模式，在Android源码中和一些第三方框架中也很常用；

Builder的使用场景

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

Builder的简单实现

如果工厂去造一辆车，将车最基本的部件作为一个抽象类

public abstract class Car {
 protected String mEngine;
 protected String mType;
 protected String mColor;
 protected Car(){}
 //设置发动机
 public void setEngine(String engine){
    this.mEngine=engine;
 }
 //设置车型
 public void setType(String type){
    this.mType=type;
 } 
 //设置颜色
 public abstract void setColor();
@Override
public String toString() {
    return "Car [mEngine=" + mEngine + ", mType=" + mType + ", mColor="
            + mColor + "]";
}

}

例如现在我要组装一辆车小A

public class BlueBird extends Car{
protected BlueBird(){

}
 //设置车的颜色
    @Override
    public void setColor() {
    mColor="蓝色";

    }


}

组装一辆车所需要的基本过程

public abstract class Builder {
    public abstract void buildEngine(String engine);
    public abstract void buildType(String type);
    public abstract void buildColor();
    public abstract Car create();
}

组装小A车所需要的基本过程

public  class BlueBirdBuilder extends Builder {
    private Car mCar=new BlueBird();
    @Override
    public void buildEngine(String engine) {
        mCar.setEngine(engine);
    }

    @Override
    public void buildType(String type) {
        mCar.setType(type);
    }

    @Override
    public void buildColor() {
        mCar.setColor();
    }

    @Override
    public Car create() {
        return mCar;
    }

}

开始组装汽车的机械臂

public class Plant {
        Builder mBuilder=null;
        public Plant (Builder builder){
            this.mBuilder=builder;
        }
        public void build(String engine,String type) {
            mBuilder.buildColor();
            mBuilder.buildEngine(engine);
            mBuilder.buildType(type);

        }
}

启动机械臂并且设置如汽车的基本参数

public static void main(String[] args) {
        // TODO Auto-generated method stub
            Builder builder=new BlueBirdBuilder();
            Plant plant=new Plant(builder);
            plant.build("1.5T", "小型车");
            System.out.println(builder.create().toString());

    }

上述的示例中通过BlueBirdBuilder来构建Car对象，而Plant封装了构建复杂产品对象的过程，对外部隐藏了具体的细节。Builder与Plant一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以构建不同的对象。但是在开发中Plant通常会被省略，而是直接使用一个Builder来进行对象的组装，这个Builder通常为链式调用，代码如下：new A().setC().setB().create();
那么上述的代码如何改为链式调用呢?我们只要从Builder 这个类下手将返回的void 改为Builder类型代码如下：

public abstract class Builder {
    public abstract Builder buildEngine(String engine);
    public abstract Builder buildType(String type);
    public abstract Builder buildColor();
    public abstract Car create();
}

BlueBirdBuilder继承了Builder所以也要进行修改

public  class BlueBirdBuilder extends Builder {
    private Car mCar=new BlueBird();
    @Override
    public Builder buildEngine(String engine) {
        mCar.setEngine(engine);
        return this;
    }

    @Override
    public Builder buildType(String type) {
        mCar.setType(type);
        return this;
    }

    @Override
    public Builder buildColor() {
        mCar.setColor();
        return this;
    }

    @Override
    public Car create() {
        return mCar;
    }

}

这样一个链式调用就组成了：
mBuilder.buildColor().buildEngine(engine).buildColor();