Template Method

Real-world analogy

Building a pre-fabricated residential home follows a strict construction template:

1. Pour reinforced concrete foundation
2. Erect structural framing
3. Install plumbing and electrical conduits
4. Mount roof shingles
5. Paint exterior walls

A homebuyer cannot change the sequence—you cannot install roof shingles before pouring the foundation. However, the buyer can customize the concrete finish, select drywall textures, and choose exterior paint colors. The construction company defines the invariant building skeleton, while the homeowner customizes designated template steps.

The problem

You are building a data ingestion engine for an enterprise analytics warehouse. The pipeline ingests documents from various formats: CSV files, JSON payloads, and XML documents.

Every document ingestion follows the exact same operational sequence:

1. Open the file connection.
2. Read raw text data.
3. Parse records into memory.
4. Validate schema and required fields.
5. Persist records to the database.
6. Close the file connection and log audit metrics.

Without the Template Method pattern, developers copy-paste the entire 6-step workflow into separate CsvParser, JsonParser, and XmlParser classes:

1 // Naive implementation: Duplicate algorithm skeleton across classes
2 class CsvParser {
3   process(filePath) {
4     console.log(`Opening file: ${filePath}`);
5     const raw = "csv,data,here";
6     console.log("Parsing CSV lines...");
7     const records = [{ id: 1 }];
8     console.log("Validating records...");
9     console.log("Saving records to database...");
10     console.log(`Closing file: ${filePath}`);
11   }
12 }
13 
14 class JsonParser {
15   process(filePath) {
16     console.log(`Opening file: ${filePath}`); // Duplicated opening logic
17     const raw = '{"json": true}';
18     console.log("Parsing JSON tokens...");  // Unique variation
19     const records = [{ id: 2 }];
20     console.log("Validating records...");   // Duplicated validation logic
21     console.log("Saving records to database..."); // Duplicated persistence
22     console.log(`Closing file: ${filePath}`); // Duplicated cleanup
23   }
24 }

1 public class Example {
2     static class CsvParser {
3         public void process(String path) {
4             System.out.println("Open " + path);
5             System.out.println("Parse CSV records");
6             System.out.println("Validate and save");
7             System.out.println("Close " + path);

If a bug is discovered in resource cleanup, exception logging, or transaction commit logic, developers must fix the bug across every duplicated parser class.

The solution

The Template Method pattern defines the skeleton of an algorithm in a base class method, deferring specific steps to subclasses. Subclasses can override individual steps (or optional hooks) without modifying the invariant structure and order of the algorithm.

• Abstract Class (DataMiner): Declares the templateMethod() defining the sequence of steps, concrete helper steps, and abstract steps that subclasses must implement.
• Concrete Classes (CsvMiner, JsonMiner): Implements the specific steps (parse(), extractRecords()).
• Client: Calls the template method on the base class abstraction.

Step-by-step implementation

Step 1: Define the abstract base class and template method

The base class implements the invariant algorithm sequence.

Step 2: Implement concrete subclasses

Subclasses override only the variable parsing step and any desired hooks.

Step 3: Client invokes the template method

The client triggers the template method polymorphically.

1 const csv = new CsvMiner();
2 csv.mine("transactions.csv");
3 
4 const json = new JsonMiner();
5 json.mine("events.json");

1 public class Example {
2     abstract static class DataMiner { public void mine(String p) {} }
3     static class

The complete example

Here is the complete, runnable implementation demonstrating ETL ingestion with abstract steps and optional hooks.

1 === Processing: orders_2026.csv ===
2 [Storage] Opened file descriptor: orders_2026.csv
3 [CsvParser] Split lines by newline and cells by comma: payload_content_from_orders_2026.csv
4 [Telemetry] Recorded metric: 150 records ingested.
5 [Storage] Released file lock: orders_2026.csv
6 === Completed: orders_2026.csv ===
7 
8 === Processing: audit_logs.json ===
9 [Storage] Opened file descriptor: audit_logs.json
10 [JsonParser] Deserialized JSON object graph: payload_content_from_audit_logs.json
11 [Storage] Released file lock: audit_logs.json
12 === Completed: audit_logs.json ===

Variations

Hooks and the "Hollywood Principle"

The Hollywood Principle ("Don't call us, we'll call you") describes the inversion of control at the core of Template Method. In standard procedural programming, client code continuously invokes utility library functions. With Template Method, the high-level parent class calls down into subclass hook methods:

• Abstract Steps: Must be overridden by subclasses (e.g. parseRecords()).
• Concrete Steps: Invariant default logic implemented by the parent (e.g. openFile(), closeFile()).
• Hooks: Optional methods providing default or no-op behavior (e.g. shouldSendMetrics()). Subclasses selectively override hooks to intercept execution without breaking the template.

Template Method vs Strategy

• Template Method (Inheritance): Operates at the class level. The algorithm skeleton is statically defined at compile time in a superclass, with subclasses providing specific step implementations. Cannot change algorithm parts at runtime once an instance is created.
• Strategy (Composition): Operates at the object level. The algorithm is fully encapsulated in an independent strategy object. Strategies can be swapped dynamically at runtime without subclassing.

Where you've already used it

• javax.servlet.http.HttpServlet: The service() method implements the template method, parsing headers and invoking overridden doGet(), doPost(), or doPut() hook methods.
• Spring JdbcTemplate & TransactionTemplate: Manages connection acquisition, transaction commit, rollback, and cleanup, delegating SQL row mapping to custom callback steps.
• Java AbstractList / AbstractMap: Implements high-level collection methods (addAll, contains, toString) based on subclasses providing core primitive steps (get(index), size()).
• React Class Lifecycle: React's component rendering engine dictates the exact sequence (constructor -> render -> componentDidMount).

Pros and cons

When not to use it

Do not use Template Method when algorithm variations need to be swapped dynamically at runtime. If you need dynamic runtime configuration, use Strategy instead.

Related patterns

Interview questions

What is the 'Hollywood Principle' and how does Template Method embody it? The Hollywood Principle states 'Don't call us, we'll call you.' In Template Method, the high-level superclass controls the execution sequence and calls down into subclass methods when required, inverting traditional dependency flow.

How does Template Method differ from Strategy? Template Method uses inheritance to vary specific steps of an algorithm at compile time. Strategy uses composition to swap entire algorithms dynamically at runtime.

Why should the template method itself be declared final in Java? Declaring the template method final prevents subclasses from overriding the master algorithm sequence, ensuring critical invariant steps (such as security checks, transactions, and resource cleanup) cannot be bypassed.

What is the difference between an abstract step and a hook method? An abstract step has no implementation in the base class; subclasses are strictly forced by the compiler to implement it. A hook has a default (often empty) implementation in the base class, making subclass overriding entirely optional.