• 【23种设计模式】建造者模式【⭐⭐⭐】

    个人主页：金鳞踏雨

    个人简介：大家好，我是金鳞，一个初出茅庐的Java小白

    目前状况：22届普通本科毕业生，几经波折了，现在任职于一家国内大型知名日化公司，从事Java开发工作

    我的博客：这里是CSDN，是我学习技术，总结知识的地方。希望和各位大佬交流，共同进步 ~

    比较简单，但是很经常用！

    个人感悟：

    为什么会有这种设计模式？往往是因为语言或者框架本身的缺陷而导致的。这个语言或者框架本身就不支持这种开发形式，我们必须使用一种开发"套路"来解决这个问题！

    那为什么有一些设计模式我们在开发中很少见呢？因为本身一些框架就提供了这些功能！我们使用起来就很简单，所以就没有那么重要了！

    一、原理

    Builder 模式，中文翻译为建造者模式或者构建者模式，也有人叫它生成器模式。

    实际上，建造者模式的原理和代码实现非常简单，掌握起来并不难，难点在于应用场景。比如，你有没有考虑过这样几个问题：直接使用构造函数或者配合 set 方法就能创建对象，为什么还需要建造者模式来创建呢？建造者模式和工厂模式都可以创建对象，那它们两个的区别在哪里呢，话不多说，我们直接来学习：

    角色

    1. 产品（Product）：表示将要被构建的复杂对象。
    2. 抽象创建者（Abstract Builder）：定义构建产品的接口，通常包含创建和获取产品的方法。
    3. 具体创建者（Concrete Builder）：实现抽象创建者定义的接口，为产品的各个部分提供具体实现。
    4. 指挥者（Director）：负责调用具体创建者来构建产品的各个部分，控制构建过程。

    示例代码

    我们考虑一个文档编辑器的例子。假设我们需要创建一个复杂的HTML文档，它包含了标题、段落和图像等元素。

    1、产品（Product）类 - HTML文档（HtmlDocument）：

    1. public class HtmlDocument {
    2.     private String header = "";
    3.     private String body = "";
    4.     private String footer = "";
    5.  
    6.     public void addHeader(String header) {
    7.         this.header = header;
    8.     }
    9.  
    10.     public void addBody(String body) {
    11.         this.body = body;
    12.     }
    13.  
    14.     public void addFooter(String footer) {
    15.         this.footer = footer;
    16.     }
    17.  
    18.     @Override
    19.     public String toString() {
    20.         return "" + header + "" + body + "
      " + footer + "
      "      ;
    21.     }
    22. }

    2、抽象创建者（Abstract Builder）类 - HtmlDocumentBuilder：

    1. public abstract class HtmlDocumentBuilder {
    2.     protected HtmlDocument document;
    3.  
    4.     public HtmlDocument getDocument() {
    5.         return document;
    6.     }
    7.  
    8.     public void createNewHtmlDocument() {
    9.         document = new HtmlDocument();
    10.     }
    11.  
    12.     public abstract void buildHeader();
    13.     public abstract void buildBody();
    14.     public abstract void buildFooter();
    15. }

    3、具体创建者（Concrete Builder）类 - ArticleHtmlDocumentBuilder：

    1. // 实现抽象
    2. public class ArticleHtmlDocumentBuilder extends HtmlDocumentBuilder {
    3.     @Override
    4.     public void buildHeader() {
    5.         document.addHeader("Article Header");
    6.     }
    7.  
    8.     @Override
    9.     public void buildBody() {
    10.         document.addBody("Article Body");
    11.     }
    12.  
    13.     @Override
    14.     public void buildFooter() {
    15.         document.addFooter("Article Footer");
    16.     }
    17. }

    4、指挥者（Director）类 - HtmlDirector：

    1. public class HtmlDirector {
    2.     private HtmlDocumentBuilder builder;
    3.  
    4.     public HtmlDirector(HtmlDocumentBuilder builder) {
    5.         this.builder = builder;
    6.     }
    7.  
    8.     public void constructDocument() {
    9.         builder.createNewHtmlDocument();
    10.         builder.buildHeader();
    11.         builder.buildBody();
    12.         builder.buildFooter();
    13.     }
    14.  
    15.     public HtmlDocument getDocument() {
    16.         return builder.getDocument();
    17.     }
    18. }

    现在我们可以使用创建者设计模式来构建一个HTML文档对象：

    1. public class Main {
    2.     public static void main(String[] args) {
    3.         HtmlDocumentBuilder articleBuilder = new ArticleHtmlDocumentBuilder();
    4.         HtmlDirector director = new HtmlDirector(articleBuilder);
    5.  
    6.         director.constructDocument();
    7.         HtmlDocument document = director.getDocument();
    8.  
    9.         System.out.println("Constructed HTML Document: \n" + document);
    10.     }
    11. }

    在这个例子中，我们创建了一个表示HTML文档的产品类（HtmlDocument），一个抽象的创建者类（HtmlDocumentBuilder），一个具体的创建者类（ArticleHtmlDocumentBuilder）和一个指挥者类（HtmlDirector）。当我们需要创建一个新的HTML文档对象时，我们可以使用指挥者类来控制构建过程，从而实现了将构建过程与表示过程的分离。

    以上是一个创建者设计模式的标准写法，事实，我们在工作中往往不会写的这么复杂，为了创建一个对象，我们创建了很多辅助的类，总觉得不太合适，在这个案例中，我们可以使用内部类来简化代码，以下是修改后的代码（甚至我们还移除了抽象层）

    1. public class HtmlDocument {
    2.     private String header = "";
    3.     private String body = "";
    4.     private String footer = "";
    5.  
    6.     public void addHeader(String header) {
    7.         this.header = header;
    8.     }
    9.  
    10.     public void addBody(String body) {
    11.         this.body = body;
    12.     }
    13.  
    14.     public void addFooter(String footer) {
    15.         this.footer = footer;
    16.     }
    17.  
    18.     @Override
    19.     public String toString() {
    20.         return "" + header + "" + body + "
      " + footer + "
      "      ;
    21.     }
    22.  
    23.     public static class Builder {
    24.         protected HtmlDocument document;
    25.  
    26.         public Builder() {
    27.             document = new HtmlDocument();
    28.         }
    29.  
    30.         public Builder addHeader(String header) {
    31.             document.addHeader(header);
    32.             return this;
    33.         }
    34.  
    35.         public Builder addBody(String body) {
    36.             document.addBody(body);
    37.             return this;
    38.         }
    39.  
    40.         public Builder addFooter(String footer) {
    41.             document.addFooter(footer);
    42.             return this;
    43.         }
    44.  
    45.         public HtmlDocument build() {
    46.             return document;
    47.         }
    48.     }
    49. }

    创建一个HTML文档对象

    1. public class Main {
    2.     public static void main(String[] args) {
    3.         HtmlDocument.Builder builder = new HtmlDocument.Builder();
    4.         HtmlDocument document = builder.addHeader("This is the header")
    5.                                        .addBody("This is the body")
    6.                                        .addFooter("This is the footer")
    7.                                        .build();
    8.  
    9.         System.out.println("Constructed HTML Document: \n" + document);
    10.     }
    11. }

    将创建者类（Builder）作为HTML文档类（HtmlDocument）的内部类。

    这样做可以让代码更加紧凑。此外，我们使用了一种流式接口，使得在客户端代码中创建HTML文档对象更加简洁。

    二、为什么需要建造者模式

    1. 根据复杂的配置项进行定制化构建

    首先，我们先看一个mybaits中经典的案例，这个案例中使用了装饰器和创建者设计模式：

    1. public class CacheBuilder {
    2.     private final String id;
    3.     private Classextends Cache> implementation;
    4.     private final Listextends Cache>> decorators;
    5.     private Integer size;
    6.     private Long clearInterval;
    7.     private boolean readWrite;
    8.     private Properties properties;
    9.     private boolean blocking;
    10.  
    11.     public CacheBuilder(String id) {
    12.         this.id = id;
    13.         this.decorators = new ArrayList<>();
    14.     }
    15.  
    16.     public CacheBuilder size(Integer size) {
    17.         this.size = size;
    18.         return this;
    19.     }
    20.  
    21.     public CacheBuilder clearInterval(Long clearInterval) {
    22.         this.clearInterval = clearInterval;
    23.         return this;
    24.     }
    25.  
    26.     public CacheBuilder blocking(boolean blocking) {
    27.         this.blocking = blocking;
    28.         return this;
    29.     }
    30.  
    31.     public CacheBuilder properties(Properties properties) {
    32.         this.properties = properties;
    33.         return this;
    34.     }
    35.  
    36.     // 构建
    37.     public Cache build() {
    38.         // 使用了装饰器模式，添加 LruCache
    39.         setDefaultImplementations();
    40.         Cache cache = newBaseCacheInstance(implementation, id);
    41.         setCacheProperties(cache);
    42.         // 根据配置的装饰器对原有缓存进行增强，如增加淘汰策略等
    43.         if (PerpetualCache.class.equals(cache.getClass())) {
    44.             // 遍历装饰器，使其与目标对象绑定
    45.             for (Classextends Cache> decorator : decorators) {
    46.                 cache = newCacheDecoratorInstance(decorator, cache);
    47.                 setCacheProperties(cache);
    48.             }
    49.             cache = setStandardDecorators(cache);
    50.         } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
    51.             cache = new LoggingCache(cache);
    52.         }
    53.         return cache;
    54.     }
    55. }

    我们总结这个案例中的几个特点：

    1、参数有必填项id，有很多可选填的内容；通常必选项id通过构造器传入，可选项通过方法传递。

    2、真正的构建过程需要调用build()方法，构建时需要根据已配置的成员变量的内容选择合适的装饰器，对目标cache进行增强。

    2. 实现不可变对象

    创建者设计模式（Builder Design Pattern）可以实现不可变对象，即一旦创建完成，对象的状态就不能改变。这有助于保证对象的线程安全和数据完整性。

    1. public final class ImmutablePerson {
    2.     private final String name;
    3.     private final int age;
    4.     private final String address;
    5.  
    6.     private ImmutablePerson(Builder builder) {
    7.         this.name = builder.name;
    8.         this.age = builder.age;
    9.         this.address = builder.address;
    10.     }
    11.  
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     public int getAge() {
    17.         return age;
    18.     }
    19.  
    20.     public String getAddress() {
    21.         return address;
    22.     }
    23.  
    24.     public static class Builder {
    25.         private String name;
    26.         private int age;
    27.         private String address;
    28.  
    29.         public Builder() {
    30.         }
    31.  
    32.         public Builder setName(String name) {
    33.             this.name = name;
    34.             return this;
    35.         }
    36.  
    37.         public Builder setAge(int age) {
    38.             this.age = age;
    39.             return this;
    40.         }
    41.  
    42.         public Builder setAddress(String address) {
    43.             this.address = address;
    44.             return this;
    45.         }
    46.  
    47.         public ImmutablePerson build() {
    48.             return new ImmutablePerson(this);
    49.         }
    50.     }
    51. }

    在这个例子中，ImmutablePerson 类具有三个属性：name、age 和 address。这些属性都是 final 的，一旦设置就不能更改。

    ImmutablePerson 的构造函数是私有的，外部无法直接创建该类的实例。要创建一个 ImmutablePerson 实例，需要使用内部的 Builder 类。通过连续调用 Builder 类的方法，我们可以为 ImmutablePerson 设置属性。最后，通过调用 build() 方法，我们创建一个具有指定属性的不可变 ImmutablePerson 实例。

    实际上，使用建造者模式创建对象，还能避免对象存在无效状态。我再举个例子解释一下。比如我们定义了一个长方形类，如果不使用建造者模式，采用先创建后 set 的方式，那就会导致在第一个 set 之后，对象处于无效状态。

    1. Rectangle r = new Rectange(); // r is invalid
    2. r.setWidth(2); // r is invalid
    3. r.setHeight(3); // r is valid

    为了避免这种无效状态的存在，我们就需要使用构造函数一次性初始化好所有的成员变量。如果构造函数参数过多，我们就需要考虑使用建造者模式，先设置建造者的变量，然后再一次性地创建对象，让对象一直处于有效状态。

    实际上，如果我们并不是很关心对象是否有短暂的无效状态，也不是太在意对象是否是可变的。比如，对象只是用来映射数据库读出来的数据，那我们直接暴露 set() 方法来设置类的成员变量值是完全没问题的。而且，使用建造者模式来构建对象，代码实际上是有点重复的。

    小结

    建造者模式是用来创建一种类型的复杂对象，通过设置不同的可选参数，“定制化”地创建不同的对象。

    我们把类的必填属性放到构造函数中，强制创建对象的时候就设置。

    • 如果必填的属性有很多，把这些必填属性都放到构造函数中设置，那构造函数就又会出现参数列表很长的问题。
    • 如果我们把必填属性通过 set() 方法设置，那校验这些必填属性是否已经填写的逻辑就无处安放了。
    • 如果类的属性之间有一定的依赖关系或者约束条件，我们继续使用构造函数配合 set() 方法的设计思路，那这些依赖关系或约束条件的校验逻辑就无处安放了。
    • 如果我们希望创建不可变对象，也就是说，对象在创建好之后，就不能再修改内部的属性值，要实现这个功能，我们就不能在类中暴露 set() 方法。构造函数配合 set() 方法来设置属性值的方式就不适用了。

    建造者与工厂模式有何区别？

    实际上，其实不用非得把工厂模式、建造者模式分得那么清楚，我们需要知道的是，每个模式为什么这么设计，能解决什么问题。只有了解了这些最本质的东西，我们才能不生搬硬套，才能灵活应用，甚至可以混用各种模式创造出新的模式，来解决特定场景的问题。

    三、源码应用

    创建者设计模式在源码中有广泛的使用常见：

    1、JDK中，如StringBuilder和StringBuffer，他们的实现不是完全按照标准的创建者设计模式设计，但也是一样的思想：

    这两个类用于构建和修改字符串。它们实现了创建者模式，允许客户端通过方法链来修改字符串。这些类在性能上优于 String 类，因为它们允许在同一个对象上执行多次修改，而不需要每次修改都创建一个新的对象。

    1. StringBuilder builder = new StringBuilder();
    2. builder.append("Hello").append(" ").append("World!");
    3. String result = builder.toString();

    2、在SSM源码中很多类都使用创建者设计模式，如Spring中的BeanDefinitionBuilder 类，mybatis中的 SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder等，因为实现都比较简单就不带着大家一个一个看了。

    3、使用lombok简单的实现创建者设计模式

    Lombok 是一个 Java 库，它可以简化代码，提高开发效率，尤其是在实现模式和生成常用方法（例如 getter、setter、equals、hashCode 和 toString）时。

    要使用 Lombok 简单地实现创建者设计模式，可以使用 @Builder 注解。自动生成创建者类和相关方法。

    首先，引入 Lombok 库。

    1. <dependencies>
    2.     <dependency>
    3.         <groupId>org.projectlombokgroupId>
    4.         <artifactId>lombokartifactId>
    5.         <version>1.18.20version>
    6.         <scope>providedscope>
    7.     dependency>
    8. dependencies>

    然后，创建一个使用 Lombok 的创建者设计模式的类：

    1. @Getter
    2. @ToString
    3. @Builder
    4. public class Person {
    5.     private String name;
    6.     private int age;
    7.     private String address;
    8. }

    在上面的示例中，我们使用了 @Builder 注解来自动生成创建者类和相关方法。此外，我们还使用了 @Getter 注解来自动生成 getter 方法，以及 @ToString 注解来自动生成 toString 方法。

    自动生成的创建者类创建 Person 对象

    1. Person person = Person.builder()
    2.     .name("John Doe")
    3.     .age(30)
    4.     .address("123 Main St")
    5.     .build();

    通过 Lombok，可以轻松地实现创建者设计模式，减少样板代码，提高代码可读性。

    文章到这里就结束了，如果有什么疑问的地方，可以在评论区指出~

    希望能和大佬们一起努力，诸君顶峰相见

    再次感谢各位小伙伴儿们的支持！！！

  • 相关阅读:
    线程的状态与转换，组织与控制
    java中操作字符串有哪些类呢？
    大促来咯，有些事情不得不提
    什么是并行执行 以 Aptos、Sui、Linera 和 Fuel 为例给你讲透
    JavaScript 数组常用方法详细教程
    实现线程池
    《点燃我，温暖你》理工男神李峋同款C语言版本爱心
    52.seata分布式事务
    亚马逊VS独立站Shopify
    联想集团：2022/23财年第一季度业绩
  • 原文地址：https://blog.csdn.net/weixin_43715214/article/details/132844000