Android模板设计模式之 - 构建整个应用的BaseActivity

1. 模式介绍

模式的定义

定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

所有分享大纲：2017Android进阶之路与你同行

视频讲解地址：http://pan.baidu.com/s/1nuNA0Vv

模式的使用场景

1. 多个子类有公有的方法，并且逻辑基本相同时。
2. 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
3. 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。

2. UML类图

uml.png

角色介绍

• AbstractClass : 抽象类，定义了一套算法框架。
• ConcreteClass1 : 具体实现类1；
• ConcreteClass2： 具体实现类2；

3. 模式的简单实现

简单实现的介绍
模板方法实际上是封装一个算法框架，就像是一套模板一样。而子类可以有不同的算法实现，在框架不被修改的情况下实现算法的替换。下面我们以开电脑这个动作来简单演示一下模板方法。开电脑的整个过程都是相对稳定的，首先打开电脑电源，电脑检测自身状态没有问题时将进入操作系统，对用户进行验证之后即可登录电脑，下面我们使用模板方法来模拟一下这个过程。

实现源码

1package com.dp.example.templatemethod;
2
3/**
4 * 抽象的Computer
5 * @author mrsimple
6 *
7 */
8public abstract class AbstractComputer {
9
10    protected void powerOn() {
11        System.out.println("开启电源");
12    }
13
14    protected void checkHardware() {
15        System.out.println("硬件检查");
16    }
17
18    protected void loadOS() {
19        System.out.println("载入操作系统");
20    }
21
22    protected void login() {
23        System.out.println("小白的电脑无验证，直接进入系统");
24    }
25
26    /**
27     * 启动电脑方法, 步骤固定为开启电源、系统检查、加载操作系统、用户登录。该方法为final， 防止算法框架被覆写.
28     */
29    public final void startUp() {
30        System.out.println("------ 开机 START ------");
31        powerOn();
32        checkHardware();
33        loadOS();
34        login();
35        System.out.println("------ 开机 END ------");
36    }
37}
38
39
40package com.dp.example.templatemethod;
41
42/**
43 * 码农的计算机
44 * 
45 * @author mrsimple
46 */
47public class CoderComputer extends AbstractComputer {
48    @Override
49    protected void login() {
50        System.out.println("码农只需要进行用户和密码验证就可以了");
51    }
52}
53
54
55package com.dp.example.templatemethod;
56
57/**
58 * 军用计算机
59 * 
60 * @author mrsimple
61 */
62public class MilitaryComputer extends AbstractComputer {
63
64
65    @Override
66    protected void checkHardware() {
67        super.checkHardware();
68        System.out.println("检查硬件防火墙");
69    }
70
71    @Override
72    protected void login() {
73        System.out.println("进行指纹之别等复杂的用户验证");
74    }
75}
76
77
78package com.dp.example.templatemethod;
79
80public class Test {
81    public static void main(String[] args) {
82        AbstractComputer comp = new CoderComputer();
83        comp.startUp();
84
85        comp = new MilitaryComputer();
86        comp.startUp();
87
88    }
89} 

输出结果如下 :

1------ 开机 START ------
2开启电源
3硬件检查
4载入操作系统
5码农只需要进行用户和密码验证就可以了
6------ 开机 END ------
7------ 开机 START ------
8开启电源
9硬件检查
10检查硬件防火墙
11载入操作系统
12进行指纹之别等复杂的用户验证
13------ 开机 END ------ 

通过上面的例子可以看到，在startUp方法中有一些固定的步骤，依次为开启电源、检查硬件、加载系统、用户登录四个步骤，这四个步骤是电脑开机过程中不会变动的四个过程。但是不同用户的这几个步骤的实现可能各不相同，因此他们可以用不同的实现。而startUp为final方法，即保证了算法框架不能修改，具体算法实现却可以灵活改变。startUp中的这几个算法步骤我们可以称为是一个套路，即可称为模板方法。因此，模板方法是定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。如图 :

flow.png

4. Android源码中的模式实现

在Android中，使用了模板方法且为我们熟知的一个典型类就是AsyncTask了，关于AsyncTask的更详细的分析请移步Android中AsyncTask的使用与源码分析，我们这里只分析在该类中使用的模板方法模式。

在使用AsyncTask时，我们都有知道耗时的方法要放在doInBackground(Params... params)中，在doInBackground之前如果还想做一些类似初始化的操作可以写在onPreExecute方法中，当doInBackground方法执行完成后，会执行onPostExecute方法，而我们只需要构建AsyncTask对象，然后执行execute方法即可。我们可以看到，它整个执行过程其实是一个框架，具体的实现都需要子类来完成。而且它执行的算法框架是固定的，调用execute后会依次执行onPreExecute,doInBackground,onPostExecute,当然你也可以通过onProgressUpdate来更新进度。我们可以简单的理解为如下图的模式 :

async-flow.png

下面我们看源码，首先我们看执行异步任务的入口, 即execute方法 :

1public final AsyncTask<Params, Progress, Result> execute(Params... params) {
2        return executeOnExecutor(sDefaultExecutor, params);
3    }
4
5    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
6            Params... params) {
7        if (mStatus != Status.PENDING) {
8            switch (mStatus) {
9                case RUNNING:
10                    throw new IllegalStateException("Cannot execute task:"
11                            + " the task is already running.");
12                case FINISHED:
13                    throw new IllegalStateException("Cannot execute task:"
14                            + " the task has already been executed "
15                            + "(a task can be executed only once)");
16            }
17        }
18
19        mStatus = Status.RUNNING;
20
21        onPreExecute();
22
23        mWorker.mParams = params;
24        exec.execute(mFuture);
25
26        return this;
27    } 

可以看到execute方法(为final类型的方法)调用了executeOnExecutor方法，在该方法中会判断该任务的状态，如果不是PENDING状态则抛出异常，这也解释了为什么AsyncTask只能被执行一次，因此如果该任务已经被执行过的话那么它的状态就会变成FINISHED。继续往下看，我们看到在executeOnExecutor方法中首先执行了onPreExecute方法，并且该方法执行在UI线程。然后将params参数传递给了mWorker对象的mParams字段，然后执行了exec.execute(mFuture)方法。
mWorker和mFuture又是什么呢？其实mWorker只是实现了Callable接口，并添加了一个参数数组字段，我们挨个来分析吧，跟踪代码我们可以看到，这两个字段都是在构造函数中初始化。

1public AsyncTask() {
2        mWorker = new WorkerRunnable<Params, Result>() {
3            public Result call() throws Exception {
4                mTaskInvoked.set(true);
5
6                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
7                return postResult(doInBackground(mParams));
8            }
9        };
10
11        mFuture = new FutureTask<Result>(mWorker) {
12            @Override
13            protected void done() {
14                try {
15                    final Result result = get();
16
17                    postResultIfNotInvoked(result);
18                } catch (InterruptedException e) {
19                    android.util.Log.w(LOG_TAG, e);
20                } catch (ExecutionException e) {
21                    throw new RuntimeException("An error occured while executing doInBackground()",
22                            e.getCause());
23                } catch (CancellationException e) {
24                    postResultIfNotInvoked(null);
25                } catch (Throwable t) {
26                    throw new RuntimeException("An error occured while executing "
27                            + "doInBackground()", t);
28                }
29            }
30        };
31    } 

简单的说就是mFuture就包装了这个mWorker对象，会调用mWorker对象的call方法，并且将之返回给调用者。关于AsyncTask的更详细的分析请移步Android中AsyncTask的使用与源码分析，我们这里只分析模板方法模式。总之，call方法会在子线程中调用，而在call方法中又调用了doInBackground方法，因此doInBackground会执行在子线程。doInBackground会返回结果，最终通过postResult投递给UI线程。 我们再看看postResult的实现 :

1private Result postResult(Result result) {
2        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
3                new AsyncTaskResult<Result>(this, result));
4        message.sendToTarget();
5        return result;
6    }
7
8    private static class InternalHandler extends Handler {
9        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
10        @Override
11        public void handleMessage(Message msg) {
12            AsyncTaskResult result = (AsyncTaskResult) msg.obj;
13            switch (msg.what) {
14                case MESSAGE_POST_RESULT:
15                    // There is only one result
16                    result.mTask.finish(result.mData[0]);
17                    break;
18                case MESSAGE_POST_PROGRESS:
19                    result.mTask.onProgressUpdate(result.mData);
20                    break;
21            }
22        }
23    }
24
25
26    private void finish(Result result) {
27        if (isCancelled()) {
28            onCancelled(result);
29        } else {
30            onPostExecute(result);
31        }
32        mStatus = Status.FINISHED;
33    } 

可以看到，postResult就是把一个消息( msg.what == MESSAGE_POST_RESULT)发送给sHandler，sHandler类型为InternalHandler类型，当InternalHandler接到MESSAGE_POST_RESULT类型的消息时就会调用result.mTask.finish(result.mData[0])方法。我们可以看到result为AsyncTaskResult类型，源码如下 :

1 @SuppressWarnings({"RawUseOfParameterizedType"})
2    private static class AsyncTaskResult<Data> {
3        final AsyncTask mTask;
4        final Data[] mData;
5
6        AsyncTaskResult(AsyncTask task, Data... data) {
7            mTask = task;
8            mData = data;
9        }
10    } 

可以看到mTask就是AsyncTask对象，调用AsyncTask对象的finish方法时又调用了onPostExecute，这个时候整个执行过程就完成了。 总之，execute方法内部封装了onPreExecute, doInBackground, onPostExecute这个算法框架，用户可以根据自己的需求来在覆写这几个方法，使得用户可以很方便的使用异步任务来完成耗时操作，又可以通过onPostExecute来完成更新UI线程的工作。
另一个比较好的模板方法示例就是Activity的声明周期函数，例如Activity从onCreate、onStart、onResume这些程式化的执行模板，这就是一个Activity的模板方法。

5. 构建整个应用的BaseActivity

接下来我们看一下怎么才能用到开发中... 等等我要去举报你 --> 怎么啦？ 你抄袭别人的。怎么？被发现了吗，我这不是抄袭只是把好东西拿出来与大家分享而已，给大家推荐一下：https://github.com/simple-android-framework-exchange/android_design_patterns_analysis#schedule 里面有很多设计模式，最好大家可以买一本书看一下这么好的东西还是支持一下吧希望可以出一些更好的（虽然我看的是电子文档）。说到这里非常感谢大家的打赏虽然不多但是我内心真的很感谢，希望以后可以出更多好的文章。
　　在网上查了很多关于别人讲的模板设计模式，都是只简单的介绍一下概念然后写一个小的事例如：程序员的一天，银行办理业务等等等等。我最近剃了个光头，因为上班闲来无事看别人的博客的时候老是抓头发，一直都在想想我该用到哪里呢？哪里又能用到呢？.......所以干脆剃了个光头。

因为目前还是停留在内涵段子项目的系统架构部分，而且每个项目肯定离不开Activity，在Activity的onCreate()方法里面基本都是：设置布局 ->初始化头部 -> 初始化界面 -> 初始化数据。如果按照这么个流程是不是刚好符合我们模板设计模式。

1/**
2 * Created by Darren on 2017/2/8.
3 * Email: 240336124@qq.com
4 * Description: 整个应用的BaseActivity
5 */
6public abstract class BaseActivity extends AppCompatActivity {
7
8    @Override
9    protected void onCreate(@Nullable Bundle savedInstanceState) {
10        super.onCreate(savedInstanceState);
11        setContentView();
12        initTitle();
13        initView();
14        initData();
15    }
16
17    // 初始化数据
18    protected abstract void initData();
19
20    // 初始化界面
21    protected abstract void initView();
22
23    // 设置界面视图
24    protected abstract void setContentView();
25
26    // 初始化头部
27    protected abstract void initTitle();
28} 

以后我们每次新建Activity就不会直接继承自 AppCompatActivity 而是我们自己的BaseActivity就会自动要我们复写BaseActivity里面的几个抽象方法，我们在方法里面写对应的代码。

1/**
2 * Created by Darren on 2017/2/8.
3 * Email: 240336124@qq.com
4 * Description: 主页面MainActivity
5 */
6public class MainActivity extends BaseActivity {
7
8    @Override
9    protected void initData() {
10
11    }
12
13    @Override
14    protected void initView() {
15
16    }
17
18    @Override
19    protected void setContentView() {
20        setContentView(R.layout.activity_main);
21    }
22
23    @Override
24    protected void initTitle() {
25
26    }
27} 

这也没见到什么好处啊~好处我待会再来说，我们先对BaseActivity来扩展一下，一些通用的流程和功能其实可以放在BaseActivity里面，比如前几次所分享的自己动手打造一套IOC注解框架、启动Activity...

1/**
2 * Created by Darren on 2017/2/8.
3 * Email: 240336124@qq.com
4 * Description: 整个应用的BaseActivity
5 */
6public abstract class BaseActivity extends AppCompatActivity {
7
8    @Override
9    protected void onCreate(@Nullable Bundle savedInstanceState) {
10        super.onCreate(savedInstanceState);
11        setContentView();
12        // IOC注解注入
13        ViewUtils.inject(this);
14        initTitle();
15        initView();
16        initData();
17    }
18
19    // 初始化数据
20    protected abstract void initData();
21
22    // 初始化界面
23    protected abstract void initView();
24
25    // 设置界面视图
26    protected abstract void setContentView();
27
28    // 初始化头部
29    protected abstract void initTitle();
30
31
32    /**
33     * 启动一个Activity
34     * @param activity  需要启动的Activity的Class
35     */
36    public void startActivity(Class<? extends Activity> activity) {
37        Intent intent = new Intent(this,activity);
38        startActivity(intent);
39    }
40
41    /**
42     *  findViewById 不需要再去强转
43     */
44    public <T extends View> T viewById(@IdRes int resId) {
45        return (T) super.findViewById(resId);
46    }
47} 

接下来我们来说一下好处，模板设计模式的好处就不说了网上太多了，我们就只说在真正的开发中这么做的好处

1. 在实际的开发过程中我们往往不是一个人在开发，如果把直接在onCreate()里面写很多东西显然不行，但是如果写一些方法，那么每个成员所写的方法都会不同，何况有些哥们英语估计没过四级，单词都写错；
2. 直接继承自BaseActivity会自动提示覆盖方法，更加有利于开发或者代码的阅读，每个方法各尽其职只干自己该干的事，没事干就歇着；
3. 我们可以把通用的流程或者是某些方法放到BaseActivity，这样又节省代码又方便但是不是乱七八糟的放一大堆，细节会有很多具体可以看视频讲解；
4. 我们中间肯定还需要逻辑层的BaseActivity，这样做其实有利于后期的版本迭代、层次抽离和代码重构...

所有分享大纲：2017Android进阶之路与你同行

视频讲解地址：http://pan.baidu.com/s/1nuNA0Vv