JAVA设计模式之建造者模式

一 概述

1.1 定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

• 建造者模式（Builder pattern）属于创建型模式
• 建造者模式主要用来创建复杂的对象，用户可以不用关心其建造过程和细节

例如：当要组装一台电脑时，我们选择好 CPU、内存、硬盘等等，然后交给装机师傅，装机师傅就把电脑给组装起来，我们不需要关心是怎么拼装起来的。

1.2 使用场景

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

1.3 解决的问题

当一个类的构造函数参数超过4个，而且这些参数有些是可选的时，我们通常有两种办法来构建它的对象。

例如我们现在有如下一个类计算机类 Computer，其中 cpu 与 ram 是必填参数，而其他 3 个是可选参数，那么我们如何构造这个类的实例呢，通常有两种常用的方式：

public class Computer {
    private String cpu;//必须
    private String ram;//必须
    private int usbCount;//可选
    private String keyboard;//可选
    private String display;//可选
}

第一：折叠构造函数模式（telescoping constructor pattern ），这个我们经常用，如下代码所示：

public class Computer {
     ...
    public Computer(String cpu, String ram) {
        this(cpu, ram, 0);
    }
    public Computer(String cpu, String ram, int usbCount) {
        this(cpu, ram, usbCount, "罗技键盘");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard) {
        this(cpu, ram, usbCount, keyboard, "三星显示器");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard, String display) {
        this.cpu = cpu;
        this.ram = ram;
        this.usbCount = usbCount;
        this.keyboard = keyboard;
        this.display = display;
    }
}

第二种：Javabean 模式，如下所示

public class Computer {
        ...

    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public int getUsbCount() {
        return usbCount;
    }
...
}

那么这两种方式有什么弊端呢？

• 第一种主要是使用及阅读不方便。你可以想象一下，当你要调用一个类的构造函数时，你首先要决定使用哪一个，然后里面又是一堆参数，如果这些参数的类型很多又都一样，你还要搞清楚这些参数的含义，很容易就传混了。。。
• 第二种方式在构建过程中对象的状态容易发生变化，造成错误。因为那个类中的属性是分步设置的，所以就容易出错。

为了解决这两个痛点，builder 模式就横空出世了。

二 实现

2.1 实现方法

• 在 Computer 中创建一个静态内部类 Builder，然后将 Computer 中的参数都复制到 Builder 类中
• 在 Computer 中创建一个 private 的构造函数，参数为 Builder 类型
• 在 Builder 中创建一个 public 的构造函数，参数为 Computer 中必填的那些参数，cpu 和 ram
• 在 Builder 中创建设置函数，对 Computer 中那些可选参数进行赋值，返回值为 Builder 类型的实例
• 在 Builder 中创建一个 build() 方法，在其中构建 Computer 的实例并返回

下面代码就是最终的样子：

public class Computer {
    private final String cpu;//必须
    private final String ram;//必须
    private final int usbCount;//可选
    private final String keyboard;//可选
    private final String display;//可选

    private Computer(Builder builder){
        this.cpu=builder.cpu;
        this.ram=builder.ram;
        this.usbCount=builder.usbCount;
        this.keyboard=builder.keyboard;
        this.display=builder.display;
    }
    //省略getter
    ...
    public static class Builder{
        private String cpu;//必须
        private String ram;//必须
        private int usbCount;//可选
        private String keyboard;//可选
        private String display;//可选
       
        public Builder(String cup,String ram){
            this.cpu=cup;
            this.ram=ram;
        }

        public Builder setUsbCount(int usbCount) {
            this.usbCount = usbCount;
            return this;
        }
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }
        public Builder setDisplay(String display) {
            this.display = display;
            return this;
        }        
        public Computer build(){
            return new Computer(this);
        }
    }
}

2.2 使用

在客户端使用链式调用，一步一步的把对象构建出来。

Computer computer = new Computer.Builder("因特尔","三星")
        .setDisplay("三星24寸")
        .setKeyboard("罗技")
        .setUsbCount(2)
        .build();

构建者模式是一个非常实用而常见的创建类型的模式（creational design pattern)，例如图片处理框架 Glide，网络请求框架 Retrofit 等都使用了此模式。

其实上面的内容是 Builder 在 Java 中一种简化的使用方式，经典的 Builder 模式与其有一定的不同。

三 传统 Builder 模式

3.1 UML 类图

• Product（产品类）：最终要生成的对象，例如 Computer 实例
• Builder（抽象建造者）：构建者的抽象基类（有时会使用接口代替）。其定义了构建 Product 的抽象方法，其实体类需要实现这些方法。其会包含一个用来返回最终产品的方法 Product getProduct()
• ConcreteBuilder（实际的建造者）：Builder 的实现类
• Director（指挥者类）：决定如何构建最终产品的算法。其会包含一个负责组装的方法 void Construct(Builder builder)， 在这个方法中通过调用 builder 的方法，就可以设置 builder，等设置完成后，就可以通过 builder 的 getProduct() 方法获得最终的产品

我们接下来将最开始的例子使用传统方式来实现一遍。

3.2 实现

第一步：我们的目标 Computer 类：

3.2.1 目标 Computer 类

public class Computer {
    private String cpu;//必须
    private String ram;//必须
    private int usbCount;//可选
    private String keyboard;//可选
    private String display;//可选

    public Computer(String cpu, String ram) {
        this.cpu = cpu;
        this.ram = ram;
    }
    public void setUsbCount(int usbCount) {
        this.usbCount = usbCount;
    }
    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }
    public void setDisplay(String display) {
        this.display = display;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", usbCount=" + usbCount +
                ", keyboard='" + keyboard + '\'' +
                ", display='" + display + '\'' +
                '}';
    }
}

第二步：抽象构建者类

3.2.2 抽象构建者类

public abstract class ComputerBuilder {
    public abstract void setUsbCount();
    public abstract void setKeyboard();
    public abstract void setDisplay();

    public abstract Computer getComputer();
}

第三步：实体构建者类，我们可以根据要构建的产品种类产生多了实体构建者类，这里我们需要构建两种品牌的电脑，苹果电脑和联想电脑，所以我们生成了两个实体构建者类。

3.2.3 实体构建者类

苹果电脑构建者类

public class MacComputerBuilder extends ComputerBuilder {
    private Computer computer;
    public MacComputerBuilder(String cpu, String ram) {
        computer = new Computer(cpu, ram);
    }
    @Override
    public void setUsbCount() {
        computer.setUsbCount(2);
    }
    @Override
    public void setKeyboard() {
        computer.setKeyboard("苹果键盘");
    }
    @Override
    public void setDisplay() {
        computer.setDisplay("苹果显示器");
    }
    @Override
    public Computer getComputer() {
        return computer;
    }
}

联想电脑构建者类

public class LenovoComputerBuilder extends ComputerBuilder {
    private Computer computer;
    public LenovoComputerBuilder(String cpu, String ram) {
        computer=new Computer(cpu,ram);
    }
    @Override
    public void setUsbCount() {
        computer.setUsbCount(4);
    }
    @Override
    public void setKeyboard() {
        computer.setKeyboard("联想键盘");
    }
    @Override
    public void setDisplay() {
        computer.setDisplay("联想显示器");
    }
    @Override
    public Computer getComputer() {
        return computer;
    }
}

第四步：指导者类（Director）

3.2.4 指导者类（Director）

public class ComputerDirector {
    public void makeComputer(ComputerBuilder builder) {
        builder.setUsbCount();
        builder.setDisplay();
        builder.setKeyboard();
    }
}

3.3 使用

首先生成一个 director (1)，然后生成一个目标 builder (2)，接着使用 director 组装 builder (3)，组装完毕后使用 builder 创建产品实例 (4)。

   public static void main(String[] args) {
        ComputerDirector director=new ComputerDirector();//1
        ComputerBuilder builder=new MacComputerBuilder("I5处理器","三星125");//2
        director.makeComputer(builder);//3
        Computer macComputer=builder.getComputer();//4
        System.out.println("mac computer:"+macComputer.toString());

        ComputerBuilder lenovoBuilder=new LenovoComputerBuilder("I7处理器","海力士222");
        director.makeComputer(lenovoBuilder);
        Computer lenovoComputer=lenovoBuilder.getComputer();
        System.out.println("lenovo computer:"+lenovoComputer.toString());
}

输出结果如下：

mac computer:Computer{cpu='I5处理器', ram='三星125', usbCount=2, 
        keyboard='苹果键盘', display='苹果显示器'}
        
lenovo computer:Computer{cpu='I7处理器', ram='海力士222', usbCount=4, 
        keyboard='联想键盘', display='联想显示器'}

可以看到，文章最开始的使用方式是传统 builder 模式的变种， 首先其省略了 director 这个角色，将构建算法交给了 client 端，其次将 builder 写到了要构建的产品类里面，最后采用了链式调用。

四 总结

日常工作中最为常见的就是使用文章开头的变种，而不是传统模式。本文传统模式实例构建的对象是可变的，我们也可以将其写成不可变对象，以场景而定吧

4.1 优点

• 封装性良好，隐藏内部构建细节
• 易于解耦，将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象
• 易于扩展，具体的建造者类之间相互独立，增加新的具体建造者无需修改原有类库的代码
• 易于精确控制对象的创建，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响

4.2 缺点

• 产生多余的 Build 对象以及 Director 类
• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大

五 Android 中的源码实例分析

Android 中的 AlertDialog.Builder 就是使用了 Builder 模式来构建 AlertDialog 的。

5.1 AlertDialog.Builder 的简单用法

// 创建一个 Builder 对象
        AlertDialog.Builder builder = new AlertDialog.Builder(activity); 
        builder.setIcon(R.drawable.icon);
        builder.setTitle("标题");
        builder.setMessage("信息");
        builder.setPositiveButton("确定",
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {

                    }
                });
        AlertDialog alertDialog = builder.create(); // 创建 AlertDialog 对象
        alertDialog.show(); // 展示 AlertDialog

通过 Builder 对象来构建 Icon、Title、Message 等，将 AlertDialog 的构建过程和细节隐藏了起来。

5.2 AlertDialog 相关源码分析

// AlertDialog 源码
public class AlertDialog extends Dialog implements DialogInterface {
    private AlertController mAlert; // 接受 Builder 成员变量P的参数

    AlertDialog(Context context, @StyleRes int themeResId,
             boolean createContextThemeWrapper) {
        super(context, createContextThemeWrapper ? 
                resolveDialogTheme(context, themeResId) : 0, createContextThemeWrapper);
        mWindow.alwaysReadCloseOnTouchAttr();
        // 创建 AlertController 对象
        mAlert = AlertController.create(getContext(), this, getWindow());
    }

    @Override
    public void setTitle(CharSequence title) { // 设置 Title
        super.setTitle(title);
        mAlert.setTitle(title); // 保存在 AlertController 对象中
    }

    public void setMessage(CharSequence message) { // 设置 Message
        mAlert.setMessage(message); // 保存在 AlertController 对象中
    }

    public void setIcon(@DrawableRes int resId) { // 设置 Icon
        mAlert.setIcon(resId); // 保存在 AlertController 对象中
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAlert.installContent(); // 安装 AlertDialog 的内容
    }

    // AlertDialog 其他代码略

    public static class Builder {
    // 构建 AlertDialog 对象所需要的参数都存放在 P 中
        private final AlertController.AlertParams P;
        public Builder(Context context) {
            this(context, resolveDialogTheme(context, 0));
        }

        public Builder(Context context, int themeResId) {
            // 初始化 AlertParams 对象
            P = new AlertController.AlertParams(new ContextThemeWrapper(
                    context, resolveDialogTheme(context, themeResId)));
        }

        public Context getContext() {
            return P.mContext;
        }

        public android.app.AlertDialog.Builder setTitle(CharSequence title) {
            P.mTitle = title; // 保存 title 到 P 中
            return this;
        }

        public android.app.AlertDialog.Builder setMessage(CharSequence message) {
            P.mMessage = message; // 保存 message
            return this;
        }


        public android.app.AlertDialog.Builder setIcon(@DrawableRes int iconId) {
            P.mIconId = iconId; // 保存 IconId
            return this;
        }

        // Builder 其他代码略

        public android.app.AlertDialog create() { // 构建 AlertDialog
        // 创建一个 AlertDialog 对象
            final android.app.AlertDialog dialog =
                    new android.app.AlertDialog(P.mContext, 0, false);
            P.apply(dialog.mAlert);// 将 P 中的参数设置到 AlertController 中
            // 其他设置代码略
            return dialog;
        }
    }
}

// Dialog 源码
 public class Dialog implements DialogInterface, Window.Callback, 
         KeyEvent.Callback, View.OnCreateContextMenuListener, 
         Window.OnWindowDismissedCallback {
        //其他代码略
        public void show() {
            // 前面代码略
            if (!mCreated) {
                dispatchOnCreate(null);// 分发 onCreate
            } else {
                final Configuration config = mContext.getResources().getConfiguration();
                mWindow.getDecorView().dispatchConfigurationChanged(config);
            }

            onStart(); // 调用onStart()
            mDecor = mWindow.getDecorView();
            
            // 设置参布局参数略
           
            mWindowManager.addView(mDecor, l); // 添加到 WindowManager
            mShowing = true;

            sendShowMessage();
        }
        
        void dispatchOnCreate(Bundle savedInstanceState) {// 分发 onCreate
            if (!mCreated) {
            // 调用 AlertDialog 的 onCreate 方法，创建 AlertDialog 视图
                onCreate(savedInstanceState);
                mCreated = true;
            }
        }
    }

// AlertController 源码
public class AlertController {
        //其他代码略

        public void installContent() { // 安装内容
            int contentView = selectContentView(); // 选择合适的布局
            mWindow.setContentView(contentView);// 布局添加到 Window 中
            // 把 dialog.mAlert 对象中需要构建的元素逐个添加设置到 Window 上
            // 即构建我们设置的布局发生在这一步中
            setupView();
        }
    }

5.3 简单流程说明：

1、通过 AlertDialog.Builder 设置各种属性后（如：setTitle()），这些属性信息会保存在 P 变量中，P 变量的类型为 AlertController.AlertParams。

2、调用 builder.create() 即可返回一个 AlertDialog 对象。

• builder.create() 方法中首先会创建一个 AlertDialog 对象，AlertDialog 对象构造时会初始化 WindowManager 和 Window
• builder.create() 创建完 AlertDialog 对象后，会调用 P.apply(dialog.mAlert)；即把 P 变量中所存储的用来构建 AlertDialog 对象的元素设置到了 dialog.mAlert 中，dialog.mAlert 的类型为 AlertController

3、调用 AlertDialog 的 show() 方法，展示界面。

• show() 方法中会调用 dispatchOnCreate(null)，dispatchOnCreate(null) 调起 onCreate(),onCreate() 会调起mAlert.installContent()；即安装 AlertDialog 的内容
• installContent() 中会调用 mWindow.setContentView(mAlertDialogLayout)；即把 mAlertDialogLayout 这个布局加到 Window 中去
• 调完 mWindow.setContentView(mAlertDialogLayout) 后会调用 setupView()，setupView() 中会把 dialog.mAlert 对象中需要构建的元素逐个添加设置到 mWindow 上
• 最后通过把 view 添加到 mWindowManager 上展示出来

5.4 总结

• builder 模式隐藏了这种复杂的构建过程，只需几行简单的代码就把 AlertDialog 给展示出来了
• AlertDialog 的 builder 中并没有抽象建造者（Builder）、Director（指挥者类）等角色。AlertDialog.Builder 同时扮演了 Builder、ConcreteBuilder、Director 等角色，这是 Android 中的一种简化，也值得我们去学习使用