一、概述
在通常情况下，我们调用有参或者无参构造函数来直接实例化对象，那样的参数定制都通过有参构造的顺序定的死死的，往往不能够满足一些需求。
所谓生成器，其实也就是把类的构造拆分，把一个类的许多参数都可以通过get set方法来让类的使用者能够按照自己的需求去按照自己的步骤来设置参数。
二、下面是一个简单的例子：
1、这是一个产品的接口，定义了一些主要的工序
public interface Product {
//以下是这个业务的一些主要工序
void setA(int A);
void setB(int B);
void setC(int C);
}
2、这是上面的产品接口主要实现类：主要的工序操作逻辑在这里实现
public class ProductIml implements Product {
private int A,B,C;
public void setA(int A) {
this.A = A;
}
public void setB(int B) {
this.B = B;
}
public void setC(int C) {
this.C = C;
}
}
3、这是一个生成器接口：主要一类业务的封装
public interface Builder {
//以下是一些某业务的工序
void buildA();
void buildB();
void buildC();
//业务完成返回产品
Product getProduct();
}
4、上述业务的第一种生成方式：
public class BuildOne implements Builder{
//创建要返回的业务产品对象
Product productOne = new ProductIml();
//返回最终产品的方法
public Product getProduct() {
return productOne;
}
public void buildA() {
productOne.setA(1);
}
public void buildB() {
productOne.setB(2);
}
public void buildC() {
productOne.setC(3);
}
}
5、该业务的第二种生成方式：
public class BuildTwo implements Builder
{
Product productTwo = new ProductIml();
int A,B,C;
public Product getProduct() {
return productTwo;
}
public void buildA() {
productTwo.setA(2);
}
public void buildB() {
productTwo.setB(3);
}
public void buildC() {
productTwo.setC(1);
}
}
（4、5两种生成方式就是该产品面临不同的业务需求，都有自己特定的参数设置方式，具体都封装在子类中）
6、指挥者（中介吧，我姑且这么叫，这个中介会根据客户的需求，选取不同的生成器来定制不同的业务）
public class Leader {
private Builder builder;
Leader(Builder builder){
this.builder = builder;
}
//这里可以对业务的工序进行排序
void product(){
builder.buildB();
builder.buildA();
builder.buildC();
}
Product getProduct(){
return builder.getProduct();
}
}
7、客户端使用（业务的选取）
面临不同的业务，选取不同的业务生成器，通过对不同工序的封装来实现不同的场景。
public class Client {
public static void main(String[] args) {
//生成器模式下，可选择一项业务的哪种生产方式，（不同的生产器，具有不同的生产模式，内部细节）
Builder builder = new BuildOne();
//创建一个指导者，指导者选取上面选取的生产方式（不同的指导者，具有不同的生产方案）
Leader leader = new Leader(builder);
//指导者开始业务工作
leader.product();
}
}
三、优缺点
优点：
①扩展性强：当有新的业务需求时，找到相应“中介”，根据需求定制新的生成器，不需要改变原来的生成器，就可以实现业务。
②封装性好：一个业务的具体工序都是在生成器里面，至于怎么加工这些工序都在中介帮你完成，客户是不需要知道业务的具体内部细节。
缺点：
当一个产品，它的业务变化越来越大，生成器也就越来越多，不便于管理。
当一个产品其实不需要那么多的生成器的时候，也就不需要生成器模式，因为反而使得代码臃肿。
四、举例
