• 彻底理解建造者模式

    建造者模式

    • 建造者模式也属于创建型模式，它提供了一种创建对象的最佳方式。

    1. 概念

    • 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    • 主要作用：用户不知道对象的创建过程和细节的情况下就可以直接创建负责的对象，即用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（影藏内部的建造过程和细节）
    • 分离了部件的构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
    • 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
    • 建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

    2. 结构

    • 建造者（Builder）模式包含如下角色：

      • 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。

      • 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。

      • 产品类（Product）：要创建的复杂对象。

      • 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

    3. 实现案例

    3.1 案例一：普通的建造者案例

    • 抽象建造者：制定方法

      public interface Builder {
    void step1();

    void step2();

    void step3();

    Product getProduct();
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    • 产品类

      public class Product {
    private String step1;
    private String step2;
    private String step3;

    public void setStep1(String step1) {
        this.step1 = step1;
    }

    public void setStep2(String step2) {
        this.step2 = step2;
    }

    public void setStep3(String step3) {
        this.step3 = step3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "step1='" + step1 + '\'' +
                ", step2='" + step2 + '\'' +
                ", step3='" + step3 + '\'' +
                '}';
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    • 具体建造者

      public class Worker implements Builder {

    private Product product;

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

    @Override
    public void step1() {
        product.setStep1("步骤1");
        System.out.println("步骤1");
    }

    @Override
    public void step2() {
        product.setStep2("步骤2");
        System.out.println("步骤2");
    }

    @Override
    public void step3() {
        product.setStep3("步骤3");
        System.out.println("步骤3");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31

    • 指挥者：核心，负责指挥构建一个工程，工程如何构建，由它决定

      public class Director {

    //指挥Worker工作步骤
    public Product build(Builder builder){
        builder.step1();
        builder.step2();
        builder.step3();

        return builder.getProduct();
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11

    • 测试方法

      public class Test {
    public static void main(String[] args) {
        //创建指挥
        Director director = new Director();
        //指挥Worker完成工作
        Product build = director.build(new Worker());
        System.out.println(build.toString());
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    • 输出结果

      .

    3.2 案例二：建造者模式实现链式赋值

    • 这种方式没有指挥类，相当于将指挥类的功能交付给具体的建造者

    • 抽象建造者

      public interface Builder {

    Builder buildA(String msg);//汉堡

    Builder buildB(String msg);//可乐

    Builder buildC(String msg);//薯条

    Builder buildD(String msg);//炸鸡

    Product getProduct();
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12

    • 产品类

      public class Product {
    //初始值，即默认套餐
    private String buildA = "汉堡";
    private String buildB = "可乐";
    private String buildC = "薯条";
    private String buildD = "炸鸡";

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

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

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

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

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33

    • 具体建造者

      public class Worker implements Builder {

    private Product product;

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

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

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

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

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

    @Override
    public Product getProduct() {
        return product;
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37

    • 测试方法

      public class Test {
    public static void main(String[] args) {
        //服务员
        Worker worker = new Worker();

        Product product = worker.buildA("鸡米花").getProduct();
        System.out.println(product.toString());
        //Product{buildA='鸡米花', buildB='可乐', buildC='薯条', buildD='炸鸡'}
	
        //链式编程
        Product product1 = worker.buildA("鸡排")
                .buildB("牛肉汉堡")
                .buildC("柠檬汁")
                .getProduct();
        System.out.println(product1.toString());
        //Product{buildA='鸡排', buildB='牛肉汉堡', buildC='柠檬汁', buildD='炸鸡'}
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18

    3.3 案例三：用静态内部类实现建造者模式

    • 事实上，在平时编写代码时，我们通常都会忽略对象的复杂性，优先考虑使用工厂模式创建对象，而不是建造者模式。因为工厂模式和建造者模式的作用都是创建一个产品对象，相对于建造者模式来说，工厂模式没有抽象建造者和指挥者，所以结构更加简洁直接，因此更常使用。

    • 一般情况下，我们更习惯使用静态内部类的方式实现建造者模式，即一个产品类内部自动带有一个具体建造者，由它负责该产品的组装创建，不再需要 Builder 和 Director。这样做可以使产品表示与创建之间的联系更加紧密，结构更加紧凑，同时使得建造者模式更加简洁。

      • 产品类

        public class Product {
    private String buildA = "汉堡";
    private String buildB = "可乐";
    private String buildC = "薯条";
    private String buildD = "炸鸡";

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

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

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

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

    @Override
    public String toString() {
        return "Product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
    
    //静态内部类
    public static class Builder {
        private Product product = new Product();

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

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

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

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

        public Product getProduct() {
            return product;
        }
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12
        • 13
        • 14
        • 15
        • 16
        • 17
        • 18
        • 19
        • 20
        • 21
        • 22
        • 23
        • 24
        • 25
        • 26
        • 27
        • 28
        • 29
        • 30
        • 31
        • 32
        • 33
        • 34
        • 35
        • 36
        • 37
        • 38
        • 39
        • 40
        • 41
        • 42
        • 43
        • 44
        • 45
        • 46
        • 47
        • 48
        • 49
        • 50
        • 51
        • 52
        • 53
        • 54
        • 55
        • 56
        • 57
        • 58
        • 59
        • 60
        • 61

      • 测试方法

        public class Test {
    public static void main(String[] args) {
        Product product = new Product.Builder()
                .buildA("香辣鸡腿堡")
                .buildB("墨西哥鸡肉卷")
                .buildC("提拉米苏")
                .buildD("冰阔落")
                .getProduct();
        System.out.println(product.toString());
        //Product{buildA='香辣鸡腿堡', buildB='墨西哥鸡肉卷', buildC='提拉米苏', buildD='冰阔落'}
    }
}

        • 1
        • 2
        • 3
        • 4
        • 5
        • 6
        • 7
        • 8
        • 9
        • 10
        • 11
        • 12

    4. 优点与缺点

    • 优点：

      • 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
      • 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
      • 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
      • 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险，符合开闭原则。

    • 缺点：

      • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
  • 相关阅读:
    CentOS与Xshell，开启ssh协议sshd服务远程控制
    Java虚拟机（JVM）面试题（总结最全面的面试题！！！）
    《动手学深度学习 Pytorch版》 9.1 门控循环单元（GRU）
    java计算机毕业设计家电仓储管理系统MyBatis+系统+LW文档+源码+调试部署
    C++：this指针
    VMware17.0.1密匙/下载/安装Ubuntu18.04
    VSCODE 系列（一）VSCODE下载和安装
    今日头条小程序是什么
    点云从入门到精通技术详解100篇-LiDAR 点云与影像匹配点云的滤波方法研究与应用（中）
    如何实现项目管理自动化？为什么项目需要需要自动化？
  • 原文地址：https://blog.csdn.net/qq_52248567/article/details/126167092