构建者模式在android端中的实际应用

试想一种需求，有一个简单的Bean类，Bean类里有10个属性，但是我们初始化的时候仅仅想设置2个属性，可能会想到构造函数，但是如果需求升级，让我们设置4个，6个属性，如果用构造函数那代码会过于臃肿，此外频繁的set设置属性，调用的地方代码也比较多且可读性不太好，在这时候可以采用构建者模式了。

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

经典构建者模式有以下几个角色：

构建者角色、指导者、产品角色。

构建者模式的优缺点：

在创建者模式中，客户端不再负责对象的创建与组装，而是把这个对象创建的责任交给其具体的创建者类，把组装的责任交给组装类，客户端只负责对象的调用，从而明确了各个类的职责。

虽然利用创建者模式可以创建出不同类型的产品，但是如果产品之间的差异巨大，则需要编写多个创建者类才能实现，如果这是结合工厂模式更好。

我们以汉堡包为例，通过代码说下构建者模式：

1.产品抽象角色：

/**
 * 经典构建者模式-产品抽象角色
 * Created by wangmaobo on 2019/3/25.
 */
public abstract class HamBurg {
    protected String bread;
    protected String vegetable;
    protected float prize;

    public void setBread(String name) {
        this.bread = name;
    }

    public abstract void setPrize();

    public void setVegetable(String vegetable) {
        this.vegetable = vegetable;
    }

    @Override
    public String toString() {
        return "HamBurg{" +
                "bread='" + bread + '\'' +
                ", vegetable='" + vegetable + '\'' +
                ", prize='" + prize + '\'' +
                '}';
    }
}

2.产品具体角色：

/**
 * 经典构建者模式-具体构建者类
 * Created by wangmaobo on 2019/3/25.
 */
public class ChineseHamBugeBuilder extends Builder {
    private HamBurg mHamBurg = new ChineseHamBurg();

    @Override
    public void buildBread(String bread) {
        mHamBurg.setBread(bread);
    }

    @Override
    public void buildVegetable(String vegetable) {
        mHamBurg.setVegetable(vegetable);
    }

    @Override
    public void buildPrize() {
        mHamBurg.setPrize();
    }

    @Override
    public HamBurg create() {
        return mHamBurg;
    }
}

3.抽象构建者角色：

/**
 * 经典构建者模式-抽象构建者类
 * Created by wangmaobo on 2019/3/25.
 */
public abstract class Builder {
    public abstract void buildBread(String bread);

    public abstract void buildVegetable(String vegetable);

    public abstract void buildPrize();

    public abstract HamBurg create();

}

4.具体构建者角色：

/**
 * 经典构建者模式-具体构建者类
 * Created by wangmaobo on 2019/3/25.
 */
public class ChineseHamBugeBuilder extends Builder {
    private HamBurg mHamBurg = new ChineseHamBurg();

    @Override
    public void buildBread(String bread) {
        mHamBurg.setBread(bread);
    }

    @Override
    public void buildVegetable(String vegetable) {
        mHamBurg.setVegetable(vegetable);
    }

    @Override
    public void buildPrize() {
        mHamBurg.setPrize();
    }

    @Override
    public HamBurg create() {
        return mHamBurg;
    }
}

5.导演角色：

/**
 * 经典构建者模式-导演组装类
 * Created by wangmaobo on 2019/3/25.
 */
public class Director {
    Builder mBuilder;

    public Director(Builder builder) {
        mBuilder = builder;
    }

    public Builder construct(String bread, String vegetable) {
        mBuilder.buildBread(bread);
        mBuilder.buildVegetable(vegetable);
        mBuilder.buildPrize();
        return mBuilder;
    }
}

调用：

        Builder builder = new ChineseHamBugeBuilder();
        Director director = new Director(builder);
        director.construct("chinese bread", "carrot");
        HamBurg hamBurg = builder.create();
        Log.e("classic hamburg", "中国汉堡包信息：" + hamBurg.toString());

实际上，我们可以将经典构建者模式进行适当调整，在没有批量处理的需求下，调用更加方便。

将构建者角色类稍加改进：

/**
 * 经典构建者模式-具体构建者类
 * Created by wangmaobo on 2019/3/25.
 */
public class ChineseHamBugeBuilder extends Builder {
    private HamBurg mHamBurg = new ChineseHamBurg();

    @Override
    public Builder buildBread(String bread) {
        mHamBurg.setBread(bread);
        return this;
    }

    @Override
    public Builder buildVegetable(String vegetable) {
        mHamBurg.setVegetable(vegetable);
        return this;
    }

    @Override
    public Builder buildPrize() {
        mHamBurg.setPrize();
        return this;
    }

    @Override
    public HamBurg create() {
        return mHamBurg;
    }
}

调用：

HamBurg hamBurg1 = new ChineseHamBugeBuilder()
                .buildBread("chinese bread")
                .buildVegetable("carrot")
                .buildPrize()
                .create();
Log.e("improve hamburg", "中国汉堡" + hamBurg1.toString());

实际上我们还可以省去抽象类，及导演类，将构建者Builder类作为产品的内部类，类似实现的比如开源框架Retrofit，具体调用：

            OkHttpClient.Builder builder = new OkHttpClient.Builder()
                    .connectTimeout(15, TimeUnit.SECONDS)
                    .readTimeout(20, TimeUnit.SECONDS)
                    .writeTimeout(20, TimeUnit.SECONDS)
                    .retryOnConnectionFailure(false)
                    .addInterceptor(interceptor);
            OkHttpClient client = builder.build();
            retrofitInstance = new Retrofit.Builder()
                    .baseUrl(BASEURL)
                    .client(client)
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();

当然实际项目开发中我们甚至可以省略构建者角色，参考RxJava的链式调用风格，将所需要的属性设置直接放到产品角色类里面，比如之前我封装过的万能适配器的ViewHolder类：

public class ViewHolder extends RecyclerView.ViewHolder {
        private final SparseArray<View> mViews;
        private View itemView;

        public ViewHolder(View itemView) {
            super(itemView);
            mViews = new SparseArray<>();
            this.itemView = itemView;
            this.itemView.setOnClickListener(v -> {
                onItemClick(getAdapterPosition());
                if (mOnItemClickListener != null)
                    setOnItemClick(v, getAdapterPosition());
            });
            setTextChangedListener(this, itemView);
            setRatingBarListener(this, itemView);
        }

        public <T extends View> T getView(int viewId) {
            View view = mViews.get(viewId);
            if (view == null) {
                view = itemView.findViewById(viewId);
                mViews.put(viewId, view);
            }
            return (T) view;
        }

        public ViewHolder setText(int viewId, String text) {
            if (TextUtils.isEmpty(text)) {
                text = "";
            }
            TextView tv = getView(viewId);
            tv.setText(text);
            return this;
        }

        /**
         * 如果text为空，显示“--”
         *
         * @param viewId
         * @param text
         * @return
         */
        public ViewHolder setTextNotNull(int viewId, String text) {
            if (TextUtils.isEmpty(text)) {
                text = "--";
            }
            TextView tv = getView(viewId);
            tv.setText(text);

            return this;
        }

        public ViewHolder setTextHint(int viewId, String hint) {
            if (TextUtils.isEmpty(hint)) {
                return this;
            }
            TextView tv = getView(viewId);
            tv.setHint(hint);
            return this;
        }

        public ViewHolder setBackground(int viewId, int drawableId) {
            View view = getView(viewId);
            view.setBackground(mContext.getResources().getDrawable(drawableId));
            return this;
        }

        /**
         * 如果text为空，控件隐藏
         *
         * @param viewId
         * @param text
         * @return
         */
        public ViewHolder setTextAndView(int viewId, String text) {
            TextView tv = getView(viewId);
            if (TextUtils.isEmpty(text)) {
                tv.setVisibility(View.GONE);
            } else {
                tv.setText(text);
                tv.setVisibility(View.VISIBLE);
            }
            return this;
        }

        public ViewHolder setProjectName(int viewId, String text) {
            TextView tv = getView(viewId);
            if (CommonUtils.IsNull(Constant.project_id) && !CommonUtils.IsNull(text)) {
                tv.setVisibility(View.VISIBLE);
                tv.setText(text);
            } else {
                tv.setVisibility(View.GONE);
            }
            return this;
        }

        public ViewHolder setTextColor(int viewId, int textColorId) {
            TextView tv = getView(viewId);
            tv.setTextColor(textColorId);
            return this;
        }

        public ViewHolder setImage(int viewId, Object params) {
            ImageView iv = getView(viewId);
            if (params instanceof String) {
                //自己写加载图片的逻辑-默认的加载模式
                GlideUtils.loadImageViewCircle(mContext, params.toString(),
                        getView(viewId), R.mipmap.image_loading_icon);
            } else if (params instanceof Integer) {
                iv.setImageResource((int) params);
            } else if (params instanceof Bitmap) {
                iv.setImageBitmap((Bitmap) params);
            } else if (params instanceof Drawable) {
                iv.setImageDrawable((Drawable) params);
            } else {
                try {
                    throw new Exception("params is wrong!");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return this;
        }

        public ViewHolder setCircleImage(int viewId, String url, String name) {
            GlideUtils.loadHeadImg(mContext, url, name, getView(viewId));
            return this;
        }

        public ViewHolder setClickListener(int viewId) {
            View v = getView(viewId);
            v.setOnClickListener(v1 -> onSingleViewClick(v1, getAdapterPosition()));
            return this;
        }

        public ViewHolder setVisible(int viewId) {
            View v = getView(viewId);
            v.setVisibility(View.VISIBLE);
            return this;
        }

        public ViewHolder setInVisible(int viewId) {
            View v = getView(viewId);
            v.setVisibility(View.GONE);
            return this;
        }

        public int getCurrentPosition() {
            return getAdapterPosition();
        }

    }

调用举例：

holder.setTextNotNull(R.id.tv_introduce, content.eventTitle)
        .setTextNotNull(R.id.tv_urgency, content.urgentName)
        .setTextNotNull(R.id.tv_question, content.eventDescribe)
        .setTextNotNull(R.id.tv_createPerson, "创建人")
        .setTextNotNull(R.id.tv_createTime, create_time)
        .setTextNotNull(R.id.tv_startTime, start_time)
        .setTextNotNull(R.id.tv_endTime, end_time)
        .setTextNotNull(R.id.tv_notice, content.eventStateName)
        .setTextNotNull(R.id.tv_work_type, content.eventSourceName);

项目中能用到此模式的地方举例：

1.自定义View里，可以选择性的组装View的属性，避免了各种构造函数的创建；

2.各种Bean类里，比如EventBusBean，数据Bean类；

3.实现某一个大的功能的框架。

ps：开发模式是死的，人是活的，任何一种设计模式都有其优缺点，我们可以根据自己的产品需求，获取其优点，让开发效率及代码可读性更高一点，尽可能“取其精华，去其糟粕”。