建造者模式：把类对象的构造与装配分别实现。
单例、工厂、原型这几种模式的重点在于创建出一个个的实例对象来，而这个建造者模式的重点在于对某个对象的组成部分的装配。
在实际开发中，一个类不可能只有简单的几个属性，往往是有大量的属性。创建对象的同时或者之后，给属性也设置好对应的值，这个对象才有使用的价值。否则一个空对象我们用它做什么呢。
如果一个表有20个字段，那么它对应的实体类就有20个属性，如何给这个类的对象的属性赋值呢。要么是利用构造方法在创建对象的同时就赋值，要么就是创建一个空对象，然后用set方法给赋值。
构造器的方法问题就是不够灵活，而set方法就是代码量大。
建造者模式可以完美的解决这个问题。
先看一下建造者模式的一般方式：
这里有三个基本角色：产品(有比较多、复杂的组件)，构造者，装配者
这里以电脑这种产品为例：
public class Computer {
private String cpu;
private String memery;
private String screen;
@Override
public String toString() {
return "Computer{" +
"cpu='" + cpu + '\'' +
", memery='" + memery + '\'' +
", screen='" + screen + '\'' +
'}';
}
// 省略get与set方法
}
构造者，用来模拟构造产品的各个组成部分
// 抽象构造者
public abstract class Builder {
Computer computer = new Computer();
// 构建cpu
protected abstract void buildCpu();
// 构建memery
protected abstract void buildMemery();
// 构建screen
protected abstract void buildScreen();
}
// 具体的建造者
public class HuaweiComputer extends Builder{
@Override
protected void buildCpu() {
computer.setCpu("only amd ...");
}
@Override
protected void buildMemery() {
computer.setMemery("sangsam 1024G");
}
@Override
protected void buildScreen() {
computer.setScreen("huawei 27 big screen");
}
}
public class AppleComputer extends Builder{
@Override
protected void buildCpu() {
computer.setCpu("inter i7");
}
@Override
protected void buildMemery() {
computer.setMemery("kinston 256G");
}
@Override
protected void buildScreen() {
computer.setScreen("apple cloure");
}
}
装配者，不同的产品只是组件不同，但是装配流程是相同的
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Computer createComputer(){
builder.buildCpu();
builder.buildMemery();
builder.buildScreen();
return builder.computer;
}
}
测试
public class ClientDemo {
public static void main(String[] args) {
// 通过给装配者传递不同的产品构造者来得到不同的产品
// Director director = new Director(new AppleComputer());
Director director = new Director(new HuaweiComputer());
Computer computer = director.createComputer();
System.out.println(computer);
}
}
当然从这里我们可以看到这种模式的适用场景，那就是产品应当是同一类产品，产品的组成部分可能很多，各个组成部分可能不相同，但是他们组成这个产品的整理逻辑(装配流程)是相同的。
其实本质上还是封装，我们把不同的部分(组成部分)单独实现，相同的部分(装配)统一实现。
也可以把构造者和装配者这两个角色放在一起来实现，如下：
public abstract class BuilderTotal {
Computer computer = new Computer();
// 构造者：构造产品的各个组成部分
protected abstract void buildCpu();
protected abstract void buildMemry();
protected abstract void buildScreen();
// 装配者：完成组装
public Computer createCoumputer(){
this.buildCpu();
this.buildMemry();
this.buildScreen();
return this.computer;
}
}
不同的产品
public class XiaomiComputer extends BuilderTotal{
@Override
protected void buildCpu() {
computer.setCpu("xiaomi cpu");
}
@Override
protected void buildMemry() {
computer.setMemery("xiaomi memery");
}
@Override
protected void buildScreen() {
computer.setScreen("xiaomi screen");
}
}
public class HpComputer extends BuilderTotal{
@Override
protected void buildCpu() {
computer.setCpu("hp special cpu");
}
@Override
protected void buildMemry() {
computer.setMemery("hp special memery");
}
@Override
protected void buildScreen() {
computer.setScreen("hp special screen");
}
}
测试：
public class ClientDemo_02 {
public static void main(String[] args) {
BuilderTotal hp = new HpComputer();
Computer coumputer = hp.createCoumputer();
System.out.println(coumputer);
System.out.println("========================");
BuilderTotal xiaomi = new XiaomiComputer();
Computer computer = xiaomi.createCoumputer();
System.out.println(computer);
}
}
虽然这样是把不同的功能放在同一个类中实现，不符合单一原则，但其实我觉得这样的代码可读性要高一点，不过当属性比较多的时候，也会比较乱。
接下来看一种比较巧妙的方式，利用内部类的方式，对产品的各个部分(属性)进行组装，而且非常灵活。
public class Phone {
private String brand;
private String memory;
private String screen;
private String camera;
private String clour;
// 私有构造方法，创建对象由内部类的方法实现(最后用到)
private Phone(String brand, String memory, String screen, String camera, String clour) {
this.brand = brand;
this.memory = memory;
this.screen = screen;
this.camera = camera;
this.clour = clour;
}
// 借助一个内部类，用来构造属性的各个部分，并创建调用它的构造方法创建对象返回给调用者
public static PhoneBuilder phoneBuilder(){
return new PhoneBuilder();
}
// 静态内部类实现
public static class PhoneBuilder{
// 拥有和外部类相同的参数
private String brand;
private String memory;
private String screen;
private String camera;
private String clour;
// 对每一个属性提供一个方法来设置它的值，这其实就是构造组件的部分
public PhoneBuilder brand(String brand){
this.brand = brand;
// 返回自身，这样方便使用链式编程
return this;
}
public PhoneBuilder memory(String memory){
this.memory = memory;
return this;
}
public PhoneBuilder screen(String screen){
this.screen = screen;
return this;
}
public PhoneBuilder camera(String camera){
this.camera = camera;
return this;
}
public PhoneBuilder clour(String clour){
this.clour = clour;
return this;
}
// 最后提供一个方法，创建产品对象，参数值就是上面的方法接受到的
public Phone build(){
return new Phone(brand, memory, screen, camera, clour);
}
}
// 只为了测试方便，忽略
@Override
public String toString() {
return "Phone{" +
"brand='" + brand + '\'' +
", memory='" + memory + '\'' +
", screen='" + screen + '\'' +
", camera='" + camera + '\'' +
", clour='" + clour + '\'' +
'}';
}
}
只看这个类的设计会觉得很复杂，但是使用的时候就觉得爽了：
public class PhoneClient {
public static void main(String[] args) {
Phone phone = Phone.phoneBuilder() // 这一步是得到它内部的一个构造器
.brand("huawei")
.clour("black")
// .memory("64G")
// .camera("1000 wan")
.screen("18 ch")
.build(); // 这一步才是真正创建一个Phone对象，并使用上面接受的参数
System.out.println(phone);
}
}
可以看到，在得到构造器和利用构造器创建对象中间，都是设置对象的属性值，最爽的地方就在于：随意。想设置几个就设置几个，而且顺序随意，而且代码可读性很好，很明确要给给哪些属性设置什么值。
其实这完全就是lomboc中的注解@Builder的功能。之前只是照着别人用觉得方便，也没有琢磨琢磨。最近学到了这个，觉得这个设计真是巧妙。平时工作中只是简单的crud，动脑筋比较少，多学学这些优秀的东西，真的可以开阔思路。
