【design pattern】行为型模式之—模板方法设计模式（Template method）

1. 简介                                 

Template method ：模板方法 设计模式

定义一个操作中的 算法骨架，将一些步骤放到子类中去实现。

结合其名称通俗的解释， 提供一个 模板方法 ，这个模板方法可以被多次重用 ，但是 其中某些部分在重用的过程中需要改变 ，那就利用抽象的思想，把需要改变的部分抽象出来，由其不同的子类 提供不同的实现；而将不变的部分直接提供实现 。当然 子类也可以 重写 已经实现的 方法（overrider）

根据上面的描述，模版方法设计模式的

实现：

            ★  抽象类   A

            ★  A 的 子类 A1 

            ★  A 的 子类 A2

            （如果 A1 仍然为 抽象类  ：即 模版方法 的 二次 使用

             ★  A1 的子类  B1

             ★  A1 的子类  B2

              。。。

             ）

最后 利用  多态 实例化子类对象

            A  a =  new A1()；

             a.template()；

            A  a = new A2()；

             a.template()；

( 若 A1 仍为抽象类

    A  a = new B1()；

    a.template()；

    A a = new B2()；

    a.template()；

)

参考 ： Template Method in Java

2. 实践                                             

template method 是 在 分析 Spring 源码时 （Spring 4.3.4）发现的 ，这里就分析一下 Spring 是 如何 实现 该 设计模式的；

涉及到 该 设计模式的类 ：

Spring-context jar 包 中

org.springframework.context.support.AbstractApplicationContext       //抽象类

类的简单介绍：

是 ApplicationContext 接口的 抽象实现类 ，没有指定 用来配置 bean 工厂的 存储类型 。简单实现了 常见 上下文的功能 。

使用了 Template Method 设计模式，要求  具体的子类 实现 抽象方法。

和 普通的 BeanFactory 相比，ApplicationContext  应该 能够在 其 内部 bean 工厂 中 侦测已经定义了的 特殊的 bean。因此，这个类自动注册了

org.springframework.beans.factory.config.BeanFactoryPostProcessor
org.springframework.beans.factory.config.BeanPostProcessor
org.springframework.context.ApplicationListener

这些类 在 上下文中 被 定义成 bean 。

模版方法：

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

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

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

类中使用 的 抽象方法：

有三个抽象方法

         ★ 1   refreshBeanFactory（）

子类必须 实现这个方法 以执行真正的 配置加载。在任何其他的初始化工作之前 ，被本类中的 refresh 方法 调用。子类 也将 创建一个 新的 bean 工厂 并且 持有对它的一个引用，或者 返回 他 持有的 一个 单例 的 BeanFactory 实例 。在之后，如果 刷新 上下文超过 一次，这个方法将会 经常 抛出一个 IllegalStateException 异常 。也就是不支持多次刷新。

refreshBeanFactory（） 方法 所在 的 方法（其中也包括了 getBeanFactory（） 抽象方法）

//告诉 子类 刷新 内置的 bean factory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

refreshBeanFactory() 方法 在 两个不同子类中的 不同实现：

            AbstractRefreshableApplicationContext  类

其子类包括 我们常用的 ：

XmlWebApplicationContext ： 传统的 基于 XML 配置的 web 应用 使用 该 web 应用上下文；

AnnotationConfigWebApplicationContext： 基于注解配置的 web 应用 会使用 该 web 应用上下文；

ClassPathXmlApplicationContext ：

FileSystemXmlApplicationContext：

实现方法：

	// 关闭 之前的 BeanFactory,为应用上下文 生命周期 的 下一个阶段初始化一个 崭新的 bean Factory
         protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

           GenericApplicationContext 类

实现方法：

	// do nothing : 已经持有了一个内置的 BeanFactory，
    //而且可以通过调用 公共方法 注册 bean,所以这里不需要 刷新重新获取
	protected final void refreshBeanFactory() throws IllegalStateException {
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
	}

综上，当我们启动一个 基于 XmlWebApplicationContext 或者  AnnotationConfigWebApplicationContext 应用上下文的 web 项目时 ，当执行到 refreshBeanFactory 时 ，执行的是 AbstractRefreshableWebApplicationContext 中的 refreshBeanFactory　的　方法；而 实例化 GenericApplicationContext 或者其 子类之后 在调用  refreshBeanFactory 方法时 ，执行的就是 GenericApplicationContext 类中的 refreshBeanFactory　的　方法；

          
         ★ 2   closeBeanFactory（）

类同  refreshBeanFactory() 方法

         ★ 3    getBeanFactory（）

类同  refreshBeanFactory() 方法