【设计模式】模板模式

在看Spring ApplicationContext的时候，Spring的ApplicationContext启动的过程是在AbstractApplicationContext中的refresh()方法中实现的。在AbstractApplicationContext中是没有具体的BeanFactory的，同时父类中也没有维护BeanFactroy的实例，AbstractApplicationContext中定义了一些关于BeanFactroy中的抽象方法来供底层的子类来继承。具体如下：

protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;
protected abstract void closeBeanFactory();
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

以上三个方法在refresh()方法被调用，这些方法的具体的实现会在子类（之一）AbstractRefreshableApplicationContext中实现的。

在AbstractRefreshableApplicationContext中，其中refreshBeanFactory()方法中首先会创建一个DefaultListableBeanFactory；然后调用loadBeanDefinitions(DefaultListableBeanFactory beanFactory)方法将BeanDefinition的信息加载到当前的BeanFactory中来。但是这个方法在AbstractRefreshableApplicationContext中没有实现，这个方法被定义成为一个abstract 类型。

loadBeanDefinitions(DefaultListableBeanFactory beanFactory)方法在子类AbstractXmlApplicationContext中实现。主要是将BeanDefinition加载到BeanFactory中来。

综上，在一个类中，一个方法实现一个功能，在实现的过程中有一系列的步骤。其中有一些步骤无法代表当前的类中实现，或者是这些功能可能会有多种实现的方式，这个时候可以将这些步骤抽象出来，声明为一个abstract的方法，然后将这些抽象的方法交给子类去实现。模板模式是通过继承来实现的代码复用。在Spring中反复的使用了模板模式来实现当前的功能。

阎宏博士在《java与模式》一书中描述了模板模式：

模板方法模式是类的行为模式。准备一个抽象类，将部分逻辑以具体方法以及具体构造函数的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。

一个简单的实例：

模板类：

public abstract class AbstractApplicationContextTemplate {


    public void refresh() {


        System.out.println("开始加载BeanFactory");

        loadBeans();//

        System.out.println("加载beanFactory完成");

        System.out.println("加载的BeanFactory的结果= " + getBeanFactory());

    }

    /**
     * 加载bean对象
     */
    protected abstract void loadBeans();


    /**
     * 获取对应的BeanFactory
     * @return
     */
    protected abstract Map<String, Object> getBeanFactory();
}

实现子类一：

public class ConcurrentApplicationContextTemplate extends AbstractApplicationContextTemplate {

    private Map<String, Object> beanFactory;

    protected void loadBeans() {
        if (beanFactory == null) {
            beanFactory = new HashMap<String, Object>();
        }
        beanFactory.put("001", "hello world ");
        beanFactory.put("002", "ni hao");
        beanFactory.put("003", "你好");

    }

    protected Map<String, Object> getBeanFactory() {
        return this.beanFactory;
    }
}

实现子类二：

public class GenericApplicationContextTemplate extends AbstractApplicationContextTemplate {

    private Map<String, Object> beanFactory;

    protected void loadBeans() {

        if (beanFactory == null) {
            beanFactory = new ConcurrentHashMap<String, Object>();
        }

        beanFactory.put("generic001", "001");
        beanFactory.put("generic002", "002");
        beanFactory.put("generic003", "003");

    }

    protected Map<String, Object> getBeanFactory() {
        return this.beanFactory;
    }
}

调用类：

public class MainTest {


    public static void main(String[] args) {

        AbstractApplicationContextTemplate applicationContextTemplate = new ConcurrentApplicationContextTemplate();
        applicationContextTemplate.refresh();
        AbstractApplicationContextTemplate abstractApplicationContextTemplate2 = new GenericApplicationContextTemplate();
        abstractApplicationContextTemplate2.refresh();

    }
}

引出的问题：

对于父类模板类，主要描述了一些主要的流程，将一些不确定的，或者可能 变化的部分功能抽象成为一个 abstract的方法，然后将具体的交给子类来实现。某种程度上模板模式是一种代码复用和功能扩展的方式。模板模式是通过继承的方式来实现扩展的。是否有其他的方式来实现这种扩展，使用继承来实现这种扩展是否会带来其他的一些特性？

转载于:https://my.oschina.net/u/3388174/blog/881852