Template Method Pattern

Understanding the Template Method Pattern

The Template Method pattern is a behavioral design pattern that defines the skeleton of an algorithm in a base class but lets subclasses override specific steps of the algorithm without changing its structure. It enables you to reuse the common parts of an algorithm while allowing customization of the variable parts.

Problem

Imagine you're creating a data mining application that analyzes different document formats (CSV files, PDF documents, Excel spreadsheets). Regardless of the file format, the application needs to perform the same series of steps:

1. Open the file
2. Extract the data
3. Parse the data
4. Analyze the data
5. Generate a report
6. Close the file

The challenge is that some steps (like opening and closing the file) might be common across all file types, while others (like extracting and parsing data) will vary depending on the specific format.

Solution

The Template Method pattern suggests defining a skeleton algorithm in a base class method, called the template method. This method calls a series of other methods, some of which are implemented in the base class (known as "final methods") and others that are left abstract or given a default implementation (known as "hook methods").

Subclasses can then override the hook methods to provide specific implementations for the variable parts of the algorithm, without changing the overall structure defined by the template method.

Structure

Participants

• Abstract Class: Defines abstract primitive operations that concrete subclasses override to implement the steps of an algorithm. It also implements a template method that defines the skeleton of the algorithm.
• Concrete Class: Implements the primitive operations to carry out subclass-specific steps of the algorithm.

In the Template Method pattern, several types of operations may be called by the template method:

• Concrete Operations: Operations that are already implemented in the abstract class.
• Abstract Operations: Operations that must be implemented by subclasses.
• Hook Operations: Operations that have default implementations but can be overridden by subclasses if needed.

When to Use

Use the Template Method Pattern when:

• You want to implement the invariant parts of an algorithm once and leave the variant parts to subclasses.
• When common behavior among subclasses should be factored and localized in a common class to avoid code duplication.
• When you want to control the points at which subclasses can extend the algorithm.

Benefits

• Code Reuse: The template method pattern promotes code reuse by keeping the algorithm structure in a base class while allowing customization in subclasses.
• Inversion of Control: Often referred to as the "Hollywood Principle" ("Don't call us, we'll call you"), the template method controls when methods of subclasses are called.
• Clean Code: By separating the algorithm's structure from its implementation details, the code becomes more maintainable and easier to understand.
• Flexibility: You can override only the parts that need to change, keeping the rest of the algorithm intact.

Real-World Uses

• Framework Development: Many frameworks use the Template Method pattern to define the structure of operations while allowing customization by the application developer.
• Document Processing: Applications that process different document formats often use this pattern.
• Batch Processing: Systems that perform batch operations with a common workflow but specific processing requirements.
• UI Component Rendering: UI frameworks that define the rendering process but allow customization for specific components.
• Test Frameworks: Testing libraries often use template methods for test setup and teardown.

Implementation Example

Here's a JavaScript implementation of the Template Method pattern for a data processing system:

// Abstract Class
class DataProcessor {
    // Template Method - defines the algorithm skeleton
    process() {
        this.open();
        this.extract();
        this.transform();
        this.analyze();
        this.report();
        
        // Hook method with default implementation
        if (this.shouldClose()) {
            this.close();
        }
    }
    
    // Final method - same for all subclasses
    open() {
        console.log("Opening data source...");
    }
    
    // Abstract methods - must be implemented by subclasses
    extract() {
        throw new Error("extract() must be implemented by subclass");
    }
    
    transform() {
        throw new Error("transform() must be implemented by subclass");
    }
    
    // Final method - same for all subclasses
    analyze() {
        console.log("Analyzing processed data...");
    }
    
    // Abstract method - must be implemented by subclasses
    report() {
        throw new Error("report() must be implemented by subclass");
    }
    
    // Final method - same for all subclasses
    close() {
        console.log("Closing data source...");
    }
    
    // Hook method with default implementation
    shouldClose() {
        return true; // By default, always close the source
    }
}

// Concrete Class for CSV Files
class CSVProcessor extends DataProcessor {
    extract() {
        console.log("Extracting data from CSV file...");
    }
    
    transform() {
        console.log("Parsing CSV columns and rows...");
    }
    
    report() {
        console.log("Generating CSV report with column statistics...");
    }
}

// Concrete Class for Database
class DatabaseProcessor extends DataProcessor {
    extract() {
        console.log("Executing SQL query on database...");
    }
    
    transform() {
        console.log("Transforming query results into standardized format...");
    }
    
    report() {
        console.log("Generating database query performance report...");
    }
    
    // Override hook method
    shouldClose() {
        console.log("Keeping database connection open for future queries...");
        return false; // Don't close the database connection
    }
}

// Client code
console.log("Processing CSV File:");
const csvProcessor = new CSVProcessor();
csvProcessor.process();

console.log("\nProcessing Database:");
const dbProcessor = new DatabaseProcessor();
dbProcessor.process();

In this example, DataProcessor is the abstract class that defines the template method process(). This method establishes the algorithm's skeleton, calling various steps in a specific order. Some methods are implemented in the base class (like open(), analyze(), and close()), while others are left abstract (like extract(), transform(), and report()).

The CSVProcessor and DatabaseProcessor classes are concrete implementations that provide specific implementations for the abstract methods. Additionally, DatabaseProcessor overrides the hook method shouldClose() to customize the behavior of the algorithm.