问题背景：
Builder模式在很多地方都有用到，代码风格也比较简洁，但是对其深入的了解并不多，因此在参考其他博客的基础上写此文章。
首先先看我的实际应用到Builder模式的场景：
场景一：
这是在编写RPC简易框架时，需要输入服务端的配置信息时
RPC.Server server = new RPC.Builder(new Configuration())
.setBindAddress("localhost")
.setPort(8888)
.setProtocol(RPCProtocol.class)
.setInstance(new NNServer())
.build();
场景二：
此处是编写ES的索引时
//创建插入类 Index Builder中的参数表示要插入到索引中的文档，底层会转换Json格式的字符串，所以也可以将文档封装为样例类对象
val index: Index = new Index.Builder(source)
.index("movie_index_5")
.`type`("movie")
.id("1")
.build()
问题分析
在上述两个场景中，我们可以看到Builder模式的应用，都是在初始化有多个参数的情境下，那么为什么要用Builder解决问题呢，他有什么优势，我们以一个例子讲解：
public class User {
private final String firstName; // 必传参数
private final String lastName; // 必传参数
private final int age; // 可选参数
private final String phone; // 可选参数
private final String address; // 可选参数
}
在这个类中，有些参数是必要的，而有些参数是非必要的。那么问题就来了，如何创建这个类的对象呢？
方法一（使用构造方法）
第一个构造方法只包含两个必需的参数，第二个构造方法中，增加一个可选参数，第三个构造方法中再增加一个可选参数，依次类推，直到构造方法中包含了所有的参数。
public User(String firstName, String lastName) {
this(firstName, lastName, 0);
}
public User(String firstName, String lastName, int age) {
this(firstName, lastName, age, "");
}
public User(String firstName, String lastName, int age, String phone) {
this(firstName, lastName, age, phone, "");
}
public User(String firstName, String lastName, int age, String phone, String address) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
this.phone = phone;
this.address = address;
}
这样虽然可以运行，但是有以下缺点：
①参数多时将很麻烦
②对于只想传一个参数，且参数位置在后边，如传入address，那么只能采用最后一个构造方法，且需对前几个参数赋值，这是耗时且不必要的操作。
方法二（采用get，set方式）
我们同样可以根据JavaBean的习惯，设置一个空参数的构造方法，然后为每一个属性设置setters和getters方法
public class User {
private String firstName; // 必传参数
private String lastName; // 必传参数
private int age; // 可选参数
private String phone; // 可选参数
private String address; // 可选参数
public User() {
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public int getAge() {
return age;
}
public String getPhone() {
return phone;
}
public String getAddress() {
return address;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public void setAge(int age) {
this.age = age;
}
public void setPhone(String phone) {
this.phone = phone;
}
public void setAddress(String address) {
this.address = address;
}
}
这种方法看起来可读性不错，而且易于维护。作为调用者，创建一个空的对象，然后只需传入所需要的参数，但是仍有以下缺点：
①对象会产生不一致的状态。当你想要传入5个参数的时候，你必需将所有的setXX方法调用完成之后才行。然而一部分的调用者看到了这个对象后，以为这个对象已经创建完毕，就直接使用了，其实User对象并没有创建完成。
②类是可变的了，不可变类所有好处都不复存在。
此时，Builder模式便可以解决以上问题。
public class User {
private final String firstName; // 必传参数
private final String lastName; // 必传参数
private final int age; // 可选参数
private final String phone; // 可选参数
private final String address; // 可选参数
private User(UserBuilder builder) {
this.firstName = builder.firstName;
this.lastName = builder.lastName;
this.age = builder.age;
this.phone = builder.phone;
this.address = builder.address;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public int getAge() {
return age;
}
public String getPhone() {
return phone;
}
public String getAddress() {
return address;
}
public static class UserBuilder {
private final String firstName;
private final String lastName;
private int age;
private String phone;
private String address;
public UserBuilder(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public UserBuilder age(int age) {
this.age = age;
return this;
}
public UserBuilder phone(String phone) {
this.phone = phone;
return this;
}
public UserBuilder address(String address) {
this.address = address;
return this;
}
public User build() {
return new User(this);
}
}
}
这种方式有以下优点：
①类的构造方法是私有的。也就是说调用者不能直接创建User对象。
②类的属性都是不可变的。所有的属性都添加了final修饰符，并且在构造方法中设置了值。并且，对外只提供getters方法。
③Builder的内部类构造方法中只接收必传的参数，并且该必传的参数适用了final修饰符。
因此，创建一个User类对象的代码为：
new User.UserBuilder("王", "小二")
.age(20)
.phone("123456789")
.address("亚特兰蒂斯大陆")
.build();
代码分析：
UserBuilder类是内部类，且被static修饰，则为静态内部类。它有以下特点：
1.静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能访问非静态的方法和属性，但是普通内部类可以访问任意外部类的成员变量和方法
2.静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。
3.静态内部类可以单独初始化
4.外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
静态内部类使用场景一般是当外部类需要使用内部类，而内部类无需外部类资源，并且内部类可以单独创建的时候会考虑采用静态内部类的设计。
总结：
1.如果类的构造器或静态工厂中有多个参数，设计这样类时，最好使用Builder模式，特别是当大多数参数都是可选的时候。
2.如果现在不能确定参数的个数，最好一开始就使用构建器即Builder模式。
参考博客：
https://www.jianshu.com/p/e2a2fe3555b9
https://blog.csdn.net/czh500/article/details/83876425
https://blog.csdn.net/junehappylove/article/details/85236946
