Java中的设计模式（七）：生成器模式创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或

一、基本概念

生成器模式 （Builder Pattern）是 创建型设计模式 的一种，也被称为建造者模式、构建者模式，生成器模式将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

二、适用场景

隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
多个部件都可以装配到一个对象中，但产生的运行结果不相同；
产品类非常复杂或者产品类因为调用顺序不同而产生不同作用；
初始化一个对象时，参数过多，或者很多参数具有默认值；
Builder模式不适合创建差异性很大的产品类，产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；

三、生成器模式的结构

3.1 生成器（Builder）模式的主要角色说明：

产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口/抽象类，通常还包含一个返回复杂产品的方法 getResult()。
具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

3.2 生成器模式的结构图

3.3 生成器模式的实现

3.3.1 常规实现

具体的产品类，包含多个组成部件

public class Product {
    //有ABCD多个部件
    private String buildA;
    private String buildB;
    private String buildC;
    private String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

抽象建造者，包含创建产品各个子部件的抽象方法

//抽象的建造者
public abstract class Builder {
    //具体产品的各个子部件的抽象方法
    abstract void buildA();//部件A
    abstract void buildB();//部件B
    abstract void buildC();//部件C
    abstract void buildD();//部件B

    //返回具体产品的方法
    abstract Product getProduct();
}

具体建造者1，实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

//具体建造者，实现抽象建造者，完成复杂产品的各个部件的具体创建方法
public class Worker extends Builder{
   private Product product;  //提升作用域
   //通过具体建造者的构造器生成具体产品的对象
   public Worker(){
       product = new Product();
   }

    @Override
    void buildA() {
        product.setBuildA("完成部件A");
        System.out.println("完成部件A");
    }

    @Override
    void buildB() {
        product.setBuildB("完成部件B");
        System.out.println("完成部件B");
    }

    @Override
    void buildC() {
        product.setBuildC("完成部件C");
        System.out.println("完成部件C");
    }

    @Override
    void buildD() {
        product.setBuildD("完成部件D");
        System.out.println("完成部件D");
    }

    @Override
    Product getProduct() {
        System.out.println("完成产品ABCD的创建");
        return product;
    }
}

具体建造者2，实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

public class WorkerTwo extends Builder{

    private Product product;

    public WorkerTwo(){
        product = new Product();
    }

    @Override
    void buildA() {
        product.setBuildA("完成部件A2");
        System.out.println("完成部件A2");
    }

    @Override
    void buildB() {
        product.setBuildB("完成部件B2");
        System.out.println("完成部件B2");

    }

    @Override
    void buildC() {
        product.setBuildC("完成部件C2");
        System.out.println("完成部件C2");

    }

    @Override
    void buildD() {
        product.setBuildD("完成部件D2");
        System.out.println("完成部件D2");

    }

    @Override
    Product getProduct() {
        System.out.println("完成产品ABCDTWO的创建");
        return product;
    }
}

指挥者，调用建造者对象中的部件构造与装配方法完成复杂对象的创建

public class Director {

    //调用建造者对象中的部件构造与装配方法完成复杂对象的创建
    public Product construct(Builder builder){
        builder.buildA();
        builder.buildB();
        builder.buildC();
        builder.buildD();

        return builder.getProduct();
    }
}

客户类，实现具体建造者1

public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        Product build = director.construct(new Worker());//实现具体建造者1
        System.out.println(build.toString());
    }
}
复制代码

测试：在这里插入图片描述

客户类，实现具体建造者2

public class Client {
    public static void main(String[] args) {

        Director director = new Director();
        Product build = director.construct(new WorkerTwo());
        System.out.println(build.toString());
    }
}
复制代码

测试：在这里插入图片描述

上面示例是 Builder模式的常规用法，指挥者类 Director 在 Builder模式中具有很重要的作用，它用于指导具体构建者如何构建产品，控制调用先后次序，并向调用者返回完整的产品类，但是有些情况下需要简化系统结构，可以把Director和抽象建造者进行结合。

3.3.2 更为灵活的实现

产品-->套餐

public class Product {
    //默认套餐
    private String BuildA = "汉堡";
    private String BuildB = "薯条";
    private String BuildC = "炸鸡";
    private String BuildD = "可乐";

    public String getBuildA() {
        return BuildA;
    }

    public void setBuildA(String buildA) {
        BuildA = buildA;
    }

    public String getBuildB() {
        return BuildB;
    }

    public void setBuildB(String buildB) {
        BuildB = buildB;
    }

    public String getBuildC() {
        return BuildC;
    }

    public void setBuildC(String buildC) {
        BuildC = buildC;
    }

    public String getBuildD() {
        return BuildD;
    }

    public void setBuildD(String buildD) {
        BuildD = buildD;
    }

    @Override
    public String toString() {
        return "Product{" +
                "BuildA='" + BuildA + ''' +
                ", BuildB='" + BuildB + ''' +
                ", BuildC='" + BuildC + ''' +
                ", BuildD='" + BuildD + ''' +
                '}';
    }
}
复制代码

抽象建造类

public abstract class Builder {

    abstract Builder buildA(String msg);//汉堡
    abstract Builder buildB(String msg);//薯条
    abstract Builder buildC(String msg);//炸鸡
    abstract Builder buildD(String msg);//可乐

    //返回具体的套餐
    abstract Product getProduct();
}
复制代码

具体建造者-->服务员

public class Worker extends Builder{
    private Product product;

    public Worker() {
        product = new Product();
    }

    @Override
    Builder buildA(String msg) {
        product.setBuildA(msg);
        return this;
    }

    @Override
    Builder buildB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder buildC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder buildD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct() {
        return product;
    }
}
复制代码

客户：实现默认套餐

public class Client {
    public static void main(String[] args) {
        Worker worker = new Worker();
        Product product = worker.getProduct();
        System.out.println(product.toString());
    }
}
复制代码

测试：

在这里插入图片描述

实现自选套餐：

public class Client {
    public static void main(String[] args) {
        Worker worker = new Worker();
        Product product = worker
                .buildA("蛋糕")
                .buildB("鸡腿")
                .buildC("")
                .buildD("")
                .getProduct();
        System.out.println(product.toString());
    }
}
复制代码

测试：在这里插入图片描述

四、生成器模式的优缺点比较

一般的套路：优点是比较简单，开发效率高，缺点是如果参数真的很多的话鬼知道每个对应的是什么意思啊。

生成器模式：优点是可以将构造器的setter方法名取成类似注释的方式，这样我们可以很清晰的知道刚才究竟设置的什么值，可读性较高，缺点是比较冗长。

4.1 优点

使用建造者模式可以使客户端不必知道产品内部组成的细节。
具体的建造者类之间是相互独立的，这有利于系统的扩展。
具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响。

4.2 缺点

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

五、生成器模式与工厂模式的比较

5.1 工厂方法模式VS生成器模式

工厂方法模式注重的是整体对象的创建方式；
建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。

举个简单例子： 1.如要制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人； 2.而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了。

5.2 抽象工厂模式VS生成器模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。

内容参考和转载自： www.jianshu.com/p/3d1c9ffb0… juejin.cn/post/700112… juejin.cn/post/699398…