建造者模式概念
Builder 模式，中文译为建造者模式或者构建者模式，也有人叫它生成器模式
是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象。所谓复合对象就是指某个类具有不同的属性
组成
- 抽象建造者 builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
- 具体建造者 ConcreteBuilder：实现 Builder 接口，针对不同的业务逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
- 指挥者 Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
- 产品角色 Product：要创建的复杂对象。
使用建造者模式的好处：
1、使用建造者模式可以使客户端不必知道产品内部组成的细节。
2、具体的建造者类之间是相互独立的，对系统的扩展非常有利。
3、由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
使用建造模式的场合：
● 隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
● 多个部件都可以装配到一个对象中，但产生的运行结果不相同
● 产品类非常复杂或者产品类因为调用顺序不同而产生不同作用
● 初始化一个对象时，参数过多，或者很多参数具有默认值
● Builder 模式不适合创建差异性很大的产品类，产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
● 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性
● 建造者模式经常和模板方法一起使用
建造者模式与工厂模式有何区别？
工厂模式是用来创建不同但是相关类型的对象（继承同一父类或者接口的一组子类），由给定的参数来决定创建哪种类型的对象。建造者模式是用来创建一种类型的复杂对象，通过设置不同的可选参数，“定制化”地创建不同的对象。
网上有一个经典的例子很好地解释了两者的区别：
顾客走进一家餐馆点餐，我们利用工厂模式，根据用户不同的选择，来制作不同的食物，比如披萨、汉堡、沙拉。对于披萨来说，用户又有各种配料可以定制，比如奶酪、西红柿、起司，我们通过建造者模式根据用户选择的不同配料来制作披萨。
建造者模式实例讲解
1、Builder接口（定义组装电脑的规范）
public abstract class Builder {
//第一步：装CPU
public abstract void BuildCPU()；
//第二步：装主板
public abstract void BuildMainboard（）；
//第三步：装硬盘
public abstract void BuildHD（）；
//获得组装好的电脑
public abstract Computer GetComputer（）；
}
2、Director 接口（老板指导者委派任务给具体建造者装机人员）
public class Director {
//装机人员组装电脑
public void Construct(Builder builder) {
builder.BuildCPU();
builder.BuildMainboard（）;
builder.BuildHD（）;
}
}
3、定义具体产品类（要创建的对象 Product 电脑）：
public class Computer {
//电脑组件的集合
private List<String> parts = new ArrayList<String>()；
//用于将组件组装到电脑里
public void Add(String part) {
parts.add(part);
}
public void Show() {
for (int i = 0; i < parts.size(); i++) {
System.out.println(“组件” + parts.get(i) +“装好了”);
}
System.out.println(“电脑组装完成，请验收”);
}
}
4、 ConcreteBuilder接口（创建具体的建造者 ConcreteBuilder）
public class ConcreteBuilder extend Builder {
//创建产品实例
Computer computer = new Computer();
//组装产品
@Override
public void BuildCPU() {
computer.Add("组装CPU");
}
@Override
public void BuildMainboard() {
computer.Add("组装主板");
}
@Override
public void BuildHD() {
computer.Add("组装主板");
}
//返回组装成功的电脑
@Override
public Computer GetComputer() {
return computer;
}
}
5、客户端调用（法外狂徒张三找老板买电脑）
public class Builder Pattern {
public static void main(String[] args) {
//发现合适的装机人员
Director director = new Director();
Builder builder = new ConcreteBuilder();
//装机人员去装电脑
director.Construct(builder);
//装完后，装机人员搬来组装好的电脑
Computer computer = builder.GetComputer();
//组装人员展示电脑给小成看
computer.Show()；
}
}
结果输出：
组件CUP装好了
组件主板装好了
组件硬盘装好了
电脑组装完成，请验收
实际开发示例
建造者（Builder）模式在应用过程中可以根据需要改变，如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。
在平时的开发中，创建一个对象最常用的方法是，使用 new 关键字调用类的构造函数来完成。代码如下 ↓
/**
* 学生 DTO
**/
public class StudentDTO implement Serializable{
// id
private Long id;
// 姓名
private String name;
// 年龄
private Integer age;
// 爱好
private String hobby;
public Student(){}
public Student(Long id, String name, Integer age, String hobby){
this.id = id;
this.name = name;
this.age = age;
this. hobby = hobby;
}
}
因为有些值比如爱好不是必填变量，所以在创建 DTO 对象的时候，我们通过往构造函数中，给这几个参数传 null 值，来表示用默认值。创建代码如下 ↓
StudentDTO studentDTO = new StudentDTO(1, "法外狂徒张三", 33, null);
存在的问题？
现在，StudentDTO 只有4个可配置项，对应到构造函数中，也只有 4个参数，参数的个数不多。但是，如果可配置项逐渐增多，变成了 8 个、10 个，甚至更多，那继续沿用现在的设计思路，构造函数的参数列表会变得很长，代码在可读性和易用性上都会变差。在使用构造函数的时候，就容易搞错各参数的顺序，传递进错误的参数值，导致非常隐蔽的 bug。
如何解决？
用 set() 函数来给成员变量赋值，以替代冗长的构造函数.优化后代码如下 ↓
/**
* 学生 DTO
**/
public class StudentDTO implement Serializable{
// id
private Long id;
// 姓名
private String name;
// 年龄
private Integer age;
// 爱好
private String hobby;
public Student(){}
public Student(Long id, String name, Integer age){
this.id = id;
this.name = name;
this.age = age;
}
public String getHobby() {return this.hobby;}
public void setHobby(String hobby) {this.hobby = hobby;}
}
使用代码如下 ↓
StudentDTO studentDTO = new StudentDTO(1, "法外狂徒庄三", 33);
studentDTO.setHobby("唱，跳，rap");
看起来能解决上面的问题，就这？？？
请加大力度：
● 上面的示例 id、name 和 age 是必填的，所以，我们把它放到构造函数中，强制创建对象的时候就设置。如果必填的配置项有很多，把这些必填配置项都放到构造函数中设置，那构造函数就又会出现参数列表很长的问题。
● 除此之外，假设配置项之间有一定的依赖关系，如果我们继续使用现在的设计思路，那这些配置项之间的依赖关系或者约束条件的校验逻辑就无处安放了。
● 如果我们希望类对象是不可变对象，也就是说，对象在创建好之后，就不能再修改内部的属性值。要实现这个功能，我们就不能在 StudentDTO 类中暴露 set() 方法。
那可咋整？建造者登场了~~
/**
* 学生 DTO
**/
public class StudentDTO implement Serializable{
// id
private Long id;
// 姓名
private String name;
// 年龄
private Integer age;
// 爱好
private String hobby;
public Student(){}
public Student(Long id, String name, Integer age, String hobby){
this.id = id;
this.name = name;
this.age = age;
this.hobby = hobby
}
public Long getId() {return this.id;}
public String getName() {return this.name;}
public Integer getAge() {return this.age;}
public String getHobby() {return this.hobby;}
public static StudentDTO.StudentDTOBuilder builder(){
return new StudentDTO.StudentDTOBuilder();
}
public static class StudentDTOBuilder {
private Long id;
private String name;
private Integer age;
private String hobby;
public StudentDTOBuilder id(Long id) {
this.id = id;
return this;
}
public StudentDTOBuilder name(String name) {
this.name = name;
return this;
}
public StudentDTOBuilder age(Integer age) {
this.age = age;
return this;
}
public StudentDTOBuilder hobby(String hobby) {
this.hobby = hobby;
return this;
}
public StudentDTO build(){
return new StudentDTO(this.id, this.name, this.age, this.hobby);
}
}
}
可以把校验逻辑放置到 Builder 类中，先创建建造者，并且通过 set() 方法设置建造者的变量值，然后在使用 build() 方法真正创建对象之前，做集中的校验，校验通过之后才会创建对象。除此之外，把 StudentDTO 的构造函数改为 private 私有权限。这样就只能通过建造者来创建 StudentDTO 类对象。并且，StudentDTO 没有提供任何 set() 方法，这样创建出来的对象就是不可变对象了。
使用代码如下 ↓
//Builder方式创建对象
StudentDTO studentDTO = new StudentDTO.Builder()
.id(1)
.name("法外狂徒张三")
.age(33)
.build();
建造者不完美的一面：
使用建造者模式来构建对象，代码实际上是有点重复的，StudentDTO 类中的成员变量，要在 Builder 类中重新再定义一遍。
1273
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
