一、白话

  生活中，我们周围有很多构造较为复杂的机器，例如飞机、汽车、手表、电脑等，由很多很多部件组成，对装配的工艺也是有要求，先后顺序等。以汽车为例，由轮子、方向盘、刹车、发动机...等。它们都是汽车一部分，如果要完成汽车的组装，不仅仅只是把它们生产出来，然后放在一块，像拼图一样，放在既定位置就可以了，还需要事先制定好装配工艺，先安装什么，后安装什么。将上述各个模块的生产、组装单独拆分，用以匹配不同汽车的生产和组装。生成器模式（builder）就是用来拆开生产和组装的一种设计模式。

二、定义

  生成器模式，用于创建复杂对象。我们需要一个比较复杂的对象，我们并不关心，而且他的构造过程（比如先后顺序）我们也不关心。这时，我们就需要用到Builder模式了。

三、代码

  组件：产品组件，多个组件组成产品 -轮子、刹车组件。

  产品:  需要构造的复杂对象 -汽车。

  抽象生成器：抽象生成器是一个接口，定义产品的构造各个模块的装配接口，同时返回产品 --汽车生产模板。

  具体生成器：实现抽象生成器，生产各个组件 -- 具体某种车型的生产模板。

  指挥者：负责向用户提供生成器，指挥者根据请求的具体生成器构造出产品对象。

/**
 * 角色-部件
 */
public class Part {
    private String partName;

    public Part() {
    }

    public Part(String partName) {
        this.partName = partName;
    }

    public String getPartName() {
        return partName;
    }

    public void setPartName(String partName) {
        this.partName = partName;
    }
}

/**
 * 角色-产品
 */
public class Product {
    private Part partA;
    private Part partB;
    private Part partC;

    public Product(Part partA, Part partB, Part partC) {
        this.partA = partA;
        this.partB = partB;
        this.partC = partC;
    }

    public Product() {
    }

    public Part getPartA() {
        return partA;
    }

    public void setPartA(Part partA) {
        this.partA = partA;
    }

    public Part getPartB() {
        return partB;
    }

    public void setPartB(Part partB) {
        this.partB = partB;
    }

    public Part getPartC() {
        return partC;
    }

    public void setPartC(Part partC) {
        this.partC = partC;
    }
}

/**
 * 角色-抽象生成器
 * 所有生成器都需要实现该接口
 */
public interface Builder {
    // 创建部件A
    void buildPartA();
    // 创建部件B
    void buildPartB();
    // 创建部件C
    void buildPartC();

    // 组装结果
    Product getResult();
}

/**
 * 角色-具体生成器
 *
 */
public class ConcreteBuilder implements Builder {
    private Part partA;
    private Part partB;
    private Part partC;

    @Override
    public void buildPartA() {
        this.partA = new Part("车轮");
    }

    @Override
    public void buildPartB() {
        this.partB = new Part("刹车");
    }

    @Override
    public void buildPartC() {
        this.partC = new Part("发动机");
    }

    @Override
    public Product getResult() {
        return new Product(partA, partB, partC);
    }
}

/**
 * 角色-指挥者
 */
public class Director {
    private Builder builder;

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

    // 组装各个模块
    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }

}

四、总结

  优点：将一个对象分解为各个对象。可以控制整个对象的生成过程。实现了复杂对象的创建过程和它的部件创建的解耦。

  缺点：不同类型的对象需要实现不同具体生成器，类数量过多。只适用差异很小的产品生产。