Builder设计模式——自由的扩展你的项目

介绍

builder模式是一步一步创建一个复杂对象的创建性模式，它允许用户在不知道内部具体构建细节的情况下可以更加精细的控制对象的构建。因此，当需要构建内部结构复杂的对象的时候，就可以使用builder设计模式，使用该模式可以逐步的构造对象，使得对象的创建更加有弹性。该设计模式的关键就是将包含多个组件的的对象创建分多个步骤，并将这些步骤封装在一个生成器（Builder接口）中。
注意：构建的过程必须允许有不同的的表示。

使用场景

1. 相同的方法，不同的执行顺序，产生不同事件结果
2. 多个部分可以组装到同一个对象中，但是产生的运算结果不同
3. 产品类比较复杂，或者产品类调用顺序不同产生不同的结果或作用
4. 初始化一个对象比较复杂，比如参数多，很多参数具有默认值

角色

一般的模式（四种角色）：
1、定义产品类，空参构造方法（产品 Car）
2、定义一个接口（Builder），在接口中定义产品每一部分实现的方法，方法返回Builder对象，并有一个组成产品的方法（抽象生成器）
3、实现接口（具体生成器）
4、组成产品的控制类（指挥者）
5、在具体操作类构建对象（使用）

简单的实现

通过汽车组装的实例，简单实现builder设计模式：

汽车对象（bean）：

public class Car {
    private String wheel;
    private int color;
    private String door;
    public Car() {
    }
    public String getWheel() {
        return wheel;
    }
    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
    public int getColor() {
        return color;
    }
    public void setColor(int color) {
        this.color = color;
    }
    public String getDoor() {
        return door;
    }
    public void setDoor(String door) {
        this.door = door;
    }
    @Override public String toString() {
        return "Car{" +
               "wheel='" + wheel + '\'' +
               ", color=" + color +
               ", door='" + door + '\'' +
               '}';
    }
}

汽车的组装是一个特别复杂的事件，有轮子、门、颜色等等步骤，因此使用builder模式
抽象的builder接口：

public interface Builder {
    Builder buildPartA();
    Builder buildPartB();
    Builder buildPartC();
    Car getProduct();
}

builder实现类：
在实现类中，可以实现我们需要的样式和组成的产品，对于默认的组件，可以空实现，也就是什么事也不做，这样可以通过这种方式构建不同的产品样式，这是builder设计模式的关键所在

public class ConcreteBuilder implements Builder {
    private Car car;
    public ConcreteBuilder() {
        car=new Car();
    }
    @Override public Builder buildPartA() {
        car.setColor(1);
        return this;
    }
    @Override public Builder buildPartB() {
        car.setDoor("4");
        return this;
    }
    @Override public Builder buildPartC() {
        car.setWheel("6");
        return this;
    }
    @Override public Car getProduct() {
        return car;
    }
}
public class ConcreteBuilder2 implements Builder {
    private Car car;
    @Override public Builder buildPartA() {
        car.setWheel("4");
        return this;
    }
    @Override public Builder buildPartB() {
        car.setColor(R.color.colorAccent);
        return this;
    }
    @Override public Builder buildPartC() {
        return null;
    }
    @Override public Car getProduct() {
        return car;
    }
}

组成类：

/**
 * 内部实现组成
 * @author panzhijie
 * @version 2017-01-23 10:24
 */
public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //组成完整的对象
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

调用：

ConcreteBuilder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        //组成完整的产品
        director.construct();

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

在实际的开发中，Director经常不会使用，而是直接使用Builder实现类来进行组装，这个Builder的实现类通常为链式调用，它的关键点是每一个setter方法都是返回自身，这样就可以实现链式调用。