Builder 模式基本介绍
Builder 模式是一步一步创建一个复杂对象的创建型模式,它允许用户在不知道内部构建细节的情况下,可以更精细地控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦,使得构建过程和部件的表示隔离开来。
因为一个复杂的对象有很多大量组成部分,如汽车,有车轮、方向盘、发动机,还有各种小零件等,如何将这些部件装配成一辆汽车,这个装配过程很漫长,也很复杂,对于这种情况,为了构建过程中对外部隐藏实现细节,就可以使用 Builder 模式将部件和组装过程分离,使得构建过程和部件都可以*扩展,两者之间的耦合也降到最低。
Builder 模式的定义
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
Builder 模式的使用场景
- (1)相同的方法,不同的执行顺序,产生不同的事件结果时。
- (2)多个部件或零件,都可以装配到一个对象中,但是产生的运行结果又不相同时。
- (3)产品类非常复杂,或者产品类中的调用顺序不同产生了不同的作用,这个时候使用建造者模式非常合适。
- (4)当初始化一个对象特别复杂,如参数多,且很多参数都具有默认值时。
Builder 模式的 UML 类图
角色介绍:
- Product 产品类 —— 产品的抽象类;
- Builder —— 抽象 Builder 类,规范产品的组建,一般是由子类实现具体的组建过程;
- ConcreteBuilder —— 具体的 Builder 类;
- Director —— 统一组装过程。
Builder 模式的简单实现
小汽车的组装过程较为复杂,并且组装顺序是不固定的,为了易于理解,我们把小汽车组装的过程简化为构建发动机、设置车身颜色、设置轮毂大小 3 个部分,然后通过 Director 和 具体的 Builder 来构建小汽车对象。代码如下所示:
//小汽车抽象类,即 Product 角色
public abstract class Car {
protected String mEngine; //发动机型号
protected String mWheel; //轮毂大小
protected String mCarColor; //车身颜色
protected Car() {
}
public abstract void setmEngine();
public void setmWheel(String mWheel) {
this.mWheel = mWheel;
}
public void setmCarColor(String mCarColor) {
this.mCarColor = mCarColor;
}
}
//具体的 Car类,BMW
public class BMW extends Car {
@Override
public void setmEngine() {
mEngine = "涡轮增压发动机";
}
}
//抽象 Builder 类
public abstract class Builder {
//设置发动机型号
public abstract void setmEngine();
//设置轮毂大小
public abstract void setmWheel(String mWheel);
//设置车身颜色
public abstract void setmCarColor(String mCarColor);
//创建 Car
public abstract Car create();
}
public class BMWBuilder extends Builder {
private Car bmw = new BMW();
@Override
public void setmEngine() {
bmw.setmEngine();
}
@Override
public void setmWheel(String mWheel) {
bmw.setmWheel(mWheel);
}
@Override
public void setmCarColor(String mCarColor) {
bmw.setmCarColor(mCarColor);
}
@Override
public Car create() {
return bmw;
}
}
public class Director {
Builder mBuilder = null;
public Director(Builder builder) {
mBuilder = builder;
}
public void construct(String wheel, String carColor) {
mBuilder.setmWheel(wheel);
mBuilder.setmCarColor(carColor);
mBuilder.setmEngine();
}
}
public class Text {
public static void show() {
//构建器
Builder builder = new BMWBuilder();
Director bmwDirector = new Director(builder);
//封装构建过程
bmwDirector.construct("18寸轮毂", "红色");
//构建计算机
builder.create();
}
}
上述示例中,通过具体的 BMWBuilder 来构建 BMW 对象,而 Director 封装了构建复杂产品对象的过程,对外隐藏构建细节。Builder 与 Director 一起将一个复杂对象的狗将与它的表示分离,使得同样的构建过程可以创建不同的对象。
*值的注意的是,在现实开发过程中,Director 角色经常会被忽略。而是直接使用一个 Builder 来进行对象的封装,这个 Builder 通常为链式调用,它的关键点是每个 setter 方法都返回自身,也就是 return this,这样就使得 setter 方法可以链式调用,代码大致如下:
new TestBuilder().setA("A").setB("B").create();
通过这种形式不仅去除了 Director 角色,整个结构也更加简单,也能对 Product 对象的组装过程有更精细的控制。
Android 源码中的 Builder 模式实现
在 Android 源码中,最常用的 Builder 模式就是 AlertDialog.Builder,使用该 Builder 来构建复杂的 AlertDialog 对象。在开发过程中,我们 经常用到 AlertDialog,具体示例如下所示:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setIcon(R.mipmap.ic_launcher);
builder.setTitle("Title")
.setMessage("Message")
.setPositiveButton("Button1", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "点击了Button1", Toast.LENGTH_LONG).show();
}
})
.setNeutralButton("Button2", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "点击了Button2", Toast.LENGTH_LONG).show();
}
})
.setNeutralButton("Button3", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(MainActivity.this, "点击了Button3", Toast.LENGTH_LONG).show();
}
})
.create().show();
从类名就可以看出这就是一个 Builder 模式,通过 Builder 对象来组装 Dialog 的各个部分,如 title、buttons、Message 等,将Dialog 的构造和表示进行分离。
下面来看看 AlertDialog 的相关源码:
public class AlertDialog extends Dialog implements DialogInterface {
//AlertController 接收 Builder 成员变量 P 中的各个参数
private AlertController mAlert;
//构造函数
protected AlertDialog(Context context) {
this(context, 0);
}
//构造函数
protected AlertDialog(Context context, @StyleRes int themeResId) {
this(context, themeResId, true);
}
//构造 AlertDialog
AlertDialog(Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
super(context, createContextThemeWrapper ? resolveDialogTheme(context, themeResId) : 0,
createContextThemeWrapper);
mWindow.alwaysReadCloseOnTouchAttr();
//构造 AlertController
mAlert = new AlertController(getContext(), this, getWindow());
}
//实际上调用的是 mAlert 的 setTitle 方法
@Override
public void setTitle(CharSequence title) {
super.setTitle(title);
mAlert.setTitle(title);
}
public void setIcon(@DrawableRes int resId) {
mAlert.setIcon(resId);
}
//AlertDialog 其他的代码省略
//********* Builder 为 AlertDialog 的内部类 ********
public static class Builder {
//1、存储 AlertDialog 的各个参数,如 title、message、icon等
private final AlertController.AlertParams P;
public Builder(Context context) {
this(context, resolveDialogTheme(context, 0));
}
public Builder(Context context, int themeResId) {
P = new AlertController.AlertParams(new ContextThemeWrapper(
context, resolveDialogTheme(context, themeResId)));
}
//Builder 其他代码省略
//2、设置各种参数
public Builder setTitle(@StringRes int titleId) {
P.mTitle = P.mContext.getText(titleId);
return this;
}
public Builder setIcon(Drawable icon) {
P.mIcon = icon;
return this;
}
//3、构建 AlertDialog 传递参数
public AlertDialog create() {
// Context has already been wrapped with the appropriate theme.
//4、调用 new AlertDialog 构建对象,并且将参数传递给个体 AlertDialog
final AlertDialog dialog = new AlertDialog(P.mContext, 0, false);
//5、将 P 中的参数应用到 dialog 中的 mAlert 对象中
P.apply(dialog.mAlert);
dialog.setCancelable(P.mCancelable);
if (P.mCancelable) {
dialog.setCanceledOnTouchOutside(true);
}
dialog.setOnCancelListener(P.mOnCancelListener);
dialog.setOnDismissListener(P.mOnDismissListener);
if (P.mOnKeyListener != null) {
dialog.setOnKeyListener(P.mOnKeyListener);
}
return dialog;
}
上述代码中,Builder 类可以设置 AlertDialog 中的 title、message、button 等参数,这些参数都存储在类型为 AlertController.AlertParams 的成员变量 P 中,AlertController.AlertParams 中包含了与 AlertDialog 视图中对应的成员变量。在调用 Builder 类的 create 函数时会创建 AlertDialog,并且将返回 AlertDialog 的实例。关于 AlertDialog 的底层实现代码这里就不在过多的进行研究了,有兴趣的可自行查看。
使用 Builder 模式的优点:
- (1)良好的封装性,使用建造者模式可以是客户端不必知道产品内部组成的细节
- (2)建造者独立,容易扩展
缺点:
- 会产生多余的 Builder 对象以及 Director 对象,消耗内存。