AsyncTask--模板模式的应用

文章开头先贴下另外几篇设计模式的分析，感兴趣的可以看下：
设计模式-简单说明
ListView适配器模式的应用
ListView观察者模式的应用
ListView桥接模式的应用
AsyncTask为Android封装的轻量级异步类，用法简单。但是在这个简单的异步类里面其实包含了很多的知识点，本文主要是从设计模式 – 模板方法来简单分析其在AsyncTask中的使用。先说一下模板方法的定义和使用场景：

定义：针对一个特定问题，它的解决步骤是已知、并且是固定的，但是步骤中的具体的解决方式，由于不同需求可能不同，所以出现了模板方法（固定，不可改变），在该方法中定义了步骤（方法），子类只需要根据需要重写相应步骤方法即可。

场景：解决某一方法的步骤已知且固定，但是具体实现根据需求可变化

我们这里先贴一下AsyncTask模板方法模式的UML类图，简单梳理一下，免得一会绕晕：

我们先看下AsyncTask的简单使用：

//创建异步任务并执行
 new AsyncTask<Void,Void,Void>(){
      @Override
      protected Void doInBackground(Void... params) {
            return null;
      }
}.execute();

首先我们来看一下的AsyncTask构造函数：

/**
 *  AsyncTask构造，必须在UI线程调用本构造，创建异步任务
 */
public AsyncTask() {
        //WorkerRunnable为Callable<Result>接口实现类
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                    ...省略几行代码
                    //调用doInBackground
                    result = doInBackground(mParams);
                    ...省略几行代码
                } ...省略异常捕获
                finally {
                    //将使用Hanlder发送结果到主线程
                    postResult(result);
                }
                return result;
            }
        };

        //可以简单认为就是一个Runnable子实现类
        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    //判断是否执行过，未执行的话会调用postResult
                    postResultIfNotInvoked(get());
                } ...省略异常捕获
            }
        };
    }

可以看出，在AsyncTask的构造函数中主要是构造了两个对象，mWorker 和mFuture ，mWorker 为Callable接口实现类，主要是重写call方法，一会在线程池执行的时候会调用；mFuture为FutureTask接口实现类，重写run方法，FutureTask为Runnable的子类。

执行异步任务一共有两个方法execute和executeOnExecutor，不过两者实际上是一样的，因为execute也会调用executeOnExecutor，所以我们直接看executeOnExecutor方法：

 /**
  * 执行异步任务，需要在UI线程调用，会返回异步任务引用
  */
  @MainThread
  public final AsyncTask<Params,Progress,Result>executeOnExecutor(Executor exec, Params... params) {
            ...省略几行代码
            //执行该方法，可以做初始化操作（在UI线程）
            onPreExecute();

            ...省略几行代码        

            //线程池开始执行任务（会将mFuture添加到当前队列的尾部），会调用mFuture的run方法。
            //在线程池中每次执行完毕都会从队列中获取第一个任务元素来执行，直到全部执行完毕
            exec.execute(mFuture);

            return this;
      }

executeOnExecutor中使用exec，即线程池来执行execute，我们就以默认的SerialExecutor来分析：

     public synchronized void execute(final Runnable r) {
                mTasks.offer(new Runnable() {
                    public void run() {
                        try {  
                            //调用传递进来的Runnable的run方法（实际上为mFuture的run方法）
                            r.run();
                        } finally {  
                            //获取下一个任务来执行
                            scheduleNext();
                        }
                    }
                });
                if (mActive == null) {
                    scheduleNext();
                }
            }

在SerialExecutor的execute方法中我们看到它调用例如r.run,r即为我们前面传递进去的mFuture，我们看下构造中的mFuture的run方法：

    public void run() {
            ...省略几行代码        
            //调用Callable的call方法（实际上就是AsyncTask构造中所初始化的mWorker）
            result = c.call();
            ...省略几行代码    
        }

c即为我们传递进去的mWorker实例，mWorker的call方法为：

     public Result call() throws Exception {
                        ...省略几行代码
                        //调用doInBackground
                        result = doInBackground(mParams);
                        ...省略几行代码
                    } ...省略异常捕获
                    finally {
                        //将使用Hanlder发送结果到主线程
                        postResult(result);
                    }
                    return result;
                }

可以看到这里调用了doInBackground，最后还会调用postResult方法，postResult会使用基于UI线程的Handler对象（InternalHandler 实例），将结果发送到UI线程：

     private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        //使用Handler获取缓存Message对象，有则直接使用，没有则新建（Message使用了享元模式，防止大量创建Message从而消耗性能）
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                    new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

自定义Hanlder类：

    private static class InternalHandler extends Handler {
            //定义UI线程Handler
            public InternalHandler() {
                super(Looper.getMainLooper());
            }

            @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
            @Override
            public void handleMessage(Message msg) {
                AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
                switch (msg.what) {
                    case MESSAGE_POST_RESULT:
                        // 执行完毕，回调finish
                        result.mTask.finish(result.mData[0]);
                        break;
                    case MESSAGE_POST_PROGRESS:
                        //回调进度刷新(需要注意的是这个方法要回调，需要调用publishProgress才会触发)
                        result.mTask.onProgressUpdate(result.mData);
                        break;
                }
            }
        }

AsyncTask的finish方法

    private void finish(Result result) {
            if (isCancelled()) {
                onCancelled(result);
            } else {
                onPostExecute(result);
            }
            mStatus = Status.FINISHED;
        }

从以上流程就可以看出AsyncTask.execute的执行流程：onPreExecute() –> doInBackground() –> publishProgress() –> onProgressUpdate() –> onPostExecute()。这整个流程都是从execute/executeOnExecutor开始的，它们被定义为final类型，原因就是异步任务的步骤是固定的，就是以上几个步骤，但是具体这个异步任务要做什么，就需要子类根据自身需求来确定，只要重写相应的方法即可。这就是模板方法模式的一个简单分析，在Android中其实还有很多使用到了模板设计模式，只是我们没有去在意，比如：Activity/Fragment的生命周期等。如果有什么不足之处还请指出，一起进步。