Android设计模式——建造者模式

我感觉这个设计模式真是太简单，太好用了，这是一个创建型模式，定义是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。我的理解就是不需要关心建造过程，就像做菜一样，需要啥直接拿过来用，想放酱油就拿酱油，想放醋就放醋。

用途也很多，Retrofit和OkHttp都是用这个模式创建的，先看下OK HTTP的吧，简单说就是想增加拦截器就直接增加，想设置缓存也是直接设置，就像组装一样：

public class OkHttpClient implements Cloneable, Call.Factory, WebSocket.Factory {
  .....
 //构造函数
  public OkHttpClient() {
    this(new Builder());
  }
//不管咋构建的，都会调用这个构造函数
  OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    this.protocols = builder.protocols;
    ......
  }

  public Builder newBuilder() {
    return new Builder(this);
  }
  //Builder类
  public static final class Builder {
    Dispatcher dispatcher;
    ...
    int pingInterval;

    public Builder() {
        dispatcher = new Dispatcher();
        protocols = DEFAULT_PROTOCOLS;
        ...
    }

   Builder(OkHttpClient okHttpClient) {
     this.dispatcher = okHttpClient.dispatcher;
     this.proxy = okHttpClient.proxy;
     ...
   }

    ...
   //最后创建的是OkHttpClient类的对象
    public OkHttpClient build() {
      return new OkHttpClient(this);
    }
  }
}

接下来自己写个创建模式的弹出框吧，我实现了一个通用的dialog：

public class CommonAlertDialog extends Dialog {
    private final String TITLE;//题目
    private final String MESSAGE;//信息
    private final String CONFIRMTEXT;//确认文字
    private final String CANCLETEXT;//取消文字
    private final OnCancleClickListener onCancleClickListener;//取消的点击事件
    private final OnConfirmClickListener onConfirmClickListener;//确认的点击事件

    public interface OnConfirmClickListener{
        void onClick(View view);
    }
    public interface OnCancleClickListener{
        void onClick(View view);
    }

    //构造方法，其实这儿可以直接传一个builder过来的，就像OKHttp的构造方法一样
    private CommonAlertDialog(@NonNull Context context, String TITLE, String MESSAGE, String CONFIRMTEXT, String CANCLETEXT,
                             OnCancleClickListener onCancleClickListener, OnConfirmClickListener onConfirmClickListener) {
        super(context,R.style.AlertDialogUtil);
        this.TITLE = TITLE;
        this.MESSAGE = MESSAGE;
        this.CONFIRMTEXT = CONFIRMTEXT;
        this.CANCLETEXT = CANCLETEXT;
        this.onCancleClickListener = onCancleClickListener;
        this.onConfirmClickListener = onConfirmClickListener;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.view_common_dialog);
        initView();
    }
    public static Builder Builder(Context context){
        return new Builder(context);
    }
    private void initView() {
        Button btnConfirm = findViewById(R.id.btn_confirm);
        Button btnCancel = findViewById(R.id.btn_cancel);
        TextView tvTitle = findViewById(R.id.tv_title);
        TextView tvMessage = findViewById(R.id.tv_message);

        if (!TextUtils.isEmpty(TITLE)) {
            tvTitle.setText(TITLE);
        }
        if (!TextUtils.isEmpty(MESSAGE)) {
            tvMessage.setText(MESSAGE);
        }
        if (!TextUtils.isEmpty(CONFIRMTEXT)) {
            btnConfirm.setText(CONFIRMTEXT);
        }
        if (!TextUtils.isEmpty(CANCLETEXT)) {
            btnCancel.setText(CANCLETEXT);
        }
        btnConfirm.setOnClickListener(v -> {
            if(null != onConfirmClickListener){
                onConfirmClickListener.onClick(v);
            }
            dismiss();
        });
        btnCancel.setOnClickListener(v -> {
            if(null != onCancleClickListener){
                onCancleClickListener.onClick(v);
            }
            dismiss();
        });
    }
    public CommonAlertDialog shown(){
        show();
        return this;
    }
    //创建Builder类
    public static class Builder{
        private String mTitle;
        private String mMessage;
        private String mConfirmText;
        private String mCancelText;
        private OnConfirmClickListener mOnConfirmClickListener;
        private OnCancleClickListener mOnCancleClickListener;
        private Context mContext;

        private Builder(Context mContext) {
            this.mContext = mContext;
        }

        public Builder setTitle(String title){
            this.mTitle = title;
            return this;
        }
        public Builder setMessage(String message){
            this.mMessage = message;
            return this;
        }

        public Builder setConfirmText(String mConfirmText) {
            this.mConfirmText = mConfirmText;
            return this;
        }

        public Builder setCancelText(String mCancelText) {
            this.mCancelText = mCancelText;
            return this;
        }

        public Builder setOnConfirmClickListener(OnConfirmClickListener mOnConfirmClickListener) {
            this.mOnConfirmClickListener = mOnConfirmClickListener;
            return this;
        }

        public Builder setOnCancleClickListener(OnCancleClickListener mOnCancelClickListener) {
            this.mOnCancleClickListener = mOnCancelClickListener;
            return this;
        }
        //build时返回dialog对象，就是从这儿创建的对象
        public CommonAlertDialog build(){
            return new CommonAlertDialog(mContext,mTitle,mMessage,mConfirmText,mCancelText,
                    mOnCancleClickListener,mOnConfirmClickListener);
        }
    }
}

使用时就非常简单了，如下例子，我只想要设置消息文字和设置确认时的点击事件就好，相当简单

CommonAlertDialog.Builder(getSelfActivity())
                 .setMessage("是否确定删除该用户？")
                 .setOnConfirmClickListener(new CommonAlertDialog.OnConfirmClickListener() {
                     @Override
                     public void onClick(View view) {
                         。。。。。。 
                      }
                   })
                 .build()//此时返回的已经是CommonAlertDialog的对象了
                 .shown();//调用dialog的shown显示