Dependency Injection and the Template Method Pattern: Reusing Algorithms

Combining Dependency Injection and Template Method Pattern 🚀

The Template Method Pattern defines the skeleton of an algorithm in a base class, allowing subclasses to override specific steps without changing the algorithm's structure. Dependency Injection (DI) provides the dependencies needed by a class from external sources rather than creating them internally. Combining these two patterns enhances algorithm reusability and flexibility.

Template Method Pattern Refresher ⚙️

The Template Method Pattern involves:

• Abstract Class: Defines the template method (algorithm's skeleton).
• Concrete Classes: Implement the abstract operations.

// Abstract class defining the template method
abstract class DataProcessor {

    // Template method
    public final void processData() {
        readData();
        processDataInternal();
        writeData();
    }

    // Abstract methods to be implemented by subclasses
    abstract void readData();
    abstract void processDataInternal();
    abstract void writeData();
}

// Concrete class implementing the abstract methods
class CSVDataProcessor extends DataProcessor {
    @Override
    void readData() {
        System.out.println("Reading data from CSV file");
    }

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

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

Dependency Injection Overview 💉

Dependency Injection involves passing dependencies to a class instead of the class creating them. This promotes loose coupling and testability.

// Example of Dependency Injection
class Service {
    private final Repository repository;

    // Injecting the dependency through the constructor
    public Service(Repository repository) {
        this.repository = repository;
    }

    public void performTask() {
        repository.getData();
        System.out.println("Task performed");
    }
}

interface Repository {
    void getData();
}

class DatabaseRepository implements Repository {
    @Override
    public void getData() {
        System.out.println("Getting data from the database");
    }
}

Combining DI and Template Method 🤝

Use DI to inject dependencies into the abstract class of the Template Method Pattern. This allows concrete subclasses to use different implementations of these dependencies.

// Abstract class with Dependency Injection
abstract class DataProcessor {
    private final DataSource dataSource;

    // Injecting DataSource dependency
    public DataProcessor(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    // Template method
    public final void processData() {
        dataSource.connect();
        readData();
        processDataInternal();
        writeData();
        dataSource.disconnect();
    }

    // Abstract methods to be implemented by subclasses
    abstract void readData();
    abstract void processDataInternal();
    abstract void writeData();
}

interface DataSource {
    void connect();
    void read();
    void write();
    void disconnect();
}

class CSVDataSource implements DataSource {
    @Override
    public void connect() {
        System.out.println("Connecting to CSV source");
    }

    @Override
    public void read() {
        System.out.println("Reading from CSV source");
    }

    @Override
    public void write() {
        System.out.println("Writing to CSV source");
    }

    @Override
    public void disconnect() {
        System.out.println("Disconnecting from CSV source");
    }
}

// Concrete class implementing the abstract methods
class AnalyticsDataProcessor extends DataProcessor {

    public AnalyticsDataProcessor(DataSource dataSource) {
        super(dataSource);
    }

    @Override
    void readData() {
        System.out.println("Reading data for analytics");
    }

    @Override
    void processDataInternal() {
        System.out.println("Processing data for analytics");
    }

    @Override
    void writeData() {
        System.out.println("Writing analytics data");
    }
}

Benefits of Combining the Patterns ✨

• Increased Flexibility: Easily switch dependencies without modifying the core algorithm.
• Improved Testability: Mock dependencies for unit testing.
• Enhanced Reusability: Reuse the algorithm with different data sources or processing logic.