全网最全最细的【设计模式】总目录，收藏起来慢慢啃，看完不懂砍我

什么是建造者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

Builder模式是一步一步创建一个复杂对象的创建型模式，它允许使用者在不知道内部建造细节的情况下，可以更精细的控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，是的构建过程和不见得表示隔离开来。

一步一步认清建造者模式

我们此处借用数据源对象举例，让我们一步一步的从零开始认识建造者模式。

1、传统方式创建对象

public class DataSourceConfig {
    

    private String host;
    private Integer port;
    private String userName;
    private String password;
    private String database; // oracle、mysql
    private Integer initialSize;
    private Integer minIdle;
    private Integer maxActive;
	
	// 省略 get  set
   
    public static void main(String[] args) {
    
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig.setHost("");
        dataSourceConfig.setPort(3306);
        dataSourceConfig.setInitialSize(10);
        // ...
    }
}

以上代码相信很多小伙伴都不陌生，new一个对象，然后用set方法赋值，又或者使用超长的构造函数来初始化一个对象，比如说下面：

public DataSourceConfig(String host, Integer port, String userName, String password, String database, Integer initialSize, Integer minIdle, Integer maxActive) {
    
        this.host = host;
        this.port = port;
        this.userName = userName;
        this.password = password;
        this.database = database;
        this.initialSize = initialSize;
        this.minIdle = minIdle;
        this.maxActive = maxActive;
    }

构造函数的参数太长，代码在可读性和易用性上都会变差。在使用构造函数的时候，我们就容易搞错各参数的顺序，传递进错误的参数值，导致非常隐蔽的 bug。

而参数过多，使用set方法很容易漏掉某个参数，导致一些问题。

还有一种问题，这种使用 构造方法创建对象的方式，参数值只能程序员自己确保一定是正确的，否则我们做参数的判断可能就需要这样做：

public DataSourceConfig(String host, Integer port, String userName, String password, String database, Integer initialSize, Integer minIdle, Integer maxActive) {
    
    this.host = host;
    this.port = port;
    this.userName = userName;
    this.password = password;
    this.database = database;
    this.initialSize = initialSize;
    this.minIdle = minIdle;
    this.maxActive = maxActive;
    if(port < 0){
    
        throw new IllegalArgumentException("port不能为负数");
    }
    if(initialSize < 0){
    
        throw new IllegalArgumentException("initialSize不能为负数");
    }
    // ... 其他判断
}

而使用set的方式创建对象，可能需要这样做：

public void setPort(Integer port) {
    
    if(port < 0){
    
        throw new IllegalArgumentException("port不能为负数");
    }
    this.port = port;
}

但是，使用set的方式没法解决属性依赖的问题，比如说maxActive字段与initialSize必须是某个比另一个大，等等。

此时，建造者模式可能会解决这一切困惑与难题。

2、建造者模式创建对象

我们采取“约定大于配置”，将一些基础属性设置默认值，并且有些参数校验可以在最后的build校验，同时，如果不放心的话，也可以在set中校验。

以下实例，创建对象就简单太多了：

public class DataSourceConfig {
    

    private String host;
    private Integer port;
    private String database; // oracle、mysql
    private Integer initialSize;
    private Integer minIdle;
    private Integer maxActive;

    // 构造函数私有化
    private DataSourceConfig(Builder builder) {
    
        this.host = builder.host;
        this.port = builder.port;
        this.database = builder.database;
        this.initialSize = builder.initialSize;
        this.minIdle = builder.minIdle;
        this.maxActive = builder.maxActive;
    }


    // builder静态内部类
    public static class Builder {
    
        private static final int DEFAULT_INITIAL_SIZE = 10;
        private static final int DEFAULT_MIN_IDLE = 30;
        private static final int DEFAULT_MAX_ACTIVE = 200;

        // 设置一样的字段，加上初始值
        private String host;
        private Integer port;
        private String database; // oracle、mysql
        private Integer initialSize = DEFAULT_INITIAL_SIZE;
        private Integer minIdle = DEFAULT_MIN_IDLE;
        private Integer maxActive = DEFAULT_MAX_ACTIVE;

        // 对外暴露build方法
        public DataSourceConfig build(){
    
            // 做参数校验，此处省略其他
            if(StringUtils.isBlank(host)){
    
                throw new IllegalArgumentException("host不能为空");
            }
            
            // 直接使用builder返回想要的对象
            return new DataSourceConfig(this);
        }
        
        public Builder setHost(String host) {
    
            this.host = host;
            // 支持链式调用
            return this;
        }
        
        public Builder setPort(Integer port) {
    
            this.port = port;
            // 支持链式调用
            return this;
        }

        public Builder setDatabase(String database) {
    
            this.database = database;
            // 支持链式调用
            return this;
        }
        
        // ... 省略其他set方法
        
    }


    public static void main(String[] args) {
    
        // 约定大于配置
        DataSourceConfig config = new DataSourceConfig.Builder()
                .setHost("localhost")
                .setPort(3306)
                .setDatabase("mysql")
                // 省略其他参数
                .build();
    }
}

建造者模式优缺点

优点：

• 产品的建造和表示分离，实现了解耦，可以使用相同的创建过程得到不同的产品。
• 将复杂对象的创建步骤分解在不同的方法中，使得创建过程更加清晰。（良好的封装性，不必知道内部组成的细节）
• 增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

缺点：

• 对象必须有共同点，限制了使用范围。建造者模式创造出来的对象，其组成部分基本相同。如果对象之间的差异较大，则不适用这个模式。
• 产生多余的builder对象以及director对象，消耗内存。
• 如内部变化复杂，会有很多的建造类，难以维护。

建造者模式适用环境

• 相同的方法，不同的执行顺序，产生不同的事件结果。
• 对各部件或零件，都可以配到一个对象中，但是产生的运行结果又不相同时。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的结果，这个时候使用创建者模式非常合适。
• 当初始化一个对象特别复杂，如参数多，且很多参数都有默认值时（一个类有多个构造函数的时候，可以考虑使用建造者模式）
• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
• 类的属性之间有一定的依赖关系或者约束条件。
• 如果我们希望创建不可变对象，也就是说，对象在创建好之后，就不能再修改内部的属性值

与工厂模式的区别

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

参考资料

https://www.kongzid.com/archives/design3
王争老师《设计模式之美》