Java设计模式之——Builder 模式

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 对象，消耗内存。