设计模式之二：Builder模式
目录介绍
- 0.关于Builder模式案例下载
- 1.Builder模式介绍
- 2.Builder模式使用场景
- 3.Builder模式简单案例
- 3.1 Builder模式UML图(摘自网络)
- 3.2 在《Android源码设计模式》这本书上，介绍经典Builder模式中，包括
- 3.3 Product角色
- 3.4 Builder : 抽象Builder类，规范产品组建，一般是由子类实现具体的组建过程
- 3.5 ConcreteBuilder : 具体的Builder类
- 3.6 Director : 统一组装过程
- 4.Builder模式实际案例Demo
- 4.1 实际开发中，有时会遇到复杂的对象的代码
- 4.2 通过构造函数的参数形式去写一个实现类，或者通过set，get去实现
- 4.3 分析
- 4.4 将上面例子改成builder模式如下所示
- 4.5 最后运用，代码如下
- 4.6 关于线程安全问题
- 5.Android源码中的Builder模式实现
- 5.1 首先看看AlertDialog.Builder源代码，只是摘自部分代码
- 5.2 接下来看看build源代码
- 5.3 接下来看看show的代码
- 5.4 为什么AlertDialog要使用builder模式呢？
- 6.Builder模式总结
- 6.1 builder模式优点
- 6.2 builder模式缺点
- 7.关于其他说明
- 7.1 参考案例
- 8.关于其他更多内容
0.本人写的综合案例
- 案例
- 说明及截图
- 模块：新闻，音乐，视频，图片，唐诗宋词，快递，天气，记事本，阅读器等等
- 接口：七牛，阿里云，天行，干货集中营，极速数据，追书神器等等
1.Builder模式介绍
1.1 定义： 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的展示。
1.2 Builder模式属于创建型，一步一步将一个复杂对象创建出来，允许用户在不知道内部构建细节的情况下，可以更精细地控制对象的构造流程。
2.Builder模式使用场景
相同方法，不同执行顺序，产生不同事件结果
初始化对象特别复杂，参数众多，且很多参数都具有默认值时
3.Builder模式简单案例
3.1 Builder模式UML图(摘自网络)
3.2 在《Android源码设计模式》这本书上，介绍经典Builder模式中，包括
- Product : 产品抽象类
- Builder : 抽象Builder类，规范产品组建，一般是由子类实现具体的组建过程
- ConcreteBuilder : 具体的Builder类
- Director : 统一组装过程
3.3 Product角色
//设置抽象类
public abstract class BuilderUser {··
protected String name;
protected String cardID;
protected int age;
protected String address;
public BuilderUser() {}
//设置名字
public void setName(String name) {
this.name = name;
}
//抽象方法
public abstract void setCardID();
//设置年龄
public void setAge(int age) {
this.age = age;
}
//设置地址
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "BuilderUser{" +
"name='" + name + ''' +
", cardID='" + cardID + ''' +
", age=" + age +
", address='" + address + ''' +
'}';
}
}
/**
* 具体的Product角色 UserCard
*/
public class UserCard extends BuilderUser {
public UserCard() {}
@Override
public void setCardID() {
cardID="10086"; //设置默认ID
}
}
3.4 Builder : 抽象Builder类，规范产品组建，一般是由子类实现具体的组建过程
/**
* 抽象Builder类
*/
public abstract class Builder {
public abstract void buildName(String name);
public abstract void buildCardID();
public abstract void buildAge(int age);
public abstract void buildAddress(String address);
public abstract BuilderUser create();
}
3.5 ConcreteBuilder : 具体的Builder类
/**
* 具体的Builder类
*/
public class AccountBuilder extends Builder{
private BuilderUser user = new UserCard();
@Override
public void buildName(String name) {
user.setName(name);
}
@Override
public void buildCardID() {
user.setCardID();
}
@Override
public void buildAge(int age) {
user.setAge(age);
}
@Override
public void buildAddress(String address) {
user.setAddress(address);
}
@Override
public BuilderUser create() {
return user;
}
}
3.6 Director : 统一组装过程
/**
* Director角色，负责构造User
*/
public class Director {
Builder mBuilder =null;
public Director(Builder builder){
this.mBuilder =builder;
}
public void construct(String name,int age,String address){
mBuilder.buildName(name);
mBuilder.buildCardID();
mBuilder.buildAge(age);
mBuilder.buildAddress(address);
}
}
4.Builder模式实际案例Demo
4.1 实际开发中，有时会遇到复杂的对象的代码，比如
public class BuilderDemo {
private final String name; //必选
private final String cardID; //必选
private final int age; //可选
private final String address; //可选
private final String phone; //可选
}
4.2 通过构造函数的参数形式去写一个实现类，或者通过set，get去实现
BuilderDemo(String name);
BuilderDemo(String name, String cardID);
BuilderDemo(String name, String cardID,int age);
BuilderDemo(String name, String cardID,int age, String address);
BuilderDemo(String name, String cardID,int age, String address，String phone);
4.3 分析
- 第一种在参数不多的情况下，是比较方便快捷的，一旦参数多了，代码可读性大大降低，并且难以维护，对调用者来说也造成一定困惑；
- 第二种可读性不错，也易于维护，但是这样子做对象会产生不一致的状态，当你想要传入全部参数的时候，你必需将所有的setXX方法调用完成之后才行。然而一部分的调用者看到了这个对象后，以为这个对象已经创建完毕，就直接使用了，其实User对象并没有创建完成，另外，这个User对象也是可变的，不可变类所有好处都不复存在。
- Builder模式同时满足上面两种情况，易于维护，并且创建方便
4.4 将上面例子改成builder模式如下所示
public class BuilderDemo {
private final String name; //必选
private final String cardID; //必选
private final int age; //可选
private final String address; //可选
private final String phone; //可选
public BuilderDemo(UserBuilder userBuilder){
this.name=userBuilder.name;
this.cardID=userBuilder.cardID;
this.age=userBuilder.age;
this.address=userBuilder.address;
this.phone=userBuilder.phone;
}
public static class UserBuilder{
private final String name;
private final String cardID;
private int age;
private String address;
private String phone;
public BuilderDemo build(){
return new BuilderDemo(this);
}
public UserBuilder(String name,String cardID){
this.name=name;
this.cardID=cardID;
}
public UserBuilder age(int age){
this.age=age;
return this;
}
public UserBuilder address(String address){
this.address=address;
return this;
}
public UserBuilder phone(String phone){
this.phone=phone;
return this;
}
}
}
4.5 最后运用，代码如下
new BuilderDemo.UserBuilder("yc","10086")
.age(24)
.address("beijing")
.phone("13667225184")
.build();
4.6 关于线程安全问题
// 线程安全
public BuilderDemo build(){
BuilderDemo builderDemo = new BuilderDemo(this);
if(builderDemo.age > 100){
throw new IllegalStateException("Age out of range");
}
return builderDemo;
}
// 线程不安全，不要这样写
public BuilderDemo build(){
if(age > 100){
throw new IllegalStateException("Age out of range");
}
return new BuilderDemo(this);
}
5.Android源码中的Builder模式实现
5.1 首先看看AlertDialog.Builder源代码，只是摘自部分代码
public class AlertDialog extends AppCompatDialog implements DialogInterface {
//接收builder成员变量p中各个参数
final AlertController mAlert;
//下面是三个构造函数
protected AlertDialog(@NonNull Context context) {
this(context, 0);
}
protected AlertDialog(@NonNull Context context, @StyleRes int themeResId) {
super(context, resolveDialogTheme(context, themeResId));
mAlert = new AlertController(getContext(), this, getWindow());
}
protected AlertDialog(@NonNull Context context, boolean cancelable,
@Nullable OnCancelListener cancelListener) {
this(context, 0);
setCancelable(cancelable);
setOnCancelListener(cancelListener);
}
//事件上这里调用了是mAlert的setView方法
public void setView(View view) {
mAlert.setView(view);
}
public void setView(View view, int viewSpacingLeft, int viewSpacingTop, int viewSpacingRight,
int viewSpacingBottom) {
mAlert.setView(view, viewSpacingLeft, viewSpacingTop, viewSpacingRight, viewSpacingBottom);
}
public static class Builder {
//这个里面存放很多参数
private final AlertController.AlertParams P;
//这个是new AlertDialog.Builder(context,R.style.AppTheme)调用的方法
public Builder(@NonNull Context context, @StyleRes int themeResId) {
P = new AlertController.AlertParams(new ContextThemeWrapper(
context, resolveDialogTheme(context, themeResId)));
mTheme = themeResId;
}
//这部分代码省略很多，主要是set设置各种参数
public Builder setTitle(@Nullable CharSequence title) {
P.mTitle = title;
return this;
}
//这部分代码省略很多，主要是set设置各种参数
public Builder setView(int layoutResId) {
P.mView = null;
P.mViewLayoutResId = layoutResId;
P.mViewSpacingSpecified = false;
return this;
}
//构建dialog，传递参数
public AlertDialog create() {
final AlertDialog dialog = new AlertDialog(P.mContext, mTheme);
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;
}
//展示dialog
public AlertDialog show() {
final AlertDialog dialog = create();
dialog.show();
return dialog;
}
}
}
5.2 接下来看看build源代码
- 其中P是一个保存设置AlterDialog的参数类AlertParams的对象。很显然，Builder只是将AlterDialog的参数存放在一个参数对象里，做一个暂时的保存。在最后调用create方法的时候，创建一个AlterDialog对象，将暂存的参数P一次性应用到这个Dialog对象上。完成Dialog的创建。
当然，这只是创建AlertDialog，还没show出来。可以直接调用刚创建的AlertDialog的show()方法（实际为调用父类Dialog的show（）），也可以在构建完Builder之后直接调用Builder的show方法
public AlertDialog create() {
//创建
final AlertDialog dialog = new AlertDialog(P.mContext, mTheme);
//这一步很重要，下面会单独分析
P.apply(dialog.mAlert);
//设置是否可以取消，默认是true
dialog.setCancelable(P.mCancelable);
if (P.mCancelable) {
dialog.setCanceledOnTouchOutside(true);
}
//设置取消监听
dialog.setOnCancelListener(P.mOnCancelListener);
//设置dialog关闭后监听
dialog.setOnDismissListener(P.mOnDismissListener);
//设置返回键监听
if (P.mOnKeyListener != null) {
dialog.setOnKeyListener(P.mOnKeyListener);
}
//返回对象，创建成功
return dialog;
}
5.3 接下来看看show的代码
public void show() {
//如果弹窗已经show出来了
if (mShowing) {
//如果顶级view存在则设置窗口window，并显示顶级View
if (mDecor != null) {
if (mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
mWindow.invalidatePanelMenu(Window.FEATURE_ACTION_BAR);
}
mDecor.setVisibility(View.VISIBLE);
}
return;
}
mCanceled = false;
//如果窗口还未被创建
if (!mCreated) {
dispatchOnCreate(null);
}
//获得Windowd的顶级View，并将其添加到对应的WindowManager中，然后发送show的消息
onStart();
//获取DecorView
mDecor = mWindow.getDecorView();
if (mActionBar == null && mWindow.hasFeature(Window.FEATURE_ACTION_BAR)) {
final ApplicationInfo info = mContext.getApplicationInfo();
mWindow.setDefaultIcon(info.icon);
mWindow.setDefaultLogo(info.logo);
mActionBar = new WindowDecorActionBar(this);
}
//获取布局参数
WindowManager.LayoutParams l = mWindow.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
nl.copyFrom(l);
nl.softInputMode |=
WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
l = nl;
}
try {
//将mDecor添加到WindowManager中
mWindowManager.addView(mDecor, l);
mShowing = true;
//发送一个显示Dialog消息
sendShowMessage();
} finally {
}
}
- 在show函数中主要做了如下的事情：
(1)通过dispatchOnCreate函数来调用AlertDialog的onCreate函数
(2)然后接着调用onStart函数
(3)最后将Dialog的mDecor添加到WindowManager中(有点不明白这里，为什么要获取到最顶部的布局)
5.4 为什么AlertDialog要使用builder模式呢？
- AlterDialog有很多的参数，如我们上面列举的title，message，三个button及其回调，除此以外还有icon，View等属性。如果Android不采用Builder，而采用普通的构造函数来设计AlterDialog，可能要写出很多类似于如下的构造函数：
AlertDialog(String title);
AlertDialog(String message)
AlertDialog(int resId)
AlertDialog(int resId, String title, String message);
AlterDialog(int resId, String title, String message, String PositiveButtonString, OnClickListener listener);
AlterDialog(int resId, String title, String message, String PositiveButtonString, OnClickListener listener);
AlterDialog(int resId, String title, String message, String NegativeButtonString, OnClickListener listener);
AlterDialog(int resId, String title, String message, String PositiveButtonString, OnClickListener listener, String NegativeButtonString, OnClickListener listener);
....
6.Builder模式总结
6.1 Builder模式有几个好处：
- Builder的setter函数可以包含安全检查，可以确保构建过程的安全，有效。
- Builder的setter函数是具名函数，有意义，相对于构造函数的一长串函数列表，更容易阅读维护。
- 可以利用单个Builder对象构建多个对象，Builder的参数可以在创建对象的时候利用setter函数进行调整
6.2 当然Builder模式也有缺点：
- 更多的代码，需要Builder这样的内部类
- 增加了类创建的运行时开销 ，但是当一个类参数很多的时候，Builder模式带来的好处要远胜于其缺点。
7.关于其他说明
7.1 参考案例
8.关于其他更多内容
