设计模式学习第十三节 模版方法模式

概述

    基本介绍
    模版方法模式(Template Method Pattern)，也叫做模版模式，在一个抽象类公开定义了执行它的方法的模版，它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。简单来说，模版方法模式就是定义一个操作中的算法(流程)的骨架，而将一些具体实现的步骤延迟到子类中实现，使得子类可以不改变算法的结构，就可以定义该算法的某些特定步骤。这种类型的设计模式属于行为型模式。
    简要类图描述

     类图 AbstractClass中的template 方法中定义了实现的大致流程，调用的method可以是抽象方法，也可以是实现方法，如果是抽象方法，就放到子类中去实现。

public void template(){
	method1();
	method4();
	method3();
}

    类图角色以及职责说明
    1、AbstractClass 抽象类，类中实现了模版方法，定义了算法的骨架，具体子类需要去实现其它抽象方法method1()等等。
    2、ConcreteClass具体实现子类，实现AbstractClass中定义的抽象方法，以完成算法中特定的步骤。

代码实现

    使用模板方法模式实现火锅制作。
    -步骤定义为 选锅底 --> 选菜 --> 锅底烧开 —> 下菜
    -通过选择不同材料制作出不同的火锅
    类图说明

    代码实现

package com.example.pattern.template;

import java.util.concurrent.TimeUnit;

/**
 * 模版方法模式
 */
// 抽象类 表示火锅
public abstract class HotPot {

    // 模版方法 make 模版方法可以做成final 禁止子类覆盖
    public final void make() {
        selectSoup();
        selectDish();
        boilSoup();
        addDish();
    }

    public abstract void selectSoup(); // 选择锅底

    public abstract void selectDish(); // 选择配菜

    public void boilSoup() { // 锅底烧开
        System.out.println("打开火炉");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("锅底烧开");
    }

    public void addDish() {
        System.out.println("向火锅中添加一些配菜");
        System.out.println("可以享用");
    }

}

class SoupPot extends HotPot { // 清汤火锅

    @Override
    public void selectSoup() {
        System.out.println("选择清汤锅底");
    }

    @Override
    public void selectDish() {
        System.out.println("选择适合清汤的配菜");
    }
}

class SpicyHotPot extends HotPot { // 麻辣火锅

    @Override
    public void selectSoup() {
        System.out.println("选择麻辣锅底");
    }

    @Override
    public void selectDish() {
        System.out.println("选择适合麻辣的配菜");
    }
}

class Client {
    public static void main(String[] args) {
        System.out.println("制作清汤火锅");
        HotPot soupPot = new SoupPot();
        soupPot.make();
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("制作麻辣火锅");
        HotPot spicyHotPot = new SpicyHotPot();
        spicyHotPot.make();
    }
}

模板方法模式钩子方法

    在模版方法模式的父类中，我们可以定义一个方法，它默认不做任何事情，子类可以视情况要不要覆盖它，该方法称为“钩子”。
    比如在上面的方法中可以添加

// 模版方法 make 模版方法可以做成final 禁止子类覆盖
    public final void make() {
        selectSoup();
        selectDish();
        boilSoup();
        addDish();
        addSoup();
    }
    public void addSoup() { // 加汤 默认不加

    }

    麻辣锅子类中可以覆盖这个方法

   @Override
    public void addSoup() {
        System.out.println("太辣了需要加汤");
    }

模版方法在Spring框架中的应用分析

    Spring IOC 容器初始化时运用到了模版方法模式

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
	......
	// 声明了一个模版方法
	void refresh() throws BeansException, IllegalStateException;
	......
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	......
	@Override
	// 模版方法的实现
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			......
				// Tell the subclass to refresh the internal bean factory.
			// obtainFreshBeanFactory 方法调用了两个抽象方法 refreshBeanFactory getBeanFactory
			// 这样具体需要获取那种BeanFactory容器的决定权就交给了子类完成
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			
				// Initialize other special beans in specific context subclasses.
				onRefresh(); // 这里定义了一个钩子方法

		   .......
		}
	
	protected void onRefresh() throws BeansException { // 定义一个空方法 需要子类去实现
		// For subclasses: do nothing by default.
	}
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		refreshBeanFactory();
		return getBeanFactory();
	}
	// 定义子类必须要实现的方法
	protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

	......
	
}

模版方法模式注意事项与细节

    1、基本思想是：算法只存在于一个地方，那就是父类中，容易修改，需要修改算法时，只要修改父类的模版方法或者已经实现的某些步骤，子类就会继承这些修改。
    2、实现了最大化代码复用，父类的模版方法和已实现的某些步骤会被子类继承而直接使用。
    3、即统一了算法，也提供了很大的灵活性，父类的模版方法确保了算法的结构保持基本不变，同时由子类提供部分步骤的具体实现。
    4、一般模版方法都加上final关键字，防止子类继承。
    5、模版方法模式不足之处是：每一个不同的实现都需要增加一个子类，导致类的个数增加，使得系统更加庞大。
    6、模版方法模式的使用场景：当需要完成某个过程，该过程需要执行一系列的步骤，这一系列的步骤基本相同，但是个别步在实现时可能不同，通常考虑使用模版方法模式处理。