Skip to main content

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.

Template Method UML.svg

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.

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.

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

Labels:

Comments

Post a Comment

Popular posts from this blog

The HelloWorld example of JSF 2.2 with Myfaces

I just did by myself create a very simple app "HelloWorld" of JSF 2.2 with a concrete implementation Myfaces that we can use it later on for our further JSF trying out. I attached the source code link at the end part. Just follow these steps below: 1. Create a Maven project in Eclipse (Kepler) with a simple Java web application archetype "maven-archetype-webapp". Maven should be the best choice for managing the dependencies , so far. JSF is a web framework that is the reason why I chose the mentioned archetype for my example. 2. Import dependencies for JSF implementation - Myfaces (v2.2.10) into file pom.xml . The following code that is easy to find from  http://mvnrepository.com/  with key words "myfaces". <dependency> <groupId>org.apache.myfaces.core</groupId> <artifactId>myfaces-api</artifactId> <version>2.2.10</version> </dependency> <dependency> <groupId>org.apache.myfaces.core<...
Post a Comment
Read more

Junit - Test fails on French or German string assertion

In my previous post about building a regex to check a text without special characters but allow German and French . I met a problem that the unit test works fine on my machine using Eclipse, but it was fail when running on Jenkins' build job. Here is my test: @Test public void shouldAllowFrenchAndGermanCharacters(){ String source = "ÄäÖöÜüß áÁàÀâÂéÉèÈêÊîÎçÇ"; assertFalse(SpecialCharactersUtils.isExistSpecialCharater(source)); } Production code: public static boolean isExistNotAllowedCharacters(String source){ Pattern regex = Pattern.compile("^[a-zA-Z_0-9_ÄäÖöÜüß áÁàÀâÂéÉèÈêÊîÎçÇ]*$"); Matcher matcher = regex.matcher(source); return !matcher.matches(); } The result likes the following: Failed tests: SpecialCharactersUtilsTest.shouldAllowFrenchAndGermanCharacters:32 null A guy from stackoverflow.com says: "This is probably due to the default encoding used for your Java source files. The ö in the string literal in the J...
5 comments
Read more

Why Business Rules Engine Matter

"A good DSL minimizes the 'communication gap' between a domain concept and the code that implements it" - Robert C. Martin A Use Case It looks like adopting a new technology is always driven by a business need. The organizations, such as banks, have their own business processes (such as data gathering and document management). These processes are different from others but usually the differences are not big. How do we build a product which can be reused the similar features but still be adaptable with the specific requirements of each bank? Then, the answer is we should have a library/framework. There is an idea that we can implement this library/framework by using a business rules engine. Which has the following benefits: Be able to modify implementation of business domain at runtime (such as XML, CSV) S ource code is more readable for both developers and domain experts. Therefore, source code can be consider it as a document Since Business Rules Engine...
Post a Comment
Read more

Java 8 - Persistent data structure

The following is a series of posts about "functional programming in Java" which is the result of my understanding by reading the book " Java 8 in Action: Lambdas, Streams, and Functional-style Programming, by Alan Mycroft and Mario Fusco ". 1. Why functional programming? 2. Functional programming in Java 8 3. Java 8 - Using Functions as Values 4. Java 8 - Persistent data structure Persistent data structure is also known as a simple technique but it's very important. Its other names are functional data structure and immutable data structure. Why is it "persistent"? Their values persist and are isolated from changes happening elsewhere. That's it! This technique is described as below: If you need a data structure to represent the result of a computation, you should make a new one and not mutable an existing data structure. Destructive updates version public static A doSomething(A a){ a.setProp1("new value"); return...
1 comment
Read more

Building Axon.ivy Projects on Bitbucket Pipelines

Read me  if you don't know what Axon.ivy (Ivy) is. Motivation -  Ivy projects are designed to be built on a continuous integration (CI) server like Jenkins - Today, Bitbucket supports for CI with Bitbucket Pipelines - We're using Bitbucket. Then, why not? It must be very cool and convenient for us if we can centralize our CI and VCS (version control system) tools in one place. Here is an approach We have to use a maven plugin called project-build-plugin  to build ivy projects. This plugin requires an instance of Ivy engine during building time. Bitbucket Pipelines allows us to specify our own docker image as a build environment. What we need to do  is to prepare our docker image with needed stuffs such as JDK, Maven, Ivy engine, etc. Step 1. Prepare Docker images For testing purpose, I already created two docker images: Maven and Axon.ivy engine. They are now available on Docker Hub This image for Maven using Oracle JDK 8 This image for Axon.iv...
Post a Comment
Read more