设计模式之模板方法模式---template method

模式的介绍

模式的定义

Define the skeleton of an algorithm in an operation，deferring some steps to subclassed.Template Method lets subclassed redefine certain steps of an algorithm without changing the algorithm’s structure.

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

模式的使用场景

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

UML类图

角色介绍

(1)AbstractClass:
抽象的父类，定了几个抽象的方法，和关键的模板方法templateMethod，对算法的框架，步骤进行了定义
(2)ConcreteClass
具体类，主要是实现抽象父类定义的方法

模式的简单实现

想这个例子，我也是参考了好几个样例，一直想不到特别好的。有那么一刻，忽然想到，其实我们写代码就是一个非常好的模板方法模式啊。
编写代码，我们一般都是先弄明白需求，再实现功能，再验证功能。这不就是一个算法的结构。
我们定义一个编写代码模板方法父类，定义开发的三个步骤，再用一个模板方法runCode来组织这三个步骤：

public abstract class AbstractCoder {

    protected abstract void onBeforeCode();
    protected abstract void onCoding();
    protected abstract void onAfterCode();

    public final void runCode() {
        onBeforeCode();
        onCoding();
        onAfterCode();
    }
}

编定代码，不同水平的程序员，在这三个开发阶段，工作是不同的。我们实现了一个初级水平的程序员和有经验的程序员三个开发步骤的操作：

public class PrimaryCoder extends AbstractCoder {

    @Override
    protected void onBeforeCode() {
        // TODO Auto-generated method stub
        System.out.println("初级工程师code:");
        System.out.println("开发前:");
        System.out.println("看明白需求");
    }

    @Override
    protected void onCoding() {
        // TODO Auto-generated method stub
        System.out.println("开发时:");
        System.out.println("面向实现编程");
    }

    @Override
    protected void onAfterCode() {
        // TODO Auto-generated method stub
        System.out.println("编码后:");
        System.out.println("验证开发需求");
    }
}

package com.android.template_method;

public class SkilledCoder extends AbstractCoder{

    @Override
    protected void onBeforeCode() {
        // TODO Auto-generated method stub
        System.out.println("高级工程师code:");
        System.out.println("开发前:");
        System.out.println("仔细阅读开发文档，理解开发需求");
        System.out.println("根据需求形成开发UML类图");
    }

    @Override
    protected void onCoding() {
        // TODO Auto-generated method stub
        System.out.println("开发时:");
        System.out.println("严格按照开发规范编写代码");
        System.out.println("按照面向对象的开发原则开发");
        System.out.println("合理的运用合适的设计模式开发");
        System.out.println("尽量重用经过验证的代码");
    }

    @Override
    protected void onAfterCode() {
        // TODO Auto-generated method stub
        System.out.println("编码后:");
        System.out.println("验证开发需求");
        System.out.println("不断重构代码");
        System.out.println("总结开发，形成可以复用的工具代码，框架等");
    }
}

最后，我们在客户端来调用模板方法模式：

public class TemplateMethod {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AbstractCoder primAbstractCoder = new PrimaryCoder();
        primAbstractCoder.runCode();

        AbstractCoder skilledCoder = new SkilledCoder();
        skilledCoder.runCode();
    }
}

程序输出：

初级工程师code:
开发前:
看明白需求
开发时:
面向实现编程
编码后:
验证开发需求

高级工程师code:
开发前:
仔细阅读开发文档，理解开发需求
根据需求形成开发UML类图
开发时:
严格按照开发规范编写代码
按照面向对象的开发原则开发
合理的运用合适的设计模式开发
尽量重用经过验证的代码
编码后:
验证开发需求
不断重构代码
总结开发，形成可以复用的工具代码，框架等

关于钩子函数(Hook Method)

现在，我们考虑一个情况，对于有经验的软件工程师来说，有时编码的只是一个非常简单修改，那么，是不是不需要在编码之前进行一些操作，可以直接进行编码。那么这个需要，我们要如何修改代码来实现了？
答案是非常的简单，我们在父类中添加一个钩子函数(Hook Method)，来约束子类的方法操作。

AbstractCoder 类：

package com.android.template_method;

public abstract class AbstractCoder {

    protected abstract void onBeforeCode();
    protected abstract void onCoding();
    protected abstract void onAfterCode();
    //Hook
    protected boolean isBeforeCode = true;

    protected boolean isBeforeCode(){
        return isBeforeCode;
    }
    //Hook Method
    protected void setBeforeCode(boolean isBeforeCode){
        this.isBeforeCode = isBeforeCode;
    }

    public final void runCode() {
        //钩子来约束方法
        if(isBeforeCode == true){
            onBeforeCode();
        }
        onCoding();
        onAfterCode();
    }
}

TemplateMethod 修改如下：

package com.android.template_method;

public class TemplateMethod {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AbstractCoder primAbstractCoder = new PrimaryCoder();
        primAbstractCoder.setBeforeCode(true);
        primAbstractCoder.runCode();

        AbstractCoder skilledCoder = new SkilledCoder();
        skilledCoder.setBeforeCode(false);
        skilledCoder.runCode();
    }
}

运行结果如下：

初级工程师code:
开发前:
看明白需求
开发时:
面向实现编程
编码后:
验证开发需求

开发时:
严格按照开发规范编写代码
按照面向对象的开发原则开发
合理的运用合适的设计模式开发
尽量重用经过验证的代码
编码后:
验证开发需求
不断重构代码
总结开发，形成可以复用的工具代码，框架等

从结果来看，对于初级工程师，他编写代码还是按照正常的开发前，开发时，编码后的流程来开发的，但是对于高级工程师来说，他就是开发时，编码后的流程开发，直接跳过了开发前的工作。这就满足了我们上面提出的需求了。

在模板方法模式中，在父类中添加一个钩子方法(Hook Method),然后子类通过控制钩子可以对父类的方法执行操作进行约束，(子类控制父类)这是不是非常有吸引力啊。

模式的优缺点

优点

• 封装不变部分，扩展可变部分
• 提取公共部分代码，便于维护
• 行为由父类控制，子类实现

缺点

依照我们的设计习惯，抽象类负责声明最抽象，最一般的事物的属性和方法，实现类完成具体事物的属性和方法。但是模板方法模式却颠倒过来了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度，让新手产生不适感。

Android源码中的模式实现

AsyncTask类

android中，我们常用的一个AsyncTask类就是一个经典的模板方法模式，AsyncTask的一个使用样例：

实现一个AsyncTask类：

    private class AppLoadingTask extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... params) {
            fetchAndMergeApps();
            .................
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            populateApps();
            .................
        }

        @Override
        protected void onPreExecute() {
            .................
        }
    }

调用方法如下：

private AsyncTask mAppLoadingTask;
mAppLoadingTask = new AppLoadingTask().execute((Void[]) null);

我们继承AsyncTask类，实现三个接口：doInBackground，onPostExecute，onPreExecute。然后再new一个对象，执行execute方法，子类就会按一定的规则执行这三个接口，对，这就是模板方法模式。

我们来看AsyncTask源码：
frameworks/base/core/java/android/os/AsyncTask.java

先看这三个接口是如何定义的：

protected abstract Result doInBackground(Params... params);

protected void onPostExecute(Result result) {}

protected void onPreExecute() {}

再来看execute方法：

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
            throw new IllegalStateException("Cannot execute task:"+ " the task is already running.");
            case FINISHED:
            throw new IllegalStateException("Cannot execute task:"+ " the task has already been executed "+ "(a task can be executed only once)");
        }
    }
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    exec.execute(mFuture);
    return this;
}

我们可以看到会先执行onPreExecute方法，再给mWorker.mParams 赋值，再执行exec.execute(mFuture); ，那么，我们可以在构造方法中看到这二个变量的初始化：

public AsyncTask() {

    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            return postResult(doInBackground(mParams));
        }
    };

    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occured while executing doInBackground()",e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

我们可以看到会执行postResult(doInBackground(mParams));，再看postResult方法：

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

我们看到这，就知道了，消息已经发送到Handler了，查看Handler:

    private static class InternalHandler extends 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:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

如果消息发送的是任务结束(MESSAGE_POST_RESULT)，将执行：result.mTask.finish(result.mData[0]);
我看查看finish方法：

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

对的，我们看到了onPostExecute方法了。至此，模板方法在AsyncTask类中的使用情况，我们应该是明白了。

当然了，如果消息发送的是更新进度的消息(MESSAGE_POST_PROGRESS)，那么执行：

result.mTask.onProgressUpdate(result.mData);

我们查看onProgressUpdate方法：

protected void onProgressUpdate(Progress... values) {}

对的，没有实现，只有定义，也就是说，我们可以在子类中实现此方法，这也是模板方法中的一个方法噢。

参考资料

(1)Android设计模式源码解析之模板方法模式
https://github.com/hfreeman2008/android_design_patterns_analysis/tree/master/template-method/mr.simple
(2).设计模式之禅—第10章 模板方法模式