Jianwoo中的设计模式（5） — 模板方法模式

前言

在我们写一个app的时候，会有几个甚至十几个或者几十个上百个界面，我们不断的写新界面的时候，会发现，有那么一部分代码似乎流程是一样的，比如setContentView、findViewById、setListeners等等等等，而我们每次都要写一个init方法去写这些重复的方法，而且说不定不同的人在写Activity的时候，明天这些大家都要走的流程可以统一规范，但却可能因为个人习惯或者代码风格问题，把方法、位置定义的五彩缤纷，这个时候模板方法模式，就显得非常重要了，现在我们先针对这种情况下的问题进行探讨和解决，看看用模板方法模式有什么妙处

认知

在了解模板模式之前，你得对Java的抽象有一个基本的了解，一般被abstract修饰的方法或者class我们称之为抽象类，抽象类中不一定有抽象方法，但是抽象方法必须是存在于抽象类，当然抽象类也可以有具体方法存在，抽象类可以不用写具体的实现方法，而通过子类继承来重写抽象方法，那这有什么好处呢，我们在设计一个产品功能的时候，如果预先想到不同的子产品具有一系列相同的行为属性和流程，那我们可以给这个产品建立一个抽象类模型来走完产品流程，而具体的行为属性方法，可以交给子产品去做具体实现，这样既可以规范产品流程也可以减少子产品写多余的代码，这就是抽象的过程

简物中的应用场景1

那在简物中什么场景应用到抽象方法模式呢，在前言我们已经聊到了，我们在写Activity的时候，很多流程是通用的，我们可以把这些流程抽象到父类，让子类去做具体实现

public abstract class BaseActivity extends AppCompatActivity{

    protected Category category;

    protected boolean firstRunning = true;

    ...

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        init();
    }

    protected void init(){
        setActivityParams();
        setContentView();
    }

    @Override
    protected void onStart() {
        super.onStart();
        /**
         * 初始化数据，网络请求放在onStart以提高界面加载速度
         */
        if(firstRunning){
            initCategory();
            firstRunning = false;
            ...
        }
    }

    /**
     * 设置Activity的根布局
     */
    protected abstract void setContentView();

    /**
     * UI绑定/监听器初始化/UI设置监听
     */
    protected abstract void initCategory();

   ....

}

我们看到上面有一个Category类，这个类是干啥用的，在关于简物的项目分析一文中我做了详细的介绍，这里就不多讲了，category负责了UI逻辑部分的初始化、设置监听、更新UI等操作

public abstract class Category{

    protected Listener listener;
    protected BaseActivity activity;

    ...

    public Category(BaseActivity activity){
        this.activity = activity;
        this.app = activity.getApp();
        prepare();
        findViews();
        initListener();
        setListener();
        initViews();
        init();
        setTitlePadding();
    }

   /**
     * 预初始化
     */
    protected abstract void prepare();

    /**
     * 绑定控件
     */
    protected abstract void findCategoryViews();

    /**
     * 初始化监听器Listener
     */
    protected abstract void initThisListener();

    /**
     * 设置UI控件的监听
     */
    protected abstract void setThisListener();

    /**
     * 初始化数据
     */
    protected abstract void init();

    /**
     * 初始化UI
     */
    protected abstract void initViews();

   ...

}

好，我们先写这两个抽象父类，那我们在使用的时候就怎样的呢，这里拿收藏列表做例子

/**
 * Created by Barry on 2017/4/16.
 * 我的收藏
 */
public class CollectActivity extends BaseActivity {

    @Override
    protected void setContentView() {
        setContentView(R.layout.activity_collect);
    }

    @Override
    protected void initCategory() {
        category = new CollectCategory(this);
    }

    ...

}

CollectCategory继承抽象流程类Category，并且实现抽象方法

/**
 * Created by Barry on 2017/4/16.
 * 我的收藏列表
 */
public class CollectCategory extends Category {

    @Bind(R.id.ptr_layout)
    PtrFrameLayout mPtrFrameLayout;

    MyCollectAdapter mDailyAdapter;
    @Bind(R.id.recyclerview)
    LoadMoreRecyclerView mRecyclerView;

    MyCollectModel mMyCollectModel;

    public CollectCategory(BaseActivity activity) {
        super(activity);
    }

    @Override
    protected void prepare() {
        initAdapater();
        initMyCollectModel();
    }

    @Override
    protected void findCategoryViews() {
        ButterKnife.bind(this, getActivity());
    }

    @Override
    protected void initThisListener() {
        listener = new CollectListener(this);
    }

    @Override
    protected void setThisListener() {
        mRecyclerView.setOnRefreshEndListener((CollectListener)listener);
    }

    @Override
    protected void init() {
        onRefresh();
    }

    @Override
    protected void initViews() {
        initPtrLayout(mPtrFrameLayout);
        initRecyclerView();
    }

    private void initRecyclerView(){
        mRecyclerView.setLayoutManager(new StaggeredGridLayoutManager(2, StaggeredGridLayoutManager.VERTICAL));
        mRecyclerView.setItemAnimator(new FadeInAnimator());
        mRecyclerView.getItemAnimator().setRemoveDuration(300);
        mRecyclerView.getItemAnimator().setAddDuration(300);
        mRecyclerView.getItemAnimator().setChangeDuration(300);
        mRecyclerView.getItemAnimator().setMoveDuration(300);
        mRecyclerView.setAdapter(mDailyAdapter);
    }

    private void initAdapater(){
        mDailyAdapter = new MyCollectAdapter(getActivity(), new ArrayList());
    }

    private void initMyCollectModel(){
        mMyCollectModel = new MyCollectModelImpl(new MyCollectView() {
            @Override
            public void getMyCollectSuccess(List goods) {
                mDailyAdapter.notifyDataSetChanged(goods);
                loadComplete();
            }

            @Override
            public void getMyCollectLoadmoreSuccess(List goods) {
                if(isEmpty(goods)){
                    mRecyclerView.onFinish();
                }
                mDailyAdapter.notifyDataSetChangedLoadmore(goods);
                loadComplete();
            }

            @Override
            public void getMyCollectError(String message) {
                loadComplete();
            }

            @Override
            public void networkError(String message) {
                loadComplete();
            }
        });
    }

    public void loadComplete(){
        mPtrFrameLayout.refreshComplete();
        mRecyclerView.loadComplete();
    }

    public void onRefresh(){
        if(LoginFactory.isUserLogin()){
            mRecyclerView.onRefresh();
            mMyCollectModel.getMyCollectGoods(PageSize.START, PageSize.BASE_PAGE_SIZE, getUserUuid());
            return;
        }
        loadComplete();
        LoginFactory.login(getActivity());
    }

    public void onLoadMore(){
        if(mRecyclerView.isLoadmoreAvailable() && mDailyAdapter != null && mDailyAdapter.getItemCount() > 0){
            mMyCollectModel.getMyCollectGoods(mDailyAdapter.getItemCount(), PageSize.BASE_PAGE_SIZE, getUserUuid());
        }
    }

    public boolean checkCanDoRefresh(PtrFrameLayout frame, View content, View header) {
        return mRecyclerView.isRefreshAble();
    }

    public void onRefreshBegin(PtrFrameLayout frame) {
        onRefresh();
    }

有发现什么吗，主要流程我均是通过实现抽象类的方法去完成的，也就是我只要往对应的方法里去填坑就好，那这是不是意味着，对于一个新人开发者，只要了解这套流程逻辑，那即使他的代码水平或者局部风格和我们不一致也是可以和我们统一流程，不管谁去维护这部分代码，至少主要初始化流程不会走错！可以快速定位出错大致位置，如果做过后端你会发现，很多框架，比如我做后端用的Laravel，他对于不同层的代码封装的非常好，你只要对应在不同的层写类去继承它的父类然后做对应的实现就好了，这会大大减少一个人上手你项目的成本，一个业务线上的程序猿应该把时间花在专心实现功能上，而不是去花在明明可以统一流程却初始化顺序和结构都不一致的代码上，模板方法模式也是提高开发效率的一种

当然，模板方法模式并非一定是开发一个项目必选的，这得适应不同的应用场景，如果项目是组件化开发，那就不一定所有人都要统一这套规范，这更适应应该是模块化开发

那在开发组件模块的时候我们又在什么地方会用到模板模式呢

简物中的应用场景2

对于一些界面常出现的无网络、无数据等通用界面，可以封装成模块供不同的Activity使用，而无网络、无数据等界面又具有相同的特征：显示缺省图片、显示缺省标题、可以点击重试，那我们同样可以用模板模式进行封装一个EmptyView

/**
 * Created by Barry on 2017/3/21.
 */
public abstract class BaseEmptyView {

    /**
     * 用于绑定控件的父容器，这里不一定是Activity或者Fragment中的view，那我们传入一个Object，后面做判断
     */
    Object mTarget;

    View mContentView;

    QHImageView mImage;

    TextView mTitle;
    public BaseEmptyView(Object target) {
        this.mTarget = target;
        findViews();
        init();
    }

    private void findViews(){
        if(BaseUtils.isEmpty(getContentView())){
            throw new NullPointerException("parent view is null.");
        }
        mContentView = getContentView().findViewById(getLayoutId());
        mImage = (QHImageView) getContentView().findViewById(getImageId());
        mTitle = (QHTextView) getContentView().findViewById(getTitleId());
    }

    private void init(){
        mContentView.setVisibility(View.GONE);
        initImageParams();
        hide();
    }

    private void initImageParams(){
        int marginTop = (BaseUtils.getHeight() - BaseUtils.getStatusBarHeight() - BaseUtils.dip2px(45)) / 2 - getImageHeight();
        LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(getImageWidth(), getImageHeight());
        params.setMargins(0, marginTop, 0, 0);
        mImage.setLayoutParams(params);
        mImage.setImageURI(BaseUtils.fromRes(getImageRes()));
    }

    /**
     * 不同缺省页不同的布局id
     * @return
     */
    protected abstract int getLayoutId();

    /**
     * 图片控件id
     * @return
     */
    protected abstract int getImageId();

    /**
     * 标题控件id
     * @return
     */
    protected abstract int getTitleId();

    /**
     * 图片资源
     * @return
     */
    protected abstract int getImageRes();

    public int getImageWidth(){
        return BaseUtils.getWidth() / 3;
    }

    public int getImageHeight(){
        return getImageWidth();
    }

    public void show(){
        mContentView.setVisibility(View.VISIBLE);
    }

    public void hide(){
        mContentView.setVisibility(View.GONE);
    }

    public View getContentView(){
        if(mTarget instanceof Activity){
            ViewGroup group = (ViewGroup)((Activity)mTarget).getWindow().getDecorView();
            FrameLayout layout = (FrameLayout)group.findViewById(android.R.id.content);
            return layout.getChildAt(0);
        }

        if(mTarget instanceof View){
            return (View)mTarget;
        }
        return null;

    }

}

比如我们现在在消息中心界面有一个暂无消息的界面提示

public class EmptyMessage extends BaseEmptyView {

    public EmptyMessage(Object mContentView) {
        super(mContentView);
    }

    @Override
    protected int getLayoutId() {
        return R.id.empty_message_layout;
    }

    @Override
    protected int getImageId() {
        return R.id.empty_message;
    }

    @Override
    protected int getTitleId() {
        return R.id.empty_message_title;
    }

    @Override
    protected int getImageRes() {
        return R.mipmap.empty_message;
    }
}

惊不惊喜意不意外，我只要复写几个提供参数的方法就可以快速的实现一套缺省界面的逻辑，那我们怎么调用呢

public class MessageCategory extends Category {

    EmptyMessage mEmptyMessage;

    public MessageCategory(BaseActivity activity) {
        super(activity);
    }

    @Override
    protected void prepare() {
        mEmptyMessage = new EmptyMessage(getActivity());
    }

    @Override
    protected void findCategoryViews() {
        ButterKnife.bind(this, getActivity());
    }

    @Override
    protected void initThisListener() {
        listener = new MessageListener(this);
    }

    @Override
    protected void setThisListener() {

    }

    @Override
    protected void init() {

    }

    @Override
    protected void initViews() {
    }

    public void showEmptyView(){
        mEmptyMessage.show();
    }

}

在请求失败的回调中，调用showEmptyView就可以显示无消息的界面啦，是不是非常方便…

关于模板方法模式就说到这里啦，现在你们应该对模板方法模式有了一个大概的了解，还是那句话，如果喜欢这篇文章，希望不要吝啬给个Like哦