Template Method Pattern in Java – Define the Skeleton of an Algorithm

Introduction

The Template Method Pattern is a behavioral design pattern that defines the skeleton of an algorithm in a method, deferring some steps to subclasses. It allows subclasses to redefine certain steps of the algorithm without changing its structure.

It’s a powerful tool in object-oriented design, promoting code reuse, consistency, and control over the flow of logic—making it widely applicable in frameworks, batch jobs, data processing pipelines, and beyond.

---

☑️ Core Intent and Participants

Intent: Define the skeleton of an algorithm in a base class but let subclasses override specific steps of that algorithm.

Participants:

• Abstract Class (Template): Defines the template method and steps (some abstract).
• Concrete Subclasses: Implement the steps defined as abstract or hook methods.

UML Diagram (Textual)

+---------------------+
|   AbstractClass     |
+---------------------+
| +templateMethod()   |
| +step1()            |
| +step2()            |  <-- abstract or overridable
+---------------------+
         ^
         |
+---------------------+
| ConcreteSubclassA   |
+---------------------+
| +step2()            |
+---------------------+

---

🚀 Real-World Use Cases

• Report generation: Define template to open → process → close
• Framework hooks: Spring, JUnit, Servlet lifecycle methods
• Data import/export: Read → Parse → Process → Write
• AI game design: Move → Evaluate → Act
• Authentication flows: Validate → Authenticate → Post-process

---

💡 Java Implementation

Step 1: Abstract Template Class

public abstract class DataProcessor {
    public final void process() {
        readData();
        processData();
        writeData();
    }

    protected abstract void readData();
    protected abstract void processData();
    protected abstract void writeData();
}

Step 2: Concrete Implementations

public class CSVDataProcessor extends DataProcessor {
    @Override
    protected void readData() {
        System.out.println("Reading data from CSV file");
    }

    @Override
    protected void processData() {
        System.out.println("Processing CSV data");
    }

    @Override
    protected void writeData() {
        System.out.println("Writing data to CSV file");
    }
}

public class XMLDataProcessor extends DataProcessor {
    @Override
    protected void readData() {
        System.out.println("Reading data from XML file");
    }

    @Override
    protected void processData() {
        System.out.println("Processing XML data");
    }

    @Override
    protected void writeData() {
        System.out.println("Writing data to XML file");
    }
}

Step 3: Demo

public class Demo {
    public static void main(String[] args) {
        DataProcessor csv = new CSVDataProcessor();
        csv.process();

        System.out.println();

        DataProcessor xml = new XMLDataProcessor();
        xml.process();
    }
}

---

✅ Pros and Cons

✅ Pros

• Promotes code reuse
• Provides a consistent algorithm structure
• Reduces duplication and promotes DRY principle
• Encapsulates invariant logic in base class

❌ Cons

• Inflexible due to inheritance
• Can lead to class explosion if too many variations are needed
• Overridden methods may violate algorithm expectations

---

🔥 Anti-patterns and Misuse

• Violating Liskov Substitution Principle (overriding steps with incompatible logic)
• Making template method overridable (it should be final)
• Hardcoding logic in the base class that should be flexible

---

🔁 Related Patterns Comparison

Pattern	Purpose
Template Method	Define algorithm skeleton
Strategy	Select behavior via composition
Factory Method	Delegate object creation to subclasses
Command	Encapsulate request as an object

🟡 Template vs Strategy: Template uses inheritance (fixed algorithm), Strategy uses composition (fully replaceable).

---

🔄 Refactoring Legacy Code

Refactor repetitive logic across similar subclasses into a base class with a template method. Extract the unique parts into abstract methods.

---

🧠 Best Practices

• Keep the template method final to prevent alteration of algorithm flow
• Extract optional steps into hook methods
• Use abstract class only when reuse is meaningful
• Favor composition over inheritance if flexibility is needed

---

🧩 Real-World Analogy

Coffee Brewing Process
Steps like boilWater → brew → pourInCup → addCondiments form a fixed sequence. You can override only addCondiments (milk, sugar, etc.) but not the full process.

---

🧪 Java Version Relevance

✅ Java 8+

Use default methods in interfaces for simple templates, but inheritance is still the primary approach.

public interface ReportGenerator {
    default void generate() {
        fetchData();
        process();
        save();
    }

    void fetchData();
    void process();
    void save();
}

---

📝 Conclusion and Key Takeaways

• Template Method defines the skeleton of an algorithm with flexibility to override certain steps.
• Ideal when you want consistent flow with pluggable behavior.
• Great for frameworks and standardized operations.

✅ Use when: Common algorithm steps exist across multiple classes.
🚫 Avoid when: Inheritance is restrictive or runtime behavior changes are needed.

---

❓ FAQ – Template Method Pattern in Java

1. What problem does Template Method solve?

It defines a common algorithm structure while allowing customization of specific steps.

2. Can interfaces be used for template methods?

Yes, using default methods in Java 8+, but limited to simpler use cases.

3. Why make template method final?

To prevent subclasses from changing the flow of the algorithm.

4. How is it used in frameworks like Spring?

Lifecycle hooks like afterPropertiesSet(), init(), etc., follow this pattern.

5. What's a hook method?

A method in the base class with default (often empty) implementation that subclasses may override.

6. When should I avoid Template Method?

If behavior varies too much across subclasses—use Strategy instead.

7. Is Template Method thread-safe?

Depends on shared state and mutable fields; base class should avoid shared mutable state.

8. Can Template Method and Strategy be combined?

Yes, a template method may use strategies internally for certain steps.

9. Is it good for data pipelines?

Yes. It’s ideal for defining standard processing pipelines with step customization.

10. Does this pattern require inheritance?

Yes, it is based on class inheritance by design.

---