{"id":44793,"date":"2015-09-30T06:41:32","date_gmt":"2015-09-30T03:41:32","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=44793"},"modified":"2023-12-07T13:06:39","modified_gmt":"2023-12-07T11:06:39","slug":"template-design-pattern","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2015\/09\/template-design-pattern.html","title":{"rendered":"Template Design Pattern Example"},"content":{"rendered":"

This article is part of our Academy Course titled Java Design Patterns<\/a>.<\/em><\/p>\n

In this course you will delve into a vast number of Design Patterns and see how those are implemented and utilized in Java. You will understand the reasons why patterns are so important and learn when and how to apply each one of them. Check it out here<\/a>!F<\/p>\n

\n

Table Of Contents<\/h4>\n
\n
1. Introduction<\/a><\/dt>\n
2. What is the Template Design Pattern<\/a><\/dt>\n
3. Implementing the Template Design Pattern<\/a><\/dt>\n
4. Introducing a hook inside the template<\/a><\/dt>\n
5. When to use the Template Design Pattern<\/a><\/dt>\n
6. Template Pattern in JDK<\/a><\/dt>\n
7. Download the Source Code<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. Introduction<\/h2>\n

The Template Design Pattern is a behavior pattern and, as the name suggests, it provides a template or a structure of an algorithm which is used by users. A user provides its own implementation without changing the algorithm’s structure.<\/p>\n

It is easier to understand this pattern with the help of a problem. We will understand the scenario in this section and will implement the solution using the Template pattern in a later section.<\/p>\n

Have you ever connected to a relation database using your Java application? Let\u2019s recall some important steps which are required to connect and insert data into the database. First, we need a driver according to the database we want to connect with. Then, we pass some credentials to the database, then, we prepare a statement, set data into the insert statement and insert it using the insert command. Later, we close all the connections, and optionally destroy all the connection objects.<\/p>\n

You need to write all these steps regardless of any vendor\u2019s relational database. Consider a problem where you need to insert some data into the different databases. You need to fetch some data from a CSV file and have to insert it into a MySQL database. Some data comes from a text file and which should be insert into an Oracle database. The only difference is the driver and the data, the rest of the steps should be the same, as JDBC provides a common set of interfaces to communicate to any vendor\u2019s specific relation database.<\/p>\n

We can create a template, which will perform some steps for the client, and we will leave some steps to let the client to implement them in its own specific way. Optionally, a client can override the default behavior of some already defined steps.<\/p>\n

Now, before implementing the code, let\u2019s know more about the Template Design Pattern.<\/p>\n

<\/a>2. What is the Template Design Pattern<\/h2>\n

The Template Pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses to redefine certain steps of an algorithm without changing the algorithm’s structure.<\/p>\n

The Template Method pattern can be used in situations when there is an algorithm, some steps of which could be implemented in multiple different ways. In such scenarios, the Template Method pattern suggests keeping the outline of the algorithm in a separate method referred to as a template method inside a class, which may be referred to as a template class, leaving out the specific implementations of the variant portions (steps that can be implemented in multiple different ways) of the algorithm to different subclasses of this class.<\/p>\n

The Template class does not necessarily have to leave the implementation to subclasses in its entirety. Instead, as part of providing the outline of the algorithm, the Template class can also provide some amount of implementation that can be considered as invariant across different implementations. It can even provide default implementation for the variant parts, if appropriate. Only specific details will be implemented inside different subclasses. This type of implementation eliminates the need for duplicate code, which means a minimum amount of code to be written.<\/p>\n

\"Figure<\/a>
Figure 1<\/figcaption><\/figure><\/p>\n

AbstractClass<\/strong><\/p>\n