设计模式（二）AlertDialog中的建造者模式

1、基本概念：

一、定义：

将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。

二、适用场景：

• 多个组成部分，均可以装配到同一个对象，可是产生的结果不相同
• 相同的方法，不一样的执行顺序，产生不一样的事件结果
• 产品特别复杂，参数比较多的状况 例：电脑含有不少零配件，能够算是一个复杂对象。其中内存卡，主板、CPU等都是电脑的组成部分，若是构建一台电脑，不须要知道是如何组装的，只须要提供所须要的零配件型号，此时就能够用构建者模式。

三、优势：

• 封装性好，可使使用者没必要知道内部组成的细节
• 建造者独立，容易扩展

四、类图：

• Director：导演类，负责安排模块顺序，通知Builder开始构建
• Builder：抽象Builder类，规范产品的组建
• ConcreteBuilder：构造者实现类，实现抽象类的全部方法，而且返回一个组建好的对象
• Product：产品类

2、实例：

一、产品实体类：

public class Computer {
    private String cpu;
    private String mainBoard;
    private String ram;

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

    public String getRam() {
        return ram;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }
}
复制代码

二、抽象Builder：

public abstract class Builder {
    public abstract void buildCpu(String cpu);
    public abstract void buildMainBoard(String mainBoard);
    public abstract void buildRam(String ram);
    public abstract Computer build();
}
复制代码

三、Builder实现类：

public class ComputerBuilder extends Builder {
    private Computer mComputer = new Computer();
    
    @Override
    public void buildCpu(String cpu) {
        mComputer.setCpu(cpu);
    }

    @Override
    public void buildMainBoard(String mainBoard) {
        mComputer.setMainBoard(mainBoard);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setRam(ram);
    }

    @Override
    public Computer build() {
        return mComputer;
    }
}
复制代码

四、导演类：

起到封装的做用，避免深刻到Builder内部的具体实现。能够传入不一样的Builder实现对象。

public class ComputerDirector {
    private Builder mBuilder;

    private ComputerDirector(Builder builder) {
        this.mBuilder = builder;
    }

    public Computer createComputer(String cpu, String mainBoard, String ram) {
        mBuilder.buildCpu(cpu);
        mBuilder.buildMainBoard(mainBoard);
        mBuilder.buildRam(ram);
        return mBuilder.build();
    }
}
复制代码

五、客户端调用：

public class ComputerTest {
    public static void main(String[] args){
        Builder builder = new ComputerBuilder();
        ComputerDirector director = new ComputerDirector(builder);
        director.createComputer("i3","my board", "4g");
    }
}
复制代码

在实际使用过程当中，有时会将Director进行省略，由调用者选择部分参数进行设置

3、AlertDialog

一、Builder

public static class Builder {

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)));
    }
   
    public Builder setTitle(@StringRes int titleId) {
        P.mTitle = P.mContext.getText(titleId);
        return this;
    }

    public Builder setCustomTitle(View customTitleView) {
        P.mCustomTitleView = customTitleView;
        return this;
    }

    public Builder setMessage(@StringRes int messageId) {
        P.mMessage = P.mContext.getText(messageId);
        return this;
    }
    ......

    public AlertDialog create() {
        // Context has already been wrapped with the appropriate theme.
        final AlertDialog dialog = new AlertDialog(P.mContext, 0, false);
        //调用了AlertParams的apply方法
        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;
    }

    public AlertDialog show() {
        final AlertDialog dialog = create();
        dialog.show();
        return dialog;
    }

}
复制代码

Builder中定义了一些set方法用来设置Dialog的参数，Builder方法内部是给AlertController.AlertParams进行参数赋值

二、AlertDialog.AlertParams

public static class AlertParams {
    public final Context mContext;
    public final LayoutInflater mInflater;

    public int mIconId = 0;
    public Drawable mIcon;
    public int mIconAttrId = 0;
    public CharSequence mTitle;
    public View mCustomTitleView;
    public CharSequence mMessage;
    public CharSequence mPositiveButtonText;
    ......

    public AlertParams(Context context) {
        mContext = context;
        mCancelable = true;
        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    }
    //将参数赋值给了Dialog
    public void apply(AlertController dialog) {
        if (mCustomTitleView != null) {
            dialog.setCustomTitle(mCustomTitleView);
        } else {
            if (mTitle != null) {
                dialog.setTitle(mTitle);
            }
            if (mIcon != null) {
                dialog.setIcon(mIcon);
            }
            if (mIconId != 0) {
                dialog.setIcon(mIconId);
            }
            if (mIconAttrId != 0) {
                dialog.setIcon(dialog.getIconAttributeResId(mIconAttrId));
            }
        }
        if (mMessage != null) {
            dialog.setMessage(mMessage);
        }
        ......
    }
} 
复制代码

三、基本使用

AlertDialog.Builder builder = new AlertDialog.Builder(this);
        // 设置参数
builder.setTitle("")
    .setIcon(R.drawable.ic_launcher)
    .setMessage("")；
builder.create().show();
复制代码

• 先建立一个Builder对象，经过Builder进行参数设置
• 内部会将这些参数传递给AlertDialog.AlertParams
• 在调用create方法时，AlertDialog.AlertParams再将参数设置给AlertDialog
• 最终经过show方法显示dialog

Builder模式一般做为配置类的构造器将配置的构造和表示分离，而且经过调用链实现，使代码调用更简洁。