设计模式——模板方法模式

一、定义与简单实现

1、定义

• 模板方法是一个定义在父类中的方法，
• 在模板方法中会顺序调用多个定义在父类中的其他方法，而这些方法有可能只是抽象方法，
• 模板方法保证了抽象方法的执行顺序，这些抽象方法由子类实现，并且子类不允许覆写模板方法。

2、UML类图

 

模板方法模式与工厂方法模式的UML类图实现都是父类定义抽象方法，然后将具体实现延迟到子类，但还是有区别的

• 模板方法模式是行为型设计模式，关注的是对象之间交流，可以是一个没有返回值的方法。
• 工厂方法模式是创建型设计模式，关注的是对象的创建，必须返回一个创建好的对象。

模板方法模式中的设计原则：

• 封装变化（抽象方法）
• 依赖抽象，不依赖具体类
• 对扩展开放，对修改关闭

3、简单代码实现

public interface TemplateService {
    void templateMethod();
}

public abstract class AbstractTemplateService implements TemplateService {
    @Override
    public void templateMethod() {
        //模板方法中的钩子方法isDoSomething1，子类可以改变方法执行顺序
        if(isDoSomething1()){
            doSomething1();
        }
        doSomething2();
        doSomething3();
    }

    protected boolean isDoSomething1(){
        return true;
    }

    protected void doSomething1(){
        System.out.println("something1 start");
    }

    /**
     * 子类不必实现，可以是空方法
     */
    protected void doSomething2(){

    }

    protected abstract void doSomething3();

}

public class ATemplateServiceImp extends AbstractTemplateService {

    @Override
    protected void doSomething3() {
        System.out.println("I am A");
    }
}

public class BTemplateServiceImp extends AbstractTemplateService {

    @Override
    protected boolean isDoSomething1() {
        return false;
    }

    @Override
    protected void doSomething2() {
        System.out.println("I am B");
    }

    @Override
    protected void doSomething3() {
        //empty
    }
}

public class Main {
    public static void main(String[] args) {
        TemplateService template = new ATemplateServiceImp();
        template.templateMethod();
        template = new BTemplateServiceImp();
        template.templateMethod();
    }
}

二、框架中的模板方法模式

模板方法在成熟的框架中用到的地方很多，最常见的就是SpringIOC容器的初始化

1、springIOC容器初始化

AbstractApplicationContext是一个抽象类，是SpringIOC容器类的超类。

它的refresh()方法就是一个模板方法，各种各样的springIOC容器都是根据这个模板方法初始化的。

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // ② IOC初始化前的装备(配置环境参数、创建监听器、事件容器)
            prepareRefresh();

            // ③ 这里可以分为两类：
            // GenericApplicationContext: 仅仅是控制beanfactory不能重复refresh
            // AbstractRefreshableApplicationContext：允许重复refresh，销毁就beanfactory，创建新beanfactory并且重新扫描生成beanDefinitionMap容器。

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // ④ 设置beanfactory的一些属性（bean的类加载器、忽略接口、BeanPostProcessor、环境参数单例注册到beanfactory单例容器中）
            prepareBeanFactory(beanFactory);

            try {
                // ⑤空方法，留由子类实现。
                //例如注册servlet相关的忽略接口、beanPostProcessor、各作用域生成bean的bean工厂
                //注册servlet的一些单例（servletContext/servletConfig/contextparameters/contextAttributes）到beanfactory的单例容器中
                postProcessBeanFactory(beanFactory);

                // ⑥beanFactoryPostProcessor排序并依次调用
                // beanFactoryPostProcessor：beanfactory的后置处理器，可以理解为一个beanfactory的拦截器（实例化后需要执行的自定义操作)
                // 例如：beanfactory初始化完成后，修改忽略接口、甚至可以对特定的beandefinition做修改
                invokeBeanFactoryPostProcessors(beanFactory);

                // ⑦BeanPostProcessors排序并依次注册到beanfactory的beanpostProcessor容器中
                // beanPostProcessors：bean实例化的处理器，可以理解为一个bean的拦截器（实例化前+实例化后需要执行自定义操作)
                // 例如：bean单例化前，修改beandefinition的属性。
                //实例化后DI，
                //拦截getbean()拦截返回一个代理类bean
                registerBeanPostProcessors(beanFactory);

                // ⑧初始化国际化文件，支持国际化
                initMessageSource();

                // ⑨初始化时间监听器并注册到beanfactory的单例容器中
                initApplicationEventMulticaster();

                // ⑩空方法，子类实现，初始化一些自定义bean并注册到beanfactory的单例容器中
                //  例如：themeSource，支持主题切换
                onRefresh();

                // ⑪注册个中监听器到beanfactory指定容器中
                registerListeners();

                // ⑫实例化不需要延迟加载的所有单例类型的bean（scope = singleton）
                finishBeanFactoryInitialization(beanFactory);

                // ⑬容器初始化完成，触发各种事件监控,ApplicationListener.onApplicationEvent()的执行时机（dubbo注册就是在这里实现的）
                // 例如：beanfactory的生命周期监控
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // ⑭ 容器初始化失败，销毁所有已实例化的bean
                destroyBeans();

                // ⑮ 设置active = false
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // ⑯ 清空公共的反射缓存
                resetCommonCaches();
            }
        }
    }  

2、JDK的ThreadPoolExecutor

线程池ThreadPoolExecutor的工作线程执行时，拓展了一个执行前，执行后方法

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

protected void beforeExecute(Thread t, Runnable r) { }

protected void afterExecute(Runnable r, Throwable t) { }

总结：模板方法模式特点：

在一个方法中定义一个算法的骨架（执行顺序），而将一些步骤延迟到子类中，模板方法还可以使得子类可以在不改变算法结构的情况下。重新定义算法中的某些步骤（钩子）。

强调的是方法执行顺序，还有延迟到子类实现。