上一篇文章中学习了三种工厂模式，这篇文章来学习一下另一种应用比较多的创建型模式，它适合用来创建拥有非常多的属性的对象。同样地，也是先从一个例子开始。
建造者模式
相信小伙伴们在假期出去游玩时，都会制定一套度假计划。一般来说，需要包括如下几个部分，VacationPlanner 类可以如下定义：
public class VacationPlanner {
private int day; // 天数
private String city; // 旅游城市
private int ticket; // 车票
private String hotel; // 住宿旅馆
private String tourist; // 旅游景点
private int personNum; // 人数
private String other; // 其他
// setter/getter/toString
}
如此，我们创建计划的方法 createPlanner 可以按照如下写：
public class Vacation {
public VacationPlanner createPlanner(int day, String city, String hotel, int personNum,
int ticket, String tourist, String other) {
VacationPlanner planner = new VacationPlanner();
planner.setDay(day);
planner.setCity(city);
planner.setHotel(hotel);
planner.setPersonNum(personNum);
planner.setTicket(ticket);
planner.setTourist(tourist);
planner.setOther(other);
return planner;
}
}
很简单吧。但是如果很多人都想要制作一个度假计划，而每个人的计划又不太一样，所以，创建的度假计划及其创建步骤也就不同。例如，有的人就是本地人，不需要旅馆；有的人需要其他活动。
另外，其实我们并不需要知道度假计划的内部实现。那我们该如何做一个有弹性的设计，去适应各种变化呢?其实，我们可以创建一个单独的创建者，将度假计划的表示和创建计划的步骤分开来。
但在这之前，我们应该定义一个抽象建造者，也就是要符合之前我们所说的针对接口编程，而不是具体的类：
public abstract class AbstractVacationPlannerBuilder {
public abstract void buildDay();
public abstract void buildTicket();
public abstract void buildHotel();
public abstract void buildTourist();
public abstract void buildPersonNum();
public abstract void buildOther();
public abstract VacationPlanner getVacationPlanner();
}
然后，再来创建一个具体的建造者：
public class VacationPlannerBuilder extends AbstractVacationPlannerBuilder {
private VacationPlanner vacationPlanner = new VacationPlanner();
@Override
public void buildDay(int day) {
vacationPlanner.setDay(day);
}
@Override
public void buildTicket(int ticket) {
vacationPlanner.setTicket(ticket);
}
@Override
public void buildHotel(String hotel) {
vacationPlanner.setHotel(hotel);
}
@Override
public void buildTourist(String tourist) {
vacationPlanner.setTourist(tourist);
}
@Override
public void buildPersonNum(int personNum) {
vacationPlanner.setPersonNum(personNum);
}
@Override
public void buildOther(String other) {
vacationPlanner.setOther(other);
}
@Override
public VacationPlanner getVacationPlanner() {
return vacationPlanner;
}
}
现在 Vacation 就可以按照如下的方式写了：
public class Vacation {
private AbstractVacationPlannerBuilder builder;
public void setVacationPlannerBuilder(AbstractVacationPlannerBuilder builder) {
this.builder = builder;
}
public AbstractVacationPlannerBuilder createPlanner(int day, String city, String hotel, int personNum,
int ticket, String tourist, String meal, String other) {
builder.buildDay(day);
builder.buildCity(city);
builder.buildHotel(hotel);
builder.buildPersonNum(personNum);
builder.buildTicket(ticket);
builder.buildTourist(tourist);
builder.buildOther(other);
return builder;
}
}
上述模式就是建造者模式，它是将一个复杂对象的表示和创建分离开来，允许通过多个步骤来创建对象，并且可以改变其过程。
它的 UML 图如下：
下面来总结一下建造者模式的优点：
- 建造者模式将一个复杂对象的创建过程封装起来；
- 向客户端隐藏了产品内部的实现，将产品本身与产品的创建过程分离开来；
- 可以更加精确地控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中；
缺点：
- 在建造者模式中，如果产品之间的差异性太大，则不适合使用建造者模式。
- 如果产品的内部变化复杂，可能需要定义很多建造者类来实现这些变化，导致系统变得很庞大。
静态内部类方式
另外，建造者模式也可以使用静态内部类的形式，它是将实体类对应的 Builder 放置到实体类的内部，看一下它的代码：
public class VacationPlanner {
private int day; // 天数
private String city; // 旅游城市
private int ticket; // 车票
private String hotel; // 住宿旅馆
private String tourist; // 旅游景点
private int personNum; // 人数
private String other; // 其他
// 全属性的构造方法
public VacationPlanner(VacationPlannerBuilder builder) {
this.day = builder.day;
this.city = builder.city;
this.ticket = builder.ticket;
this.hotel = builder.hotel;
this.tourist = builder.tourist;
this.personNum = builder.personNum;
this.other = builder.other;
}
public static class VacationPlannerBuilder {
private int day; // 天数
private String city; // 旅游城市
private int ticket; // 车票
private String hotel; // 住宿旅馆
private String tourist; // 旅游景点
private int personNum; // 人数
private String other; // 其他
// 与之前不同，这里返回 VacationPlannerBuilder
public VacationPlannerBuilder buildDay(int day) {
this.day = day;
return this;
}
public VacationPlannerBuilder buildCity(String city) {
this.city = city;
return this;
}
public VacationPlannerBuilder buildTicket(int ticket) {
this.ticket = ticket;
return this;
}
public VacationPlannerBuilder buildHotel(String hotel) {
this.hotel = hotel;
return this;
}
public VacationPlannerBuilder buildTourist(String tourist) {
this.tourist = tourist;
return this;
}
public VacationPlannerBuilder buildPersonNum(int personNum) {
this.personNum = personNum;
return this;
}
public VacationPlannerBuilder buildOther(String other) {
this.other = other;
return this;
}
public VacationPlanner build() {
return new VacationPlanner(this);
}
}
}
下面来写个测试类进行测试：
public class Test {
public static void main(String[] args) {
VacationPlanner planner = new VacationPlanner.VacationPlannerBuilder()
.buildDay(3)
.buildCity("北京")
.buildHotel("7天")
.buildPersonNum(2)
.buildTicket(999)
.buildTourist("故宫")
.buildOther("其他")
.build();
System.out.println(planner);
}
}
建造者模式的具体实践
JDK#StringBuilder
AbstractStringBuilder
可以将 StringBuilder 看成 String 的建造者，而 AbstractStringBuilder 是建造者的抽象类。它的部分源码如下：
abstract class AbstractStringBuilder implements Appendable, CharSequence {
// 存储 char 字符的数组
char[] value;
int count;
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len); // 确保容量
str.getChars(0, len, value, count);
count += len;
return this;
}
public AbstractStringBuilder append(int i) {
if (i == Integer.MIN_VALUE) {
append("-2147483648");
return this;
}
int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
: Integer.stringSize(i);
int spaceNeeded = count + appendedLength;
ensureCapacityInternal(spaceNeeded);
Integer.getChars(i, spaceNeeded, value);
count = spaceNeeded;
return this;
}
@Override
public abstract String toString();
}
StringBuilder
StringBuilder 的部分源码如下，这里使用的建造者模式是我们之前看到的第一种模式：
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence {
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
@Override
public StringBuilder append(int i) {
super.append(i);
return this;
}
@Override
public String toString() {
// 创建了一个新的 String
return new String(value, 0, count);
}
}
Guava#ImmutableSet
ImmutableSet 的建造者使用的是静态内部类方式：
public abstract class ImmutableSet<E> extends ImmutableCollection<E> implements Set<E> {
public static <E> Builder<E> builder() {
return new Builder<E>();
}
public static class Builder<E> extends ImmutableCollection.ArrayBasedBuilder<E> {
@Override
public Builder<E> add(E element) {
super.add(element);
return this;
}
@Override
public Builder<E> addAll(Iterable<? extends E> elements) {
super.addAll(elements);
return this;
}
@Override
public ImmutableSet<E> build() {
ImmutableSet<E> result = construct(size, contents);
size = result.size();
return result;
}
}
private static <E> ImmutableSet<E> construct(int n, Object... elements) {
// 返回不同的 ImmutableSet 实现
}
}
一般它有两种创建方法：
ImmutableSet<Object> set1 = new ImmutableSet.Builder<>().build();
ImmutableSet<Object> set2 = ImmutableSet.builder().build();
参考资料
- 《Head First 设计模式》
