设计模式---行为型---模板模式(Template )

一 . 模板模式介绍

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

抽象类体现的就是一种模板设计模式,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展,改造,但子类会保留抽象类的行为方式

解决的问题

• 当功能内部一部分实现是确定的,一部分实现是不确定的,这是可以把不确定的部分暴露出去,让子类去实现
• 换句话说,在软件开发中实现一个算法时,整体步骤很固定,通用,这些步骤已经在父类写好了,但是某些部分易变,易变部分可以抽象出来,共不同的子类去实现,这就是一种模板方法.

二 . 模板模式代码实现

抽象类

/**
 * 抽象类,表示豆浆
 */
public abstract class SoyaMilk {
    //模板方法,make, 模板方法可以做成final,不让子类去覆盖
    final void make() {
        select();
        addCondiments();
        soak();
        beat();
    }

    // 选材料
    void select() {
        System.out.println("第一步: 选择新鲜的黄豆");
    }

    //添加不同的配料,抽象方法,让子类去实现
    abstract void addCondiments();

    // 浸泡
    void soak() {
        System.out.println("第三部: 黄豆和配料开始浸泡");
    }

    void beat() {
        System.out.println("第四部:打碎");
    }
}

子类1

public class PeanutSoyaMilk extends SoyaMilk {
    @Override
    void addCondiments() {
        System.out.println("加入上好的花生");
    }
}

子类2

/**
 * 红豆豆浆
 */
public class RedBeanSoyaMilk extends SoyaMilk{
    @Override
    void addCondiments() {
        System.out.println("加入红豆");
    }
}

public class Client {
    public static void main(String[] args) {
        System.out.println("~~~1~~~~~~制作红豆豆浆~~~~~~~~~~~~~~~");
        SoyaMilk redBeanSoyaMilk = new RedBeanSoyaMilk();
        redBeanSoyaMilk.make();

        System.out.println("~~~~2~~~~~制作花生豆浆~~~~~~~~~~~~~~~");
        SoyaMilk peanutSoyaMilk = new PeanutSoyaMilk();
        peanutSoyaMilk.make();
    }
}

三 . 模板方法模式- - -钩子方法

在模板方法模式的父类中,我们可以定义一个方法,它默认不做任何事,子类可以视情况要不要覆盖它,该方法称为钩子

/**
 * 抽象类,表示豆浆
 */
public abstract class SoyaMilk {
    //模板方法,make, 模板方法可以做成final,不让子类去覆盖
    final void make() {
        select();
        if(customerWantCondiments()){
            addCondiments();
        }
        soak();
        beat();
    }

    // 选材料
    void select() {
        System.out.println("第一步: 选择新鲜的黄豆");
    }

    //添加不同的配料,抽象方法,让子类去实现
    abstract void addCondiments();

    // 浸泡
    void soak() {
        System.out.println("第三部: 黄豆和配料开始浸泡");
    }

    void beat() {
        System.out.println("第四部:打碎");
    }

    // 钩子方法,决定是否需要添加配料
    boolean customerWantCondiments() {
        return true;
    }

}

---

public class PureSoyaMilk extends SoyaMilk {
    //空实现就好
    @Override
    void addCondiments() {

    }

    @Override
    boolean customerWantCondiments() {
        return false;
    }
}

---

public class Client {
    public static void main(String[] args) {
        SoyaMilk pureSoyaMilk = new PureSoyaMilk();
        pureSoyaMilk.make();
    }
}

四 . 模板模式在Spring中的应用

父类: ConfigurableApplicationContext

子类:AbstractApplicationContext

在子类中实现

@Override
	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、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。 3、spring 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

缺点： 每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

注意事项： 为防止恶意操作，一般模板方法都加上 final 关键词。