【设计模式】创建型：建造者模式

悠悠 2023-01-18 04:12 203阅读 0赞

建造者模式用来创建复杂对象，可以通过设置不同的可选参数，“定制化”地创建不同的对象。用户只需指定要建造的类型就可以得到他们，建造过程及细节不需要知道。

建造者模式的原理和实现比较简单，重点是掌握应用场景，避免过度使用。

### 1.代码示例 ###

下面来直接看一个设置资源池参数的例子：

public class ResourcePoolConfig {
        
        
        private String name;
        private int maxTotal;
        private int maxIdle;
        private int minIdle;
        
        // 这里创建对象不再是通过传入参数，而是传入一个建造者builder，
        // 然后取出builder验证过的属性进行对象创建
        private ResourcePoolConfig(Builder builder) {
        
            this.name = builder.name;
            this.maxTotal = builder.maxTotal;
            this.maxIdle = builder.maxIdle;
            this.minIdle = builder.minIdle;
        }
    	//...省略getter方法...
    
        // 我们将Builder类设计成了ResourcePoolConfig的内部类。
        // 我们也可以将Builder类设计成独立的非内部类ResourcePoolConfigBuilder。
        public static class Builder {
        
            
            private static final int DEFAULT_MAX_TOTAL = 8;
            private static final int DEFAULT_MAX_IDLE = 8;
            private static final int DEFAULT_MIN_IDLE = 0;
    
            private String name;
            private int maxTotal = DEFAULT_MAX_TOTAL;
            private int maxIdle = DEFAULT_MAX_IDLE;
            private int minIdle = DEFAULT_MIN_IDLE;
    		
            // 校验逻辑放到这里来做，包括必填项校验、依赖关系校验、约束条件校验等
            public ResourcePoolConfig build() {
        
                if (StringUtils.isBlank(name)) {
        
                    throw new IllegalArgumentException("...");
                }
                if (maxIdle > maxTotal) {
        
                    throw new IllegalArgumentException("...");
                }
                if (minIdle > maxTotal || minIdle > maxIdle) {
        
                    throw new IllegalArgumentException("...");
                }
                return new ResourcePoolConfig(this);
            }
    
            public Builder setName(String name) {
        
                if (StringUtils.isBlank(name)) {
        
                    throw new IllegalArgumentException("...");
                }
                this.name = name;
                // 链式编程
                return this;
            }
            public Builder setMaxTotal(int maxTotal) {
        
                if (maxTotal <= 0) {
        
                    throw new IllegalArgumentException("...");
                }
                this.maxTotal = maxTotal;
                return this;
            }
            public Builder setMaxIdle(int maxIdle) {
        
                if (maxIdle < 0) {
        
                    throw new IllegalArgumentException("...");
                }
                this.maxIdle = maxIdle;
                return this;
            }
            public Builder setMinIdle(int minIdle) {
        
                if (minIdle < 0) {
        
                    throw new IllegalArgumentException("...");
                }
                this.minIdle = minIdle;
                return this;
            }
        }
    }
    
    // 这段代码会抛出IllegalArgumentException，因为minIdle>maxIdle
    ResourcePoolConfig config = new ResourcePoolConfig.Builder()
    .setName("dbconnectionpool")
    .setMaxTotal(16)
    .setMaxIdle(10)
    .setMinIdle(12)
    .build();

实际上，使用建造者模式创建对象，还能避免对象存在无效状态。

再举个例子解释一下。 比如我们定义了一个长方形类，如果不使用建造者模式，采用先创建后 set 的方式，那就会导致在第一个 set 之后，对象处于无效状态。具体代码如下所示：

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

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

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

### 2.源码应用 ###

使用到建造者模式的地方有很多，无论是 JDK 还是各种框架，我们能看到很多~Builder，由于最近使用了 Swagger，所以这里来看一下 Swagger 使用的建造者模式：

@Configuration
    @EnableSwagger2 // 启动 Swagger2
    public class SwaggerConfig {
        
        
        @Bean // 构建并配置 Docket 对象
        public Docket docket() {
        
            return new Docket(DocumentationType.SWAGGER_2);
        }
        
        // 构建基本配置信息
        public ApiInfo apiInfo() {
        
            return new ApiInfoBuilder()
                    .title("文档标题")
                    .description("测试的接口文档")
                    .version("v2.0")
                    .termsOfServiceUrl("baidu.com")
                    .contact(new Contact("A minor", "https://blog.csdn.net/weixin_43935927", "3132266573@qq.com"))
                    .build();
        }
    }

另外，在 MyBatis 中对于 SqlSessionFactory 的构建，也是通过 SqlSessionFactoryBuilder 来完成的。

### 3.总结 ###

如果一个类中有很多属性，为了避免构造函数的参数列表过长，影响代码的可读性和易用性，我们可以通过构造函数配合 set() 方法来解决。但是，如果存在下面情况中的任意一种，我们就要考虑使用建造者模式了

1）我们把类的必填属性放到构造函数中，强制创建对象的时候就设置。如果**必填的属性有很多**，把这些必填属性都放到构造函数中设置，那构造函数就又会出现参数列表很长的问题。如果我们把必填属性通过 set() 方法设置，那校验这些必填属性是否已经填写的逻辑就无处安放了。

2）如果类的**属性之间有一定的依赖关系**或者约束条件，我们继续使用构造函数配合 set() 方法的设计思路，那这些依赖关系或约束条件的校验逻辑就无处安放了。

3）如果我们希望创建**不可变对象**，也就是说，对象在创建好之后，就不能再修改内部的属性值，要实现这个功能，我们就不能在类中暴露 set() 方法。构造函数配合 set() 方法来设置属性值的方式就不适用了。

*  优点
    
     *  封装性好，创建和使用分离
     *  扩展性好，建造类之间独立，一定程度上解耦
 *  缺点
    
     *  产生多余Builder对象
     *  产品内部发生变化，建造者都需要修改，成本较大

**与工厂模式区别**

建造者模式是让建造者类来负责对象的创建工作，而工厂模式是由工厂类来负责对象创建的工作。那它们之间有什么区别呢？

实际上，工厂模式是用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。建造者模式是用来创建一种类型的复杂对象，通过设置不同的可选参数，“定制化”地创建不同的对象。

网上有一个经典的例子很好地解释了两者的区别。顾客走进一家餐馆点餐，我们利用工厂模式，根据用户不同的选择，来制作不同的食物，比如披萨、汉堡、沙拉。对于披萨来说，用户又有各种配料可以定制，比如奶酪、西红柿、起司，我们通过建造者模式根据用户选择的不同配料来制作披萨。

> 工厂模式：用来创建多种相关对象；建造者：用来定制一个对象