The Template Method pattern stands as one of the most widely adopted design patterns in modern software development. It perfectly embodies the Open-Closed Principle, allowing systems to be extended without modification. This pattern is extensively used in framework design, where it prvoides the foundation for customizable behavior through hook methods.

Hook methods serve as extension points within the template. Some hooks simply allow notification or logging without altering the core flow, while others can dramatically change the execution path. This flexibility makes the pattern invaluable for building flexible, maintainable architectures.

Pattern Structure and Implementation

Consider a messaging channel system where different channel types share common processing logic but require specific configuration. The Template Method pattern excels in this scenario by separating algorithmic structure from specific implementations.

The following example demonstrates a subscription-based channel architecture:

Channel Interface

package com.example.messaging.core;

import com.example.messaging.dto.MessageResult;
import com.example.messaging.enums.ChannelType;

/**
 * Contract for message channels in the subscription system.
 * 
 * Channels receive messages and distribute them to registered subscribers,
 * each of which processes the message and reports results.
 */
public interface MessageChannel<T, R extends MessageResult> {

    /**
     * Retrieves the channel's type identifier.
     *
     * @return the specific ChannelType for this channel
     */
    ChannelType getChannelType();

    /**
     * Registers a new subscriber to receive messages from this channel.
     *
     * @param subscriber the subscriber to register
     */
    void registerSubscriber(Subscriber<T, R> subscriber);

    /**
     * Removes a subscriber from receiving messages.
     *
     * @param subscriber the subscriber to remove
     */
    void unregisterSubscriber(Subscriber<T, R> subscriber);
}

AbstractChannel Base Class

package com.example.messaging.core.channels;

import com.example.messaging.core.MessageChannel;
import com.example.messaging.core.Subscriber;
import com.example.messaging.dto.MessageResult;
import com.example.messaging.dto.SingleSubscriberResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * Abstract base implementation providing the template method for message processing.
 * 
 * This class implements the core workflow of receiving messages and notifying
 * subscribers, while allowing subclasses to provide specific channel identifiers.
 */
public abstract class AbstractChannel<T, R extends MessageResult> 
        implements MessageChannel<T, R> {

    private static final Logger logger = LoggerFactory.getLogger(AbstractChannel.class);
    private final List<Subscriber<T, R>> subscriberRegistry = new ArrayList<>();

    /**
     * Template method defining the message processing workflow.
     *
     * @param payload   the message payload to process
     * @param resultCtx the context for collecting processing results
     */
    public void processMessage(T payload, R resultCtx) {
        logger.debug("Message processing initiated for channel: {}", getChannelType());
        
        for (Subscriber<T, R> handler : subscriberRegistry) {
            handler.onMessage(payload, resultCtx);
            SingleSubscriberResult subscriberOutcome = resultCtx.getResultFor(handler);
            
            if (!subscriberOutcome.isSuccessful()) {
                logger.warn("Subscriber {} failed execution, invoking recovery...", 
                           handler.getClass().getSimpleName());
                handler.onFailure(payload, resultCtx);
                logger.info("Recovery procedure completed for subscriber: {}", 
                           handler.getClass().getSimpleName());
            }
        }
        
        logger.debug("Message processing completed for channel: {}", getChannelType());
    }

    @Override
    public void registerSubscriber(Subscriber<T, R> handler) {
        if (subscriberRegistry.contains(handler)) {
            logger.debug("Subscriber already registered, skipping: {}", 
                        handler.getClass().getSimpleName());
            return;
        }
        subscriberRegistry.add(handler);
    }

    @Override
    public void unregisterSubscriber(Subscriber<T, R> handler) {
        subscriberRegistry.remove(handler);
    }
}

Concrete Channel Implementation

package com.example.messaging.activation.channels;

import com.example.messaging.activation.dto.OrderActivationEvent;
import com.example.messaging.core.channels.AbstractChannel;
import com.example.messaging.dto.MessageResult;
import com.example.messaging.enums.ChannelType;
import org.springframework.stereotype.Service;

/**
 * Concrete channel implementation for order activation events.
 * 
 * This channel handles lifecycle events when orders are activated
 * in the system, routing messages to registered subscribers.
 */
@Service
public class OrderActivationChannel 
        extends AbstractChannel<OrderActivationEvent, MessageResult> {

    /**
     * Returns the channel type identifier for order activation events.
     *
     * @return ChannelType.ORDER_ACTIVATION
     */
    @Override
    public ChannelType getChannelType() {
        return ChannelType.ORDER_ACTIVATION;
    }
}

Key Design Principles Demonsrtated

The Template Method pattern achieves several architectural goals simultaneously. The abstract base class defines the algorithmic skeleton, ensuring consistent behavior across all channel types. Subclasses only need to implement the specific configuration—returning their channel type—while inheriting the complete message processing workflow.

Hook methods within the base class allow subclasses to customize behavior at strategic points. Some hooks might enable logging, caching, or preprocessing without changing the fundamental flow. More powerful hooks can entirely alter execution paths based on runtime conditions, providing tremendous flexibility for handling diverse business requirements.

This approach results in code that is both extensible and maintainable. New channel types can be added by extending the base class and implementing the minimal required interface, without any modification to existing code—perfectly adhering to the Open-Closed Principle.