Template Method

The Template Method Pattern is a behavioral design pattern that defines the programmatic skeleton of an algorithm in a base class, delegating specific execution steps to subclasses. By locking the overarching algorithm flow within a final method while exposing abstract hook methods for variant steps, it maximizes code reuse and enforces consistent step ordering.

1. Learning Objectives

• Identify duplicate procedural skeletons across multiple classes and extract them into template patterns.
• Differentiate between the roles of abstract methods and optional Hook methods.
• Apply the Hollywood Principle ("Don't call us, we'll call you") to manage parent-child call structures.
• Analyze vtable (virtual method table) dynamic lookup costs for virtual hook dispatches.
• Implement the Non-Virtual Interface (NVI) variant of the Template Method pattern in C++.

2. Problem & Naive Solution

Suppose you are building a data ingestion engine. The system imports records from various raw source formats: CSV files and JSON files. For both formats, the parsing steps follow a strict sequence:

1. Open the file stream socket.
2. Extract the raw records into an internal model.
3. Perform validation checks (e.g. check for null values).
4. Close the file stream socket to prevent memory leaks.

The Naive Solution

A developer might implement independent classes for each parser type, copy-pasting the lifecycle logic:

This copy-paste approach exposes several design flaws:

• Code Duplication: The socket opening, error validation logs, and closing operations are duplicated across all parser classes.
• Brittle Stream Closures: If a subclass developer forgets to close the file stream inside a custom try-catch block, the system leaks file descriptors, risking thread hangs.
• Inconsistent Steps: Different developers might skip steps (e.g. bypassing validation checks), causing data corruption downstream.

3. Issues

Without a unified base algorithm template, you cannot guarantee consistent execution steps. Adding validation policies or diagnostic logs requires modifying all parser classes individually, violating DRY (Don't Repeat Yourself) guidelines.

4. Pattern Introduction & UML

The Template Method Pattern addresses this by defining the algorithm skeleton inside an abstract base class (DataParser). The main execution method is declared final to prevent subclasses from altering the step sequence. The base class implements standard steps (like opening and closing files) and exposes abstract methods (like extractData()) for subclasses to implement custom parsing logic.

UML: Data Parsing Pipeline

5. Participants

• Abstract Class (DataParser): Declares the final template method defining the algorithm steps, along with abstract hooks for sub-steps.
• Concrete Class (CsvParser, JsonParser): Overrides the abstract steps to implement format-specific parsing algorithms.

6. Theory (The Hollywood Principle & Hooks)

The Template Method pattern relies on key architectural principles:

• Hollywood Principle: "Don't call us, we'll call you." Concrete subclasses do not call parent methods directly. Instead, the parent class invokes the subclass implementations at the appropriate step in the algorithm flow.
• Abstract Methods vs. Hooks: - *Abstract Methods*: Must be overridden by subclasses to implement mandatory steps of the algorithm. - *Hooks*: Concrete methods in the base class with default implementations. Subclasses can optionally override them to alter the template flow (e.g., toggling validation checks via a boolean hook).

7. Syntax Explanation

Syntax structures for templates in different languages:

• Java: Uses final keywords on the template method (public final void parse()) to prevent subclasses from overriding and breaking the step sequence.
• Python: Lacks final methods at compiler level, but relies on properties or naming conventions (e.g., prefixing with underscores) to signal read-only status.
• C++: Implements the Non-Virtual Interface (NVI) pattern. The template method is public and non-virtual, while the customizable steps are declared private virtual virtual helper functions, enforcing encapsulation.

8. Step-by-Step Implementation

1. Step 1: Create the abstract base class and declare the template method as final/non-virtual.
2. Step 2: Write the step-by-step algorithm flow inside the template method.
3. Step 3: Declare the shared steps as helper methods in the base class.
4. Step 4: Declare variant steps as abstract or virtual methods, and write default behaviors for optional hook methods.
5. Step 5: Create subclass implementations overriding the abstract/hook methods to customize execution steps.

9. Complete Code (Mini Project)

10. Code Walkthrough

Let's review the framework delegation:

• Algorithm Guard: Declaring parseDataFile() as final in Java and non-virtual in C++ prevents subclasses from altering the step sequence, ensuring that connection closure and validation always execute in order.
• Hollywood Call Structure: The client invokes parseDataFile(). The base class executes shared logic and calls extractData(), delegating control to the subclass implementation.
• NVI Pattern Encapsulation: In the C++ example, the public template method is non-virtual, while the customizable steps are declared private virtual helper functions. This ensures subclasses cannot access or invoke the sub-steps directly.

11. Execution Flow

1. Client Invocation: Client calls parseDataFile() on the parser subclass.
2. Shared Init: The base class opens the file stream resource.
3. Subclass Extraction: The base class calls extractData(), executing the subclass implementation.
4. Hook Check: The base class checks customerWantsValidation(). If true, it runs validation.
5. Shared Cleanup: The base class closes the file stream.

12. Internal Working (vtable Dispatch Optimizations)

Virtual method invocations introduce a minor compile-time and runtime cost:

• vtable Lookup: Calling virtual methods (like extractData()) requires looking up the method address in the class's Virtual Method Table (vtable) at runtime, adding a slight performance overhead compared to direct static method binding.
• NVI Performance Benefits: The Non-Virtual Interface (NVI) pattern ensures that only variant steps incur virtual dispatch costs, while shared helper methods use faster direct static method binding.

13. Complexity Analysis

• Time Complexity: $O(1)$ constant time overhead to resolve the virtual method dispatch.
• Space Complexity: $O(1)$ constant memory overhead to hold base class reference pointers.

14. Best Practices

• Keep the Template Method Final: Always use the final keyword (Java) or declare the method as non-virtual (C++) to prevent subclasses from overriding and altering the core algorithm skeleton.
• Minimize Abstract Steps: Limit the number of abstract methods subclasses must implement to reduce developer integration overhead.

15. Common Mistakes

• Omitting Final Access modifiers: Allowing subclasses to override the template method, compromising the integrity of the algorithm skeleton.
• Violating Liskov Substitution: Subclass implementations overriding virtual methods in a way that breaks base class invariants or expectations.

16. Framework Usage

• Spring's JdbcTemplate: Spring uses Template Method to manage database connection lifecycles, statement preparation, and transaction scopes, letting developers focus on writing SQL.
• Java Servlets: The servlet container invokes the base class service() template method, which automatically routes requests to subclass implementations like doGet() or doPost().

17. Interview Discussion

18. Practice Exercises

• Easy: Write a Python program simulating an order processing pipeline with steps: validation, payment, and packaging.
• Medium: Design a GameLoader template with steps for downloading assets, checking updates, and launching the game.
• Hard: Build a microservice code build compiler pipeline supporting steps: compilation, unit testing, static lint analysis, and cloud deployment, using hooks to skip linting in debug mode.

19. Challenge Problem

Design an Enterprise Web Crawler Engine. The crawler operates in a loop: fetches raw page source, parses page URLs, extracts page content, and indexes indices. Different indexers parse formats uniquely (e.g. HTML, PDF). If indexing fails, the crawler must log transaction errors and update site tables. Write this crawler engine in Java, Python, or C++ and verify crawl executions across multiple format types.

20. Summary & Cheat Sheet

• Template Method defines algorithm skeletons in a base class, delegating steps to subclasses.
• Always use final (Java) or non-virtual (C++) modifiers on template methods to protect the algorithm flow.
• Use hooks to let subclasses optionally override or toggle parts of the execution flow.
• Subclasses are managed by the parent class, adhering to the Hollywood Principle.

21. Quiz

22. Next Lesson Preview

In the next lesson, we will explore the Chain of Responsibility Pattern. We will learn how to pass requests along a chain of handlers, letting each handler decide whether to process the request or pass it to the next link!