模板方法模式

定义

Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. template Method lets subclasses redefine certain steps of algorithm without changing the algorithm's structure.
(定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤)

通用类图

通用代码实现

public abstract class AbstractClasss {
    public abstract void doSomthing1();

    public abstract void doSomthing2();

    public final void templateMethod() {
        doSomthing1();
        doSomthing2();
    }
}

class  concreteClass extends AbstractClasss{

    @Override
    public void doSomthing1() {
        System.out.println("doSomthing1");
    }

    @Override
    public void doSomthing2() {
        System.out.println("doSomthing2");
    }
}

实际场景太多了，我们简单的举一个Tomcat声明周期的例子，为什么是它的？太经典，太惊艳了！

我们看org.apache.catalina.util.LifecycleBase#start

 @Override
    public final synchronized void start() throws LifecycleException {

        if (LifecycleState.STARTING_PREP.equals(state) ||
                LifecycleState.STARTING.equals(state) ||
                LifecycleState.STARTED.equals(state)) {

            if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStarted",
                        toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStarted",
                        toString()));
            }

            return;
        }

        if (state.equals(LifecycleState.NEW)) {
            init();
        } else if (state.equals(LifecycleState.FAILED)){
            stop();
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            invalidTransition(Lifecycle.BEFORE_START_EVENT);
        }

        setStateInternal(LifecycleState.STARTING_PREP, null, false);

        try {
            startInternal();
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            setStateInternal(LifecycleState.FAILED, null, false);
            throw new LifecycleException(
                    sm.getString("lifecycleBase.startFail",toString()), t);
        }

        if (state.equals(LifecycleState.FAILED) ||
                state.equals(LifecycleState.MUST_STOP)) {
            stop();
        } else {
            // Shouldn't be necessary but acts as a check that sub-classes are
            // doing what they are supposed to.
            if (!state.equals(LifecycleState.STARTING)) {
                invalidTransition(Lifecycle.AFTER_START_EVENT);
            }

            setStateInternal(LifecycleState.STARTED, null, false);
        }
    }

其中在try-catch中调用了startInternal()方法，它是一个protected方法

protected abstract void startInternal() throws LifecycleException;

让子类去实现，其中一个子类的实现org.apache.catalina.core.StandardHost#startInternal

    protected synchronized void startInternal() throws LifecycleException {

        // Set error report valve
        String errorValve = getErrorReportValveClass();
        if ((errorValve != null) && (!errorValve.equals(""))) {
            try {
                boolean found = false;
                Valve[] valves = getPipeline().getValves();
                for (Valve valve : valves) {
                    if (errorValve.equals(valve.getClass().getName())) {
                        found = true;
                        break;
                    }
                }
                if(!found) {
                    Valve valve =
                        (Valve) Class.forName(errorValve).newInstance();
                    getPipeline().addValve(valve);
                }
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                log.error(sm.getString(
                        "standardHost.invalidErrorReportValveClass",
                        errorValve), t);
            }
        }
        super.startInternal();
    }

子类实现了自己的逻辑，而影响了父类的启动过程

优点：


- 封装不变部分，扩展可变部分。


- 提取公共代码，便于维护。


- 行为由父类控制，子类实现。


使用场景：


- 多个子类有公有的方法，并且逻辑基本相同时。


- 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现


- 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。