Template Method Pattern: Don't Call Us, We'll Call You!

So far, the Template Method has been my most used design pattern. That is the reason why this post is quite long. J

Definition from Wiki

The Template Method defines the program skeleton of an algorithm in a method, deferring some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm's structure.

A Real World Use Case

Imagine that you have many different kinds of documents. You want to generate a pdf file from a corresponding word template. Each type has its own small modifications but the main process for document generating is the same.

We apply the Template Method for this case. We define a final method including some steps (such as preparing for content, generating file) at a superclass. There are three possibilities for these steps at subclasses:

1. Must be overridden: abstract methods.
2. Not mandatory to be overridden: default protected methods.
3. Can not be overridden: default private methods.

	abstract class AbstractDocumentGenerator{
	//THIS IS TEMPLATE METHOD
	public final File generate() {
	Document defaultDocument = prepareDocumentByDefault();
	Document refinedDocument = redefineDocument(defaultDocument);
	String templatePath = getTemplatePath();
	String outputName = getOutputName();
	return DocFactory.generate(refinedDocument, templatePath, outputName);
	}
	//This method is implemented at this class, can not be overridden
	private Document prepareDocumentByDefault() {
	Document document = new Document();
	//TODO: prepare default here
	return document;
	}
	//This is hook/default method which can be overridden by subclasses
	protected Document redefineDocument(Document defaultDocument) {
	return defaultDocument;
	}
	//These method must be implemented by subclass
	protected abstract String getOutputName();
	protected abstract String getTemplatePath();
	}
	class PaymentRequestDocumentGenerator extends AbstractDocumentGenerator {
	@Override
	protected String getOutputName() {
	return "payment_request.pdf";
	}
	@Override
	protected String getTemplatePath() {
	return "/home/document_template/payment_request.docx";
	}
	}
	class StandingOrderDocumentGenerator extends AbstractDocumentGenerator {
	@Override
	protected String getOutputName() {
	return "standing_order.pdf";
	}
	@Override
	protected String getTemplatePath() {
	return "/home/document_template/standing_order.docx";
	}
	//Override the default method
	@Override
	protected Document redefineDocument(Document defaultDocument) {
	defaultDocument.setDescription("Overriden the default");
	return defaultDocument;
	}
	}

view raw TemplateMethodDemo.java hosted with ❤ by GitHub

Dissecting the Pattern

Simply, we can see the following attributes:

• Superclass has a "template" method which should be final to prevent subclasses from reworking the algorithm.
• The template method defines the sequence of steps, each represented by a method.
• Some methods are handled by the superclass.
• Some methods are handled by subclasses.

Benefit? Why?

• Reuse, avoiding duplication, and subclasses just need to implement a couple of methods.
• The algorithm lives in one place and code changes only need to be made there.

Hooked on Template Method

A hook is a method that is declared in the abstract class but only given an empty or default implementation. This gives subclasses the ability to "hook into" the algorithm at various points if they wish; a subclass is also free to ignore the hook.

The Hollywood Principle

We allow low-level components to hooking themselves into a system, but high-level components determine when they are needed, and how. In other words, the high-level components give the low-level components a "don't call us, we'll call you" treatment.

Template Method & Strategy: Inheritance vs. Delegation

Template Method and Strategy both solve the problem of separating a generic algorithm from a detailed context. They can often be used interchangeably. However, Template Method uses inheritance to solve the problem, whereas Strategy uses composition/delegation.

Inheritance was a highlight feature in the early days of OO. That is, given some class that did something almost useful to us, we could create a subclass and change only the bits we didn't like. However, inheritance was very easy to overuse; that is a reason why we have heard of a lot of "Favor object composition over class inheritance". That is, inheritance is a very strong relationship. Derivatives are inextricably bound to their base classes. Anyway, that doesn't mean we should avoid using inheritance.

The Strategy provides one extra benefit over the Template Method. Whereas the Template Method allows a generic algorithm to manipulate many possible detailed implementations, the Strategy by fully conforming to Dependency Injection Principle (DIP) allows each detailed implementation to be manipulated by many different generic algorithms.

	//Which the same way to solve a problem
	//Template Method uses Inheritance
	//Strategy uses Composition/Delegation
	abstract class TemplateMethod{
	public final void execute() {
	doFirstThing();
	doSecondthing();
	}
	//modifier can be public, private, protected
	abstract void doFirstThing();
	abstract void doSecondthing();
	}
	class FirstConcreateTemplateMethod extends TemplateMethod{
	@Override
	void doFirstThing() {}
	@Override
	void doSecondthing() {}
	}
	class SecondConcreateTemplateMethod extends TemplateMethod{
	@Override
	void doFirstThing() {}
	@Override
	void doSecondthing() {}
	}
	class Strategy{
	private Strategable strategable; //the concrete implementation is interchangeable
	public void execute() {
	strategable.doFirstThing();
	strategable.doSecondthing();
	}
	}
	interface Strategable{
	//modifier always is public
	void doFirstThing();
	void doSecondthing();
	}
	class FirstConcreteStrategy implements Strategable{
	@Override
	public void doFirstThing() {}
	@Override
	public void doSecondthing() {}
	}

view raw StrategyVsTemplateMethod.java hosted with ❤ by GitHub

References:
[1]. Bert Bates, Kathy Sierra, Eric Freeman, and Elisabeth Robson, Head First Design Patterns, A Brain-Friendly Guide
[2]. Robert C. Martin, Agile Software Development, Principles, Patterns, and Practices
[3]. https://en.wikipedia.org/wiki/Template_method_pattern