模板方法(Template Method)模式

模板方法(Template Method)模式

隶属类别——类行为型模式

---

1. 意图

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

2. 别名

No

3. 动机

考虑一个提供Application的Document类的应用框架。Application类负责打开一个已有的以外部形式存储的文档，如一个文件。一旦一个文件中信息从该文件中读出后，它就由一个Document对象表示。

用框架构建的应用可以通过继承Application和Document来满足特定的需求。例如，一个绘图应用定义DrawApplication和Docuemnt子类；一个电子表格应用表示Spreadsheet-Application和SpreadsheetDocument子类，如下页图所示。

抽象的Application类在它的OpenDocument操作中定义了打开和读取一个文档的算法:

public class Application {
 
    private List<Document> docs = new ArrayList<Document>();
    
    public void openDocument(char name) {
        if (!canOpenDocument(name)) {
            // cannot handle this document
            return ;
        }
        Doucument doc = doCreateDocument();
        
        if (doc) {
           docs.add(doc);
           aboutToOpenDocument(doc);
            doc.open();
            doc.doRead();
        }
    }
}

OpenDocument定义了打开一个文档的每一个主要步骤。它检查该文档是否能够被打开，创建与应用相关的Document对象，将它加到定义的文档集合docs中，并且从一个文件中读取Document。

我们称OpenDocument为一个**模板方法(**template method).一个模板方法用一些抽象的操作定义一个算法，而子类将重定义这些操作以提供具体的行为。Application的子类将定义检查一个文档是否能够被打开(canOpenDocument)和创建文档(doCreateDocument)的具体算法步骤。Document子类将定义读取文档(doRead)的算法步骤。如果需要，模板方法也可以定义一个操作(aboutToOpenDocument)让Application子类知道该文档何时将被打开

通过使用抽象操作定义一个算法中的一些步骤，模板方法确定了它们的先后顺序，但允许Application和Document子类改变这些具体步骤以满足它们各自的需求。

4. 适用性

模板方法应用于下列情况

• 一次性实现一个算法的不变得部分，并将可变的行为留给子类来实现。
• 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复(分离出代码中变化的部分和不变的部分)。这是Opdyke和Johnson所描述的“重分解以一般化”的一个很好的例子[OJ93].首先识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
• 控制子类扩展。模板方法只在特定点调用“hook”操作，这样就只允许在这些点进行扩展。

5. 结构

6. 参与者

• AbstractClass(抽象类，如Application)

  ——定义抽象的原语操作(primitive operation) ,具体的子类将重定义它们以实现一个算法的各步骤。

  ——实现一个模板方法，定义一个算法的骨架。该模板方法不仅调用原语操作，也调用定义在AbstractClass或其他对象中的操纵

• ConcreteClass(具体类，如MyApplication)

  ——实现原语操作以完成算法中与特定子类相关的步骤。

7. 协作

• ConcreteClass靠AbstractClass来实现算法中不变的步骤。

8. 效果

模板方法是一种代码复用的基本技术。它们在类库中尤为重要，它们提取了类库中的公共行为。

模板方法导致一种反向的控制结构，这种结构有时被称为“好莱坞法则”，即“别找我们，我们会找你”。这指的是一个父类调用一个子类的操作，而不是相反。

模板方法调用下列类型的操作：

• 具体的操作(ConcreteClass或对客户类的操作)

• 具体的AbstractClass的操作(即，通常对子类有用的操作)

• 原语操作(即，抽象操作)(原语 操作系统或计算机网络用语范畴。是由若干条指令组成的，用于完成一定功能的一个过程。primitive or atomic action 是由若干个机器指令构成的完成某种特定功能的一段程序，具有不可分割性·即原语的执行必须是连续的，在执行过程中不允许被中断。)

• Factory Method

• 钩子操作(hook operations)，它提供了缺省的行为，子类可以在必要时进行扩展，一个钩子操作在缺省操作中通常是一个空操作。

  很重要的一点是模板方法应该指明那些操作是钩子操作(可以被重定义)以及哪些是抽象操作(必须被重定义)。要有效地重用一个抽象类，子类编写者必须明确了解哪些操作是设计为有待重定义的。

  子

子类可以通过重定义父类的操作来扩展该操作的行为，其间可以显式地调用父类操作。

public class ConcreteClass extends AbstractClass {
    
    @Override
    void operation() {
        // xxx some operation
        super.operation();
        // xxx some operation
    }
}

不幸的是，人们很容易忘记去调用该继承的行为。我们可以将这样一个操作转换为一个模板方法，以使得匪类可以对子类的扩展方式进行控制。也就是，在父类的模板方法中调用钩子操作。子类可以重定义这个钩子操作：

public class ParentClass {
    void operation() {
        hookOperation();
    }
    
    void hookOperation() {}
}

子类重定义hookOperation以扩展它的行为：

public class DerivedClass {
    
    @Override
    void hookOperation() {
        // derived class extension
    }
}

9. 实现

有三个实现问题值得注意：

• 1.使用Java访问控制 在Java中，一个模板方法调用的方法如果必须重定义的话，将其定义为抽象方法，钩子方法和抽象方法都可以定义为protected,另外模板方法和父类中不向子类进行修改的方法一般定义为final方法。
• 2.尽量减少抽象操作 定义模板方法的一个重要目标是尽量减少一个子类具体实现该算法时必须重定义的方法的数量，需要重定义的方法越多，客户程序就越冗长。
• 3.命名约定 可以给应被重定义的那些操作方法加上一个前缀识别它们。例如，用于Macintosh应用的Mac App框架[App89]给模板方法加上前缀"Do-",如"DoCreateDocument",“DoRead”,等等，阿里的Java开发手册中，要求的是使用具体模式，类，接口使用模式了，就直接指明出模式的具体的类型，个人觉得，hook方法可以加个hook前缀之类的，抽象方法就是直接用抽象关键字，模板方法可以用xxxTemplate()表示。

10. 代码示例

首先是AbstractClass——CaffeineBeverageWithHook.java

public abstract class CaffeineBeverageWithHook {
	final void prepareRecipeTemplate() {
		boilWater();
		brew();
		pourInCup();
		if (hookCustomerWantsCondiments()) {
			addCondiments();
		}
	}
	
	abstract void brew();
	
	abstract void addCondiments();
	// 不向让子类修改就可以定义为Final
	final void boilWater() {
		System.out.println("Boiling water");
	}
	// 不向让子类修改就可以定义为Final
	final void pourInCup() {
		System.out.println("Pouring into cup");
	}
	// This is hook method which is default method 
	boolean hookCustomerWantsCondiments() {
		return true;
	}
}

接下来是ConcreteClass——CoffeeWithHook & TeaWithHook

CoffeeWithHook.java

public class CoffeeWithHook extends CaffeineBeverageWithHook {
	
	@Override
	void brew() {
		System.out.println("Dripping Coffee through filter");
	}
	
	@Override
	void addCondiments() {
		System.out.println("Adding Sugar and Milk");
	}
	
	// hook method is overridden here
	@Override
	public boolean hookCustomerWantsCondiments() {
		String answer = getUserInput();
		if (answer.toLowerCase().startsWith("y")) {
			return true;
		} else {
			return false;
		}
	}
	
	private String getUserInput() {
		String answer = null;
		System.out.print("Would you like milk and sugar with your coffee (y/n)?");
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		try {
			answer = in.readLine();
		} catch (IOException ioe) {
			System.out.println("IO error trying to read your answer");
		} 
		if (answer == null) {
			return "no";
		}
		return answer;
	}
}

TeaWithHook.java

public class TeaWithHook extends CaffeineBeverageWithHook {
	
	@Override
	public void brew() {
		System.out.println("Steeping the tea");
	}
	
	@Override
	public void addCondiments() {
		System.out.println("Adding Lemon");
	}
	
	// Hook method is overridden here
	@Override
	public boolean hookCustomerWantsCondiments() {
		String answer = getUserInput();
		if (answer.toLowerCase().startsWith("y")) {
			return true;
		} else {
			return false;
		}
	}
	
	private String getUserInput() {
		String answer = null;
		System.out.print("Would you like lemon with your coffee (y/n)?");
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		try {
			answer = in.readLine();
		} catch (IOException ioe) {
			System.out.println("IO error trying to read your answer");
		} 
		if (answer == null) {
			return "no";
		}
		return answer;
	}
}

最后是测试类Client——BeverageTestDrive.java

public class BeverageTestDrive {

	public static void main(String[] args) {
		
		TeaWithHook teaHook = new TeaWithHook();
		CoffeeWithHook coffeeWithHook = new CoffeeWithHook();
		
		// prepare tea
		System.out.println("\nMaking tea...");
		teaHook.prepareRecipeTemplate();
		
		// prepare coffee
		System.out.println("\nMake coffee...");
		coffeeWithHook.prepareRecipeTemplate();
	}
}

以及对应的测试结果

Making tea...
Boiling water
Steeping the tea
Pouring into cup
Would you like lemon with your coffee (y/n)?n

Make coffee...
Boiling water
Dripping Coffee through filter
Pouring into cup
Would you like milk and sugar with your coffee (y/n)?y
Adding Sugar and Milk

最后附上对应Beverage对应类图的UML图：

11. 已知应用

模板方法非常基本，它们几乎可以在任何一个抽象类中找到。

模板方法在JDK中应用(好像确实是，只不过没把方法名定义为跟Template相关命名风格，并没有添加关键字final,更像是重写)：

• All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer.
• All non-abstract methods of java.util.AbstractList, java.util.AbstractSet and java.util.AbstractMap.

12. 相关模式

• Factory Method(工厂方法)模式： 常被模板方法调用，在动机的例子中, doCreateDocument()就是一个Factory Method， 它由模板方法openDocument调用。
• Strategy(策略)模式：模板方法使用继承来改变算法的一部分，Strategy使用委托来改变整个算法。

13. 设计原则口袋

• 封装变化

• 针对接口编程，不要针对实现编程

• 多用组合，少用继承

• 为交互对象之间的松耦合设计而努力

• 类应该对扩展开放，对修改关闭

• 依赖抽象，不要依赖具体类

• 只有几个密友交谈

• 好莱坞原则——别调用(打电话)我们，我们会调用(打电话)你

  这里展开解释一些，在好莱坞原则之下，我们允许底层组件将自己挂钩到系统上，但是高层组件会决定什么时候和怎样使用这些底层组件。换句话说，高层组件对待底层组件的方式是"别调用我们，我们会调用你"。好莱坞原则教我们一个技巧，创建一个有弹性的设计，允许低层结构能够互相操作，而又防止其他类太过依赖他们。

  • Q：底层组件不可以调用高层组件吗？
  • A：并不尽然，事实上，底层组件在结束时，常常会调用从超类中继承来的方法，我们要做的是，避免让高层和低层组件有明显的环状依赖。

参考文献

《HeadFirst设计模式》

《设计模式：可复用面向对象软件的基础》

​