建造者模式

建造者模式是一种创建型设计模式，当一个类的构造器有多个参数，特别当大多数参数是可选的，建造者模式就是种不错的选择。

接下来我们通过创建一个重试器来具体介绍建造者模式：重试器是指对执行某一业务逻辑失败后进行重试，创建重试器需要指定名称，重试次数，每次重试后休眠时间，其中重试次数和每次重试后休眠时间两个参数是非必填的。

对于这样的类，首先想到的是使用重叠构造方法，提供一个只有必填参数的构造器，第二个构造器有一个可选参数，依次类推，最后一个构造器包含所有参数。

@Slf4j
public class Retryer {
    // 默认重试次数
    private static final int DEFAULT_RETRY_TIMES = 1;
    // 默认休眠毫秒
    private static final int DEFAULT_SLEEP_MILLISECOND = 1000;

    private String name;

    private int retryTimes = DEFAULT_RETRY_TIMES;

    private Integer sleepMillisecond = DEFAULT_SLEEP_MILLISECOND;

    public Retryer(String name) {
        this.name = name;
    }

    public Retryer(String name, int retryTimes) {
        this.name = name;
        this.retryTimes = retryTimes;
    }

    public Retryer(String name, Integer sleepMillisecond) {
        this.name = name;
        this.sleepMillisecond = sleepMillisecond;
    }

    public Retryer(String name, int retryTimes, Integer sleepMillisecond) {
        if (StringUtils.isBlank(name)) {
            throw new IllegalArgumentException("name should not be empty.");
        }
        this.name = name;
        if (retryTimes <= 0) {
            throw new IllegalArgumentException("retryTime should bigger than 0");
        }
        this.retryTimes = retryTimes;
        if (sleepMillisecond < 0) {
            throw new IllegalArgumentException("sleepMillisecond should equal or bigger than 0");
        }
        this.sleepMillisecond = sleepMillisecond;
    }
}

当创建对象的时候，根据需要使用相应的构造器即可，使用这种方式可以，目前只有3个参数，但是当有更多参数的时候，继续沿用现在的设计思路，构造函数的参数列表会变得很长，代码在可读性和易用性上都会变差，客户端代码会变得难以编写，很容易搞错参数的顺序，编译器又不会报错，导致运行时出现非常隐蔽的Bug。

遇到许多构造器参数还有第二种方法，即JavaBeans模式，通过一个无参构造器来创建对象，然后调用setter方法设置每个参数。

@Slf4j
public class Retryer {
    // 默认重试次数
    private static final int DEFAULT_RETRY_TIMES = 1;
    // 默认休眠毫秒
    private static final int DEFAULT_SLEEP_MILLISECOND = 1000;

    private String name;

    private int retryTimes = DEFAULT_RETRY_TIMES;

    private Integer sleepMillisecond = DEFAULT_SLEEP_MILLISECOND;

    public Retryer(String name) {
        if (StringUtils.isBlank(name)) {
            throw new IllegalArgumentException("name should not be empty.");
        }
        this.name = name;
    }

    public void setRetryTimes(int retryTimes) {
        if (retryTimes <= 0) {
            throw new IllegalArgumentException("retryTimes should bigger than 0");
        }
        this.retryTimes = retryTimes;
    }

    public void setSleepMillisecond(Integer sleepMillisecond) {
        if (sleepMillisecond < 0) {
            throw new IllegalArgumentException("sleepMillisecond should equal or bigger than 0");
        }
        this.sleepMillisecond = sleepMillisecond;
    }
}

遗憾的是，JavaBeans模式有一个严重的缺点，构造过程被分割到几次调用中，导致在构造过程中对象会处于不一致的状态，使用处于不一致状态的对象会导致失败。另外通过JavaBeans模式无法将对象创建为不可变对象。

为解决这些问题，构造器模式就派上用场了，既能保证像重叠构造器模式那样的安全性，也能保证可读性，同时也能生成不可变对象。

@Slf4j
public class Retryer {

    private String name;

    private int retryTimes;

    private Integer sleepMillisecond;

    public Retryer(Builder builder) {
        this.name = builder.name;
        this.retryTimes = builder.retryTimes;
        this.sleepMillisecond = builder.sleepMillisecond;
    }

    public static class Builder {
        // 默认重试次数
        private static final int DEFAULT_RETRY_TIMES = 1;
        // 默认休眠毫秒
        private static final int DEFAULT_SLEEP_MILLISECOND = 1000;

        private String name;

        private int retryTimes = DEFAULT_RETRY_TIMES;

        private Integer sleepMillisecond = DEFAULT_SLEEP_MILLISECOND;

        public Builder(String name) {
            this.name = name;
        }

        public Builder retryTimes(int retryTimes) {
            this.retryTimes = retryTimes;
            return this;
        }

        public Builder sleepMillisecond(Integer sleepMillisecond) {
            this.sleepMillisecond = sleepMillisecond;
            return this;
        }

        public Retryer build() {
            if (StringUtils.isBlank(name)) {
                throw new IllegalArgumentException("name should not be empty.");
            }
            if (retryTimes <= 0) {
                throw new IllegalArgumentException("retryTimes should bigger than 0");
            }
            if (sleepMillisecond < 0) {
                throw new IllegalArgumentException("sleepMillisecond should equal or bigger than 0");
            }
            return new Retryer(this);
        }
    }
}

通过构造器模式，不直接生成想要的对象，客户端利用所有必要的参数调用构造器，得到一个builder对象，然后在builder对象上调用类似于setter的方法来设置每个可选参数，最后调用build方法来生成不可变对象。

综上所述：当一个类的构造器有多个参数，特别当大多数参数是可选的，可以使用建造者模式，先设置建造者的变量，然后再一次性地创建对象，让对象一直处于有效状态。使用建造者模式来构建对象，缺点是代码重复，Retryer类中的成员变量，要在 Builder 类中重新再定义一遍。