一. 什么是建造者模式?
建造者模式（Builder Pattern），是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。
这句话的含义:
- 比如造一辆车，比如有车身，引擎，轮胎。车还有颜色，形状的区别。 对于用户来说， 我不需要知道车里面到底是怎么构造的。我就告诉你我想要一亮什么颜色的车，你给我造出来就行。 这就是建造和表示分离。
- 建造者模式负责按顺序创建复杂对象, 把内部的建造过程和细节隐藏起来
二. 建造者的主要结构
先来看看建造者模式的UML图：
从上图可以看出, 建造者（Builder）模式由5个主要部分构成。
(1) 建造的产品对象：包含多个组成部件的复杂对象
(2) 抽象建造者：包含创建产品各个子部件的抽象方法。
(3) 具体建造者：实现了抽象建造者接口。
(4) 指挥者：调用建造者中的方法完成复杂对象的创建。他的作用是： 用来控制建造过程， 同时也用它来隔离用户与建造过程的关联。
(5) 客户类
接下来看看代码实现:
1) 建造的产品对象
package com.lxl.www.designPatterns.builderPattern.builder;
/**
* 建造的目标产品
*/
public class Product {
/**
* 产品有几个部分构成
*/
private Object partA;
private Object partB;
private Object partC;
public void show() {
// 产品展示. 组成的成品展示
System.out.println("一个完整的产品---完成了");
}
public void setPartA(Object partA) {
this.partA = partA;
}
public void setPartB(Object partB) {
this.partB = partB;
}
public void setPartC(Object partC) {
this.partC = partC;
}
}
通常这个产品对象是由几个部分构成的复杂对象.
2) 抽象建造者：包含创建产品各个子部件的抽象方法。
/**
* 建造者
*/
public abstract class Builder {
// 建造者建造的对象是谁? 也就是目标产品
Product product = new Product();
// 建造者构建的产品的每一个部分
abstract void buildPartA();
abstract void buildPartB();
abstract void buildPartC();
public Product result() {
// 返回建造者建设好的成品
return this.product;
}
}
建造者需要分几个部分建造, 并最终交付成品
3) 具体建造者：实现了抽象建造者接口。
package com.lxl.www.designPatterns.builderPattern.builder;
/**
* 具体建造者A
*/
public class ConcreteBuilderA extends Builder{
@Override
void buildPartA() {
System.out.println("建造第一部分");
}
@Override
void buildPartB() {
System.out.println("建造第二部分");
}
@Override
void buildPartC() {
System.out.println("建造第三部分");
}
}
/**
* 具体建造者A
*/
public class ConcreteBuilderB extends Builder{
@Override
void buildPartA() {
System.out.println("完成第一(1)部分");
}
@Override
void buildPartB() {
System.out.println("完成第二(2)部分");
}
@Override
void buildPartC() {
System.out.println("完成第三(3)部分");
}
}
这里面有两个具体的建造者. 他们建造的步骤流程是一样的, 但建造的结果可能是不同的.
4) 指挥者：调用建造者中的方法完成复杂对象的创建。
package com.lxl.www.designPatterns.builderPattern.builder;
/**
* 指挥者
* 指挥者指挥建造者建设产品
*/
public class Director {
Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
/**
* 指挥者指挥建造者建设产品
* 先建partA, 在建partB, 再建partC. 最后得到成品.
*/
public Product construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
return builder.result();
}
public static void main(String[] args) {
Builder builder = new ConcreteBuilderA();
Director director = new Director(builder);
Product product = director.construct();
product.show();
}
}
指挥者指挥建造者建设产品.
5) 客户类
public class Client {
public static void main(String[] args) {
Builder builder = new ConcreteBuilderA();
Director director = new Director(builder);
Product product = director.construct();
product.show();
}
}
运行结果:
建造第一部分
建造第二部分
建造第三部分
一个完成的产品---完成了
这是一个建造者模式的模型，我们定义的建造者建设的通用步骤， 不同的建设者需按照通用步骤建造设计，但每个人建造的结果可能是不同的。
二. 案例分析
下面来看两个具体的案例。
案例一：装修房子
我们有一个毛坯房需装修，将毛坯房整体分为几个部分：厨房，客厅，卧室，卫生间。不同的建造者装修风格可能不同。 中式建造者装修出来的都是中式风格，美式装修者装修出来的是美式风格。具体装修过程，由装修经理指挥完成。 按照上面 步骤来实现:
- 建造的产品对象：这里是房子, 房子需要装修的几个部分：厨房，客厅，卧室，卫生间.
/**
* 建设的目标对象---方法
*/
public class House {
/**
* 厨房
*/
private Object kitchen;
/**
* 客厅
*/
private Object livingRoom;
/**
* 卫生间
*/
private Object bathroom;
/**
* 卧室
*/
private Object bedroom;
public void show() {
System.out.println("厨房是" + kitchen);
System.out.println("卧室是" + bedroom);
System.out.println("卫生间是" + bathroom);
System.out.println("客厅是" + livingRoom);
}
public Object getKitchen() {
return kitchen;
}
public void setKitchen(Object kitchen) {
this.kitchen = kitchen;
}
public Object getLivingRoom() {
return livingRoom;
}
public void setLivingRoom(Object livingRoom) {
this.livingRoom = livingRoom;
}
public Object getBathroom() {
return bathroom;
}
public void setBathroom(Object bathroom) {
this.bathroom = bathroom;
}
public Object getBedroom() {
return bedroom;
}
public void setBedroom(Object bedroom) {
this.bedroom = bedroom;
}
}
- 抽象建造者：建造者的统一操作的框架
package com.lxl.www.designPatterns.builderPattern.house;
/**
* 建造者--建设房子的一类人
*/
public abstract class Builder {
/**
* 建设的是房子, 所以, 需要引入房子对象
*
* 如果每次建设的都是新房, 那么直接在属性定义处new. 如果可能是老房子改造, 那么就在构造函数中传入
*
*/
House house;
public Builder(House house) {
this.house = house;
}
/**
* 需要建设房子的几个部分
*/
// 建设卧室
abstract void buildBedroom() ;
// 建设卫生间
abstract void buildBathroom();
// 建设厨房
abstract void buildKitchen() ;
// 建设客厅
abstract void buildLivingRoom();
/**
* 建造者交付装修结果
* @return
*/
public House result() {
System.out.println("房子装修完成了");
return house;
}
}
- 具体建造者：实现了抽象建造者接口。 中式风格建造者
package com.lxl.www.designPatterns.builderPattern.house;
/**
* 建造者--建设房子的一类人
*/
public class ChineseBuilder extends Builder {
public ChineseBuilder(House house) {
super(house);
}
// 建设卧室
public void buildBedroom() {
house.setBedroom("中式风格");
}
// 建设卫生间
public void buildBathroom() {
house.setBathroom("中式风格");
}
// 建设厨房
public void buildKitchen() {
house.setKitchen("中式风格");
}
// 建设客厅
public void buildLivingRoom() {
house.setLivingRoom("中式风格");
}
}
美式风格建造者
package com.lxl.www.designPatterns.builderPattern.house;
/**
* 建造者--建设房子的一类人
*/
public class AmericanBuilder extends Builder {
public AmericanBuilder(House house) {
super(house);
}
// 建设卧室
public void buildBedroom() {
house.setBedroom("美式风格");
}
// 建设卫生间
public void buildBathroom() {
house.setBathroom("美式风格");
}
// 建设厨房
public void buildKitchen() {
house.setKitchen("美式风格");
}
// 建设客厅
public void buildLivingRoom() {
house.setLivingRoom("美式风格");
}
}
这里定义了两种类型的建造者, 一个是中式风格的建造者, 另一个是美式风格的建造者. 4) 指挥者：调用建造者中的方法完成复杂对象的创建。
package com.lxl.www.designPatterns.builderPattern.house;
/**
* 指挥者
*/
public class Director {
/**
* 指挥建造师建设房子
*/
Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
/**
* 发出建造房子的命令
*
* 最后得到装修的成品
*/
public House command() {
// 第一步: 装修卧室
builder.buildBedroom();
// 第二步: 装修卫生间
builder.buildBathroom();
// 第三步: 装修厨房
builder.buildKitchen();
// 第四步: 装修客厅
builder.buildLivingRoom();
return builder.result();
}
}
建筑师负责装修, 还需要一个懂装修的建筑经理来安排装修顺序.
- 客户类
package com.lxl.www.designPatterns.builderPattern.house;
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
House house = new House();
Builder builder = new ChineseBuilder(house);
Director director = new Director(builder);
House result = director.command();
result.show();
}
}
- 运行结果
房子装修完成了
厨房是中式风格
卧室是中式风格
卫生间是中式风格
客厅是中式风格
案例二：建造者结构变形 -- 实体类建造者
通常我们在项目中有这样的需求, 比如说实体对象, 在构造实体对象的时候, 有的参数是必填, 有的参数是选填. 通常我们会怎么设计呢?以房子为例. 一间普通的住宅房, 必须要有的是卧室和卫生间. 可以有可以没有的是厨房和客厅. 比如小白领租的公寓就没有厨房和客厅. 这样的实体我们怎么设计呢?
a. 通常的设计
package com.lxl.www.designPatterns.builderPattern.domain;
/**
* 文章
*/
public class House {
/**
* 卧室
*/
private String bedRoom; // 必填
/**
* 卫生间
*/
private String bathRoom; // 必填
/**
* 客厅
*/
private String livingRoom; // 选填
/**
* 厨房
*/
private String kitchenRoom; // 选填
public House(String bedRoom, String bathRoom) {
this.bedRoom = bedRoom;
this.bathRoom = bathRoom;
}
public House(String bedRoom, String bathRoom, String livingRoom, String kitchenRoom) {
this(bedRoom, bathRoom);
this.livingRoom = livingRoom;
this.kitchenRoom = kitchenRoom;
}
}
我们通常可能会这样设计, 当只有必填参数需要传入的时候, 调用第一个构造函数, 当需要传递四个参数的时候, 调用第二个构造函数, 当需要穿三个参数的时候, 就调用set方法. 是不是很眼熟.....
这样的缺点是: 当属性很多的时候, 过多的构造函数让人眼花缭乱, 结构不清晰. 维护起来也不方便.
b. 使用建造者设计模式
package com.lxl.www.designPatterns.builderPattern.domain;
/**
* 为了和第一个版本做区分, 所以这里起名字为Home
*/
public class Home {
/**
* 卧室
*/
private String bedRoom; // 必填
/**
* 卫生间
*/
private String bathRoom; // 必填
/**
* 客厅
*/
private String livingRoom; // 选填
/**
* 厨房
*/
private String kitchenRoom; // 选填
public Home(Builder builder) {
this.bedRoom = builder.bedRoom;
this.bathRoom = builder.bathRoom;
this.livingRoom = builder.livingRoom;
this.kitchenRoom = builder.kitchenRoom;
}
static class Builder {
private String bedRoom; // 必填
private String bathRoom; // 必填
private String livingRoom; // 选填
private String kitchenRoom; // 选填
public Builder(String bedRoom, String bathRoom) {
this.bedRoom = bedRoom;
this.bathRoom = bathRoom;
}
public Builder setLivingRoom(String livingRoom) {
this.livingRoom = livingRoom;
return this;
}
public Builder setKitchenRoom(String kitchenRoom) {
this.kitchenRoom = kitchenRoom;
return this;
}
public Home build() {
return new Home(this);
}
}
}
在调用的时候, 我们可以采用链式调用, 这样就构建出来一个对象了.
public class client {
public static void main(String[] args) {
Home home = new Home.Builder("卧室", "卫生间")
.setLivingRoom("客厅")
.setKitchenRoom("厨房").build();
}
}
上面的示例代码只是传入四个参数，如果参数是十四个甚至更多，builder 模式的优势将会更加明显，传递参数更加灵活，代码具有更高的可读性.
当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时可以采用上述方式利用 builder模式进行重构.
案例三：
四. 使用场景
建造者模式主要适用于以下应用场景：
- 隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
- 多个部件可以装配到一个对象中，但是产生的运行结果可能是不同的
- 如果产品类非常复杂或者产品类因为调用顺序不同而产生不同作用
- 初始化一个对象时，参数过多，或者很多参数具有默认值
- Builder模式不适合创建差异性很大的产品类
- 产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
五. 建造者模式的优缺点
优点：
使用建造者模式可以使客户端不必知道产品内部组成的细节。 具体的建造者类之间是相互独立的，这有利于系统的扩展。 具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响。
缺点：
建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。
六. 建造者模式与抽象工厂模式的比较
之所以会将建造者模式和抽线工厂模式进行比较, 是因为他们都是用来创建对象的. 我们来看看这两者创建对象有何不同.
- 与抽象工厂模式相比，建造者模式注重返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品可能一些列相关产品(实现同一个接口)
- 在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造过程，它侧重于一步步构造一个复杂对象，返回一个完整的对象 。
- 如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车.
