学点设计模式-模板方法模式

模板方法模式

“告诉大家一个好消息，昨天终于把牛叉模型公司的口子打开了，要我们做悍马模型，虽然是第一个
车辆模型，但是我们有能力，有信心做好，我们一定要…（中间省略20 分钟的讲话，如果你听过领导人的
讲话，这个你应该能够续上）”

动员工作做完了，那就开始压任务了，“这次时间是非常紧张的，只有一个星期的时间，小三，你负责
在一个星期的时间把这批10 万车模(注：车模是车辆模型的意思，不是香车美女那个车模)建设完成…”
“一个星期？这个…，是真做不完，要做分析，做模板，做测试，还要考虑扩展性、稳定性、健壮性
等，时间实在是太少了”还没等老大说完，我就急了，再不急我的小命就折在上面了！

既然领导都说了，不考虑扩展性，那好办，我先设计个类图：

非常简单的实现，你要悍马模型，我就给你悍马模型，先写个抽象类，然后两个不同型号的模型实现
类，那我们把这个程序实现出来：
HummerModel 抽象类的程序清单如下：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. Hummer Model是悍马车辆模型的意思
 */
public abstract class HummerModel {
	/*
	 * 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正 是要能够发动起来，那这个实现要在实现类里了
	 */
	public abstract void start();

	// 能发动，那还要能停下来，那才是真本事
	public abstract void stop();

	// 喇叭会出声音，是滴滴叫，还是哔哔叫
	public abstract void alarm();

	// 引擎会轰隆隆的响，不响那是假的
	public abstract void engineBoom();

	// 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑
	public abstract void run();
}

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 悍马车是每个越野者的最爱，其中H1最接近军用系列
 */
public class HummerH1Model extends HummerModel {
	@Override
	public void alarm() {
		System.out.println("悍马H1鸣笛...");
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H1引擎声音是这样在...");
	}

	@Override
	public void start() {
		System.out.println("悍马H1发动...");
	}

	@Override
	public void stop() {
		System.out.println("悍马H1停车...");
	}

	/*
	 * 第 65 页 您的设计模式 这个方法是很有意思的，它要跑，那肯定要启动，停止了等，也就是要调其他方法
	 */
	@Override
	public void run() {
		// 先发动汽车
		this.start();
		// 引擎开始轰鸣
		this.engineBoom();
		// 然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
		this.alarm();
		// 到达目的地就停车
		this.stop();
	}
}

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. H1和H2有什么差别，还真不知道，真没接触过悍马
 */
public class HummerH2Model extends HummerModel {
	@Override
	public void alarm() {
		System.out.println("悍马H2鸣笛...");
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H2引擎声音是这样在...");
	}

	@Override
	public void start() {
		System.out.println("悍马H2发动...");
	}

	@Override
	public void stop() {
		System.out.println("悍马H1停车...");
	}

	/*
	 * H2要跑，那肯定要启动，停止了等，也就是要调其他方法
	 */
	@Override
	public void run() {
		// 先发动汽车
		this.start();
		// 引擎开始轰鸣
		this.engineBoom();
		// 然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
		this.alarm();
		// 到达目的地就停车
		this.stop();
	}
}

然后程序写到这里，你就看到问题了，run 方法的实现应该在抽象类上，不应该在实现类上，好，我们
修改一下类图和实现：

就把run 方法放到了抽象类中，那代码也相应的改变一下，先看HummerModel.java:

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. Hummer Model是悍马车辆模型的意思
 */
public abstract class HummerModelExtractRun {
	/*
	 * 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正 是要能够发动起来，那这个实现要在实现类里了
	 */
	public abstract void start();

	// 能发动，那还要能停下来，那才是真本事
	public abstract void stop();

	// 喇叭会出声音，是滴滴叫，还是哔哔叫
	public abstract void alarm();

	// 引擎会轰隆隆的响，不响那是假的
	public abstract void engineBoom();

	// 那模型应该会跑吧，别管是人退的，还是电力驱动，总之要会跑
	public void run() {
		// 先发动汽车
		this.start();
		// 引擎开始轰鸣
		this.engineBoom();
		// 然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
		this.alarm();
		// 到达目的地就停车
		this.stop();
	}
}

下面是HummerH1Model.java 程序清单：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 悍马车是每个越野者的最爱，其中H1最接近军用系列
 */
public class HummerH1ModelExtractRun extends HummerModelExtractRun {
	@Override
	public void alarm() {
		System.out.println("悍马H1鸣笛...");
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H1引擎声音是这样在...");
	}

	@Override
	public void start() {
		System.out.println("悍马H1发动...");
	}

	@Override
	public void stop() {
		System.out.println("悍马H1停车...");
	}
}

下面是HummerH2Model.java 的程序清单：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. H1和H2有什么差别，还真不知道，真没接触过悍马
 */
public class HummerH2ModelExtractRun extends HummerModelExtractRun {
	@Override
	public void alarm() {
		System.out.println("悍马H2鸣笛...");
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H2引擎声音是这样在...");
	}

	@Override
	public void start() {
		System.out.println("悍马H2发动...");
	}

	@Override
	public void stop() {
		System.out.println("悍马H2停车...");
	}
}

类图修改完毕了，程序也该好了，提交给老大，老大一看，挺好，就开始生产了，并提交给客户使用
了，那客户是如何使用的呢？类图上增加一个Client 类，就是客户，我们这个是用main 函数来代替他使
用，类图如下：

然后看增加的Client.java 程序，非常的简单：

package com.cbf4life.TemplateMethodPattern;/** * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you * all. 客户开始使用这个模型 */public class Client {public static void main(String[] args) {// 客户开着H1型号，出去遛弯了HummerH1ModelExtractRun h1 = new HummerH1ModelExtractRun();h1.run(); // 汽车跑起来了；// 客户开H2型号，出去玩耍了HummerH2ModelExtractRun h2 = new HummerH2ModelExtractRun();h2.run();}}非常非常的简单，那如果我告诉这就是模板方法模式你会不会很不屑呢？就这模式，太简单了，我一直在使用呀，是的，你经常在使用，但你不知道这是模板方法模式，那些所谓的高手就可以很牛X 的说“用模板方法模式就可以实现…”，你还要很崇拜的看着，哇，牛人，模板方法模式是什么呀? 然后我们继续回顾我们这个模型，回头一想，不对呀，需求分析的有点问题，客户要关心模型的启动，停止，鸣笛，引擎声音吗？他只要在run 的过程中，听到或看都成了呀，暴露那么多的方法干啥？好了，我们重新修改一下类图：把抽象类上的四个方法设置为protected 访问权限，好了，既然客户不关心这几个方法，而且这四个方法都是由子类来实现的，那就设置成protected 模式。咦~，那还有个缺陷，run 方法既然子类都不修改，那是不是可以设置成final 类型呢？是滴是滴,类图如下： 好了，这才是模板方法模式，就是这个样子，我们只要修改抽象类代码就可以了，HummerModel.java 程序清单如下：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. Hummer Model是悍马车辆模型的意思
 *         把抽象类上的四个方法设置为protected 访问权限
 */
public abstract class HummerModelModify {
	/*
	 * 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正 是要能够发动起来，那这个实现要在实现类里了
	 */
	protected abstract void start();

	// 能发动，那还要能停下来，那才是真本事
	protected abstract void stop();

	// 喇叭会出声音，是滴滴叫，还是哔哔叫
	protected abstract void alarm();

	// 引擎会轰隆隆的响，不响那是假的
	protected abstract void engineBoom();

	// 那模型应该会跑吧，别管是人退的，还是电力驱动，总之要会跑

	final public void run() {
		// 先发动汽车
		this.start();
		// 引擎开始轰鸣
		this.engineBoom();
		// 然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭
		this.alarm();
		// 到达目的地就停车
		this.stop();
	}
}

 

其他的子类都不用修改(如果要修改，就是把四个方法的访问权限由public 修改protected)，大家请
看这个run 方法，他定义了调用其他方法的顺序，并且子类是不能修改的，这个叫做模板方法；start、stop、
alarm、engineBoom 这四个方法是子类必须实现的，而且这四个方法的修改对应了不同的类，这个叫做基本
方法，基本方法又分为三种：在抽象类中实现了的基本方法叫做具体方法；在抽象类中没有实现，在子类
中实现了叫做抽象方法，我们这四个基本方法都是抽象方法，由子类来实现的；还有一种叫做钩子方法，
这个等会讲。
到目前为止，这两个模型都稳定的运行，突然有一天，老大又找到了我，
“客户提出新要求了，那个喇叭想让它响就响，你看你设计的模型，车子一启动，喇叭就狂响，赶快
修改一下”，确实是设计缺陷，呵呵，不过是我故意的，那我们怎么修改呢？看修改后的类图：

增加一个方法，isAlarm()，喇嘛要不要响，这就是钩子方法(Hook Method)，那我们只要修改一下抽
象类就可以了：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. Hummer Model是悍马车辆模型的意思，不是悍马美女车模
 */
public abstract class HummerModelIsAlarm {
	/*
	 * 首先，这个模型要能够被发动起来，别管是手摇发动，还是电力发动，反正 是要能够发动起来，那这个实现要在实现类里了
	 */
	protected abstract void start();

	// 能发动，那还要能停下来，那才是真本事
	protected abstract void stop();

	// 喇叭会出声音，是滴滴叫，还是哔哔叫
	protected abstract void alarm();

	// 引擎会轰隆隆的响，不响那是假的
	protected abstract void engineBoom();

	// 那模型应该会跑吧，别管是人推的，还是电力驱动，总之要会跑

	final public void run() {
		// 先发动汽车
		this.start();
		// 引擎开始轰鸣
		this.engineBoom();
		// 喇嘛想让它响就响，不想让它响就不响
		if (this.isAlarm()) {
			this.alarm();
		}
		// 到达目的地就停车
		this.stop();
	}

	// 钩子方法，默认喇叭是会响的
	protected boolean isAlarm() {
		return true;
	}
}

钩子方法模式是由抽象类来实现的，子类可以重写的，H2 型号的悍马是不会叫的，喇叭是个摆设，看
HummerH2Model.java 代码：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. H1和H2有什么差别，还真不知道，真没接触过悍马
 */
public class HummerH2ModelIsAlarm extends HummerModelIsAlarm {
	@Override
	protected void alarm() {
		System.out.println("悍马H2鸣笛...");
	}

	@Override
	protected void engineBoom() {
		System.out.println("悍马H2引擎声音是这样在...");
	}

	@Override
	protected void start() {
		System.out.println("悍马H2发动...");
	}

	@Override
	protected void stop() {
		System.out.println("悍马H1停车...");
	}

	// 默认没有喇叭的
	@Override
	protected boolean isAlarm() {
		return false;
	}
}

那H2 型号的模型都没有喇叭，就是按了喇叭也没有声音，那客户端这边的调用没有任何修改，出来的
结果就不同，我们先看Client.java 程序：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 客户开始使用这个模型
 */
public class Client2 {
	public static void main(String[] args) {
		HummerH2ModelIsAlarm h2 = new HummerH2ModelIsAlarm();
		h2.run(); // H2型号的悍马跑起来
	}
}

那H1 又有所不同了，它的喇叭要不要响是由客户来决定，其实在类图上已经标明了setAlarm 这个方
法，我们看HummerH1Model.java 的代码：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 悍马车是每个越野者的最爱，其中H1最接近军用系列
 */
public class HummerH1ModelSetIsAlarm extends HummerModelIsAlarm {
	private boolean alarmFlag = true; // 是否要响喇叭

	@Override
	protected void alarm() {
		System.out.println("悍马H1鸣笛...");
	}

	@Override
	protected void engineBoom() {
		System.out.println("悍马H1引擎声音是这样在...");
	}

	@Override
	protected void start() {
		System.out.println("悍马H1发动...");
	}

	@Override
	protected void stop() {
		System.out.println("悍马H1停车...");
	}

	@Override
	protected boolean isAlarm() {
		return this.alarmFlag;
	}

	// 要不要响喇叭，是有客户的来决定的
	public void setAlarm(boolean isAlarm) {
		this.alarmFlag = isAlarm;
	}
}

这段代码呢修改了两个地方，一是重写了父类的isAlarm()方法，一是增加了一个setAlarm 方法，由
调用者去决定是否要这个功能，也就是喇叭要不要滴滴答答的响，哈哈，那我们看看Client.java 的修改：

package com.cbf4life.TemplateMethodPattern;

/**
 * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you
 *         all. 客户开始使用这个模型
 */
public class Client3 {
	public static void main(String[] args) {
		// 客户开着H1型号，出去遛弯了
		HummerH1ModelSetIsAlarm h1 = new HummerH1ModelSetIsAlarm();
		h1.setAlarm(true);
		h1.run(); // 汽车跑起来了；
	}
}

看到没，这个模型run 起来就有声音了，那当然把h1.setAlarm(false)运行起来喇叭就没有声音了，
钩子方法的作用就是这样滴。
那我们总结一下模板方法模式，模板方法模式就是在模板方法中按照一个的规则和顺序调用基本方法，
具体到我们上面那个例子就是run 方法按照规定的顺序(先调用start,然后再调用engineBoom，再调用
alarm，最后调用stop)调用本类的其他方法，并且由isAlarm 方法的返回值确定run 中的执行顺序变更，
通用类图如下：

其中TemplateMethod 就是模板方法，operation1 和operation2 就是基本方法，模板方法是通过汇总
或排序基本方法而产生的结果集。模板方法在一些开源框架中应用很多，它提供了一个抽象类，然后开源
框架写了一堆子类，在《XXX In Action》中就说明了，如果你需要扩展功能，可以继承了这个抽象类，然
后修改protected 方法，再然后就是调用一个类似execute 方法，就完成你的扩展开发，确实是一种简单
的模式。
初级程序员在写程序的时候经常会问高手“父类怎么调用子类的方法”，这个问题很有普遍性，反正我
是被问过好几回，那么父类是否可以调用子类的方法呢？我的回答是能，但强烈的、极度的不建议，怎么
做呢?

1把子类传递到父类的有参构造中，然后调用；

2使用反射的方式调用，你使用了反射还有谁不能调用的？！

3父类调用子类的静态方法。

这三种都是父类直接调用子类的方法，好用不？好用！解决问题了吗？解决了！项目中允许使用不？
不允许！我就一直没有搞懂为什么要父类调用子类的方法，如果一定要调用子类，那为什么要继承它呢？
搞不懂。其实这个问题可以换个角度去理解，在重写了父类部分方法后，再调用从父类继承的方法，产生
不同的结果（而这正是模板方法模式），这是不是也可以理解为父类调用了子类的方法呢？你修改了子类，
影响了父类的结果，模板方法模式就是这样效果。

 

定义与结构
模板方法（Template Method）模式：定义一个操作中的算法的骨架，而将一些步骤延
迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。这里
的算法的结构，可以理解为你根据需求设计出来的业务流程。特定的步骤就是指那些可能在
内容上存在变数的环节。
模式的结构：
1) 抽象类（Abstract Class）：定义了一到多个的抽象方法，以供具体的子类来实现它们；
而且还要实现一个模板方法，来定义一个算法的骨架。该模板方法不仅调用前面的抽象
方法，也可以调用其他的操作，只要能完成自身的使命。
2) 具体类（Concrete Class）：实现父类中的抽象方法以完成算法中与特定子类相关的步骤。

适用情况
1) 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。
2) 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。其实这可
以说是一种好的编码习惯了。
3) 控制子类扩展。模板方法只在特定点调用操作，这样就只允许在这些点进行扩展。比如
上面runBare（）方法就只在runTest 前面适用setUp 方法。如果你不愿子类来修改你
的模板方法定义的框架，你可以采用两种方式来做：一是在API 中不体现出你的模板方
法；或者将你的模板方法置为final 就可以了。
可以看出，使用模板方法模式可以将代码的公共行为提取出来，达到复用的目的。而且，
在模板方法模式中，是由父类的模板方法来控制子类中的具体实现。这样你在实现子类的时
候，根本不需要对业务流程有太多的了解。