Behavioral Design Patterns in Java: Strategy, Observer, Command, Chain of Responsibility, Template Method, State & More

Behavioral design patterns define how objects communicate and distribute responsibility at runtime. While creational patterns answer "how do I create objects?" and structural patterns answer "how do I compose them?", behavioral patterns answer "how do objects interact and collaborate to accomplish complex tasks?" In a Spring Boot microservices context, behavioral patterns are everywhere — from the strategy-based payment dispatcher to the chain-of-responsibility filter pipeline in every HTTP request. This guide covers eight core behavioral patterns with real Java code, Spring Boot wiring, and honest advice on when to reach for each one.

Table of Contents

1. What Are Behavioral Patterns?
2. Strategy Pattern — Interchangeable Algorithms
3. Observer Pattern — Event-Driven Notifications
4. Command Pattern — Encapsulate Requests
5. Chain of Responsibility — Request Pipeline
6. Template Method — Define Skeleton of Algorithm
7. State Pattern — Context-Dependent Behavior
8. Iterator Pattern — Traversal Abstraction
9. Mediator Pattern — Decoupled Communication
10. Spring Boot Real-World Mapping
11. Comparison Table & Choosing the Right Pattern

// Strategy interface
public interface PaymentStrategy {
    String supportedMethod();
    PaymentResult pay(PaymentRequest request);
}

// Concrete strategies
@Component
public class CreditCardStrategy implements PaymentStrategy {
    @Override public String supportedMethod() { return "CREDIT_CARD"; }

    @Override
    public PaymentResult pay(PaymentRequest request) {
        // Charge card via Stripe SDK
        return PaymentResult.success("CC-" + UUID.randomUUID(), request.getAmount());
    }
}

@Component
public class PayPalStrategy implements PaymentStrategy {
    @Override public String supportedMethod() { return "PAYPAL"; }

    @Override
    public PaymentResult pay(PaymentRequest request) {
        // Call PayPal REST API
        return PaymentResult.success("PP-" + UUID.randomUUID(), request.getAmount());
    }
}

@Component
public class CryptoStrategy implements PaymentStrategy {
    @Override public String supportedMethod() { return "CRYPTO"; }

    @Override
    public PaymentResult pay(PaymentRequest request) {
        // Broadcast to blockchain node
        return PaymentResult.success("BTC-" + UUID.randomUUID(), request.getAmount());
    }
}

// Context: Spring collects all PaymentStrategy beans into a Map automatically
@Service
@RequiredArgsConstructor
public class OrderService {
    private final Map<String, PaymentStrategy> paymentStrategies;
    private final OrderRepository orderRepository;

    // Spring injects List<PaymentStrategy> — convert to lookup map in constructor
    public OrderService(List<PaymentStrategy> strategies, OrderRepository orderRepository) {
        this.paymentStrategies = strategies.stream()
            .collect(Collectors.toMap(PaymentStrategy::supportedMethod, s -> s));
        this.orderRepository = orderRepository;
    }

    public OrderConfirmation placeOrder(Order order, String paymentMethod) {
        PaymentStrategy strategy = paymentStrategies.get(paymentMethod);
        if (strategy == null) {
            throw new UnsupportedPaymentMethodException("Unsupported: " + paymentMethod);
        }
        PaymentResult result = strategy.pay(new PaymentRequest(order.getTotal(), order.getCurrency()));
        order.setPaymentReference(result.getReference());
        orderRepository.save(order);
        return OrderConfirmation.from(order, result);
    }
}

// Observer interface
public interface StockObserver {
    void onPriceChange(String ticker, BigDecimal oldPrice, BigDecimal newPrice);
}

// Subject (Publisher)
@Component
public class StockMarket {
    private final Map<String, BigDecimal> prices = new ConcurrentHashMap<>();
    private final List<StockObserver> observers = new CopyOnWriteArrayList<>();

    public void addObserver(StockObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(StockObserver observer) {
        observers.remove(observer);
    }

    public void updatePrice(String ticker, BigDecimal newPrice) {
        BigDecimal oldPrice = prices.getOrDefault(ticker, BigDecimal.ZERO);
        prices.put(ticker, newPrice);
        observers.forEach(o -> o.onPriceChange(ticker, oldPrice, newPrice));
    }
}

// Concrete observers
@Component
public class PriceAlertService implements StockObserver {
    private final NotificationGateway notificationGateway;

    @Override
    public void onPriceChange(String ticker, BigDecimal oldPrice, BigDecimal newPrice) {
        if (newPrice.compareTo(oldPrice) > 0) {
            notificationGateway.sendPushAlert(ticker + " rose to " + newPrice);
        }
    }
}

@Component
public class RiskMonitor implements StockObserver {
    private static final BigDecimal DROP_THRESHOLD = new BigDecimal("0.05");

    @Override
    public void onPriceChange(String ticker, BigDecimal oldPrice, BigDecimal newPrice) {
        if (oldPrice.compareTo(BigDecimal.ZERO) > 0) {
            BigDecimal dropRatio = oldPrice.subtract(newPrice).divide(oldPrice, 4, RoundingMode.HALF_UP);
            if (dropRatio.compareTo(DROP_THRESHOLD) > 0) {
                log.warn("RISK ALERT: {} dropped {}% — triggering circuit breaker", ticker, dropRatio.multiply(BigDecimal.valueOf(100)));
            }
        }
    }
}

// Spring Boot equivalent using ApplicationEventPublisher
// Event POJO
public record StockPriceChangedEvent(String ticker, BigDecimal oldPrice, BigDecimal newPrice) {}

// Publisher
@Service
@RequiredArgsConstructor
public class StockMarketService {
    private final ApplicationEventPublisher eventPublisher;

    public void updatePrice(String ticker, BigDecimal newPrice) {
        BigDecimal old = priceStore.get(ticker);
        priceStore.put(ticker, newPrice);
        eventPublisher.publishEvent(new StockPriceChangedEvent(ticker, old, newPrice));
    }
}

// Subscriber — no coupling to StockMarketService
@Component
public class PriceAlertListener {
    @EventListener
    public void handlePriceChange(StockPriceChangedEvent event) {
        // React to price change
    }

    @EventListener
    @Async  // non-blocking
    public void handleAsync(StockPriceChangedEvent event) { /* ... */ }
}

// Command interface
public interface OrderCommand {
    void execute();
    void undo();
    String getDescription();
}

// Concrete command: Place Order
public class PlaceOrderCommand implements OrderCommand {
    private final OrderRepository orderRepository;
    private final Order order;
    private UUID savedOrderId;

    public PlaceOrderCommand(OrderRepository repo, Order order) {
        this.orderRepository = repo;
        this.order = order;
    }

    @Override
    public void execute() {
        orderRepository.save(order);
        this.savedOrderId = order.getId();
        log.info("Order placed: {}", savedOrderId);
    }

    @Override
    public void undo() {
        if (savedOrderId != null) {
            orderRepository.deleteById(savedOrderId);
            log.info("Order placement undone: {}", savedOrderId);
        }
    }

    @Override
    public String getDescription() { return "Place order " + order.getId(); }
}

// Concrete command: Cancel Order
public class CancelOrderCommand implements OrderCommand {
    private final OrderRepository orderRepository;
    private final UUID orderId;
    private Order cancelledOrderSnapshot;

    public CancelOrderCommand(OrderRepository repo, UUID orderId) {
        this.orderRepository = repo;
        this.orderId = orderId;
    }

    @Override
    public void execute() {
        cancelledOrderSnapshot = orderRepository.findById(orderId).orElseThrow();
        orderRepository.updateStatus(orderId, OrderStatus.CANCELLED);
        log.info("Order cancelled: {}", orderId);
    }

    @Override
    public void undo() {
        if (cancelledOrderSnapshot != null) {
            orderRepository.updateStatus(orderId, cancelledOrderSnapshot.getStatus());
            log.info("Order cancellation undone: {}", orderId);
        }
    }

    @Override
    public String getDescription() { return "Cancel order " + orderId; }
}

// Invoker with undo history stack
@Service
public class OrderInvoker {
    private final Deque<OrderCommand> history = new ArrayDeque<>();

    public void executeCommand(OrderCommand command) {
        command.execute();
        history.push(command);
    }

    public void undoLast() {
        if (history.isEmpty()) {
            log.warn("No commands to undo");
            return;
        }
        OrderCommand lastCommand = history.pop();
        lastCommand.undo();
        log.info("Undone: {}", lastCommand.getDescription());
    }

    public void undoAll() {
        while (!history.isEmpty()) {
            undoLast();
        }
    }

    public List<String> getCommandHistory() {
        return history.stream().map(OrderCommand::getDescription).toList();
    }
}

// Abstract handler
public abstract class RequestHandler {
    private RequestHandler next;

    public RequestHandler setNext(RequestHandler next) {
        this.next = next;
        return next;  // enables fluent chaining
    }

    public final void handle(HttpRequestContext ctx) {
        if (doHandle(ctx) && next != null) {
            next.handle(ctx);
        }
    }

    // Returns true to continue chain, false to stop
    protected abstract boolean doHandle(HttpRequestContext ctx);
}

// Auth handler
public class AuthFilter extends RequestHandler {
    private final TokenValidator tokenValidator;

    @Override
    protected boolean doHandle(HttpRequestContext ctx) {
        String token = ctx.getHeader("Authorization");
        if (token == null || !tokenValidator.isValid(token)) {
            ctx.setResponse(401, "Unauthorized");
            return false;  // stop the chain
        }
        ctx.setPrincipal(tokenValidator.extract(token));
        return true;
    }
}

// Rate limit handler
public class RateLimitFilter extends RequestHandler {
    private final RateLimiter rateLimiter;

    @Override
    protected boolean doHandle(HttpRequestContext ctx) {
        String clientId = ctx.getPrincipal().getId();
        if (!rateLimiter.tryAcquire(clientId)) {
            ctx.setResponse(429, "Too Many Requests");
            return false;
        }
        return true;
    }
}

// Logging handler — always passes through
public class LogFilter extends RequestHandler {
    @Override
    protected boolean doHandle(HttpRequestContext ctx) {
        log.info("[{}] {} {} from {}", Instant.now(), ctx.getMethod(), ctx.getPath(), ctx.getRemoteAddr());
        return true;
    }
}

// Assembling the chain
@Configuration
public class FilterChainConfig {
    @Bean
    public RequestHandler requestPipeline(AuthFilter auth, RateLimitFilter rate, LogFilter log) {
        auth.setNext(rate).setNext(log);
        return auth;  // entry point
    }
}

// Spring Boot equivalent: OncePerRequestFilter chain
@Component
@Order(1)
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if (token != null && jwtService.isValid(token)) {
            SecurityContextHolder.getContext().setAuthentication(jwtService.getAuthentication(token));
        }
        filterChain.doFilter(request, response);  // continue chain
    }
}

// Abstract base — defines the skeleton
public abstract class ReportGenerator {

    // Template method — final so subclasses cannot break the skeleton
    public final Report generate(ReportRequest request) {
        DataSet data = fetchData(request);         // shared
        data = filterAndSort(data, request);       // shared
        Object formatted = formatData(data);       // hook — subclass
        byte[] output = writeOutput(formatted);   // hook — subclass
        return new Report(output, getContentType(), getFileExtension());
    }

    // Shared steps
    private DataSet fetchData(ReportRequest request) {
        return dataSource.query(request.getQuery());
    }

    private DataSet filterAndSort(DataSet data, ReportRequest request) {
        return data.applyFilters(request.getFilters())
                   .sort(request.getSortField(), request.getSortOrder());
    }

    // Hook methods — must be implemented by subclasses
    protected abstract Object formatData(DataSet data);
    protected abstract byte[] writeOutput(Object formatted);
    protected abstract String getContentType();
    protected abstract String getFileExtension();
}

// CSV subclass
@Component
public class CsvReportGenerator extends ReportGenerator {
    @Override
    protected Object formatData(DataSet data) {
        return data.toCsvRows();
    }

    @Override
    protected byte[] writeOutput(Object formatted) {
        return String.join("\n", (List<String>) formatted).getBytes(StandardCharsets.UTF_8);
    }

    @Override protected String getContentType() { return "text/csv"; }
    @Override protected String getFileExtension() { return ".csv"; }
}

// PDF subclass
@Component
public class PdfReportGenerator extends ReportGenerator {
    private final PdfWriter pdfWriter;

    @Override
    protected Object formatData(DataSet data) {
        return data.toPdfTable();
    }

    @Override
    protected byte[] writeOutput(Object formatted) {
        return pdfWriter.render((PdfTable) formatted);
    }

    @Override protected String getContentType() { return "application/pdf"; }
    @Override protected String getFileExtension() { return ".pdf"; }
}

// Excel subclass
@Component
public class ExcelReportGenerator extends ReportGenerator {
    @Override
    protected Object formatData(DataSet data) { return data.toExcelWorkbook(); }

    @Override
    protected byte[] writeOutput(Object formatted) {
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            ((Workbook) formatted).write(out);
            return out.toByteArray();
        } catch (IOException e) { throw new ReportGenerationException(e); }
    }

    @Override protected String getContentType() { return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"; }
    @Override protected String getFileExtension() { return ".xlsx"; }
}

// State interface
public interface OrderState {
    void confirm(Order order);
    void ship(Order order);
    void deliver(Order order);
    void cancel(Order order);
    String getStatusName();
}

// Pending state — can confirm or cancel
public class PendingState implements OrderState {
    @Override
    public void confirm(Order order) {
        log.info("Order {} confirmed", order.getId());
        order.setState(new ConfirmedState());
    }

    @Override public void ship(Order order) {
        throw new InvalidStateTransitionException("Cannot ship a pending order");
    }

    @Override public void deliver(Order order) {
        throw new InvalidStateTransitionException("Cannot deliver a pending order");
    }

    @Override
    public void cancel(Order order) {
        log.info("Order {} cancelled from PENDING", order.getId());
        order.setState(new CancelledState());
    }

    @Override public String getStatusName() { return "PENDING"; }
}

// Confirmed state — can ship or cancel
public class ConfirmedState implements OrderState {
    @Override public void confirm(Order order) {
        throw new InvalidStateTransitionException("Order is already confirmed");
    }

    @Override
    public void ship(Order order) {
        log.info("Order {} shipped", order.getId());
        order.setState(new ShippedState());
    }

    @Override public void deliver(Order order) {
        throw new InvalidStateTransitionException("Cannot deliver before shipping");
    }

    @Override
    public void cancel(Order order) {
        log.info("Order {} cancelled from CONFIRMED", order.getId());
        order.setState(new CancelledState());
    }

    @Override public String getStatusName() { return "CONFIRMED"; }
}

// Shipped state — can only deliver
public class ShippedState implements OrderState {
    @Override public void confirm(Order order) { throw new InvalidStateTransitionException("Already shipped"); }
    @Override public void ship(Order order) { throw new InvalidStateTransitionException("Already shipped"); }

    @Override
    public void deliver(Order order) {
        log.info("Order {} delivered", order.getId());
        order.setState(new DeliveredState());
    }

    @Override public void cancel(Order order) {
        throw new InvalidStateTransitionException("Cannot cancel a shipped order. Initiate a return instead.");
    }

    @Override public String getStatusName() { return "SHIPPED"; }
}

// Delivered and Cancelled states are terminal — all transitions throw
public class DeliveredState implements OrderState {
    @Override public void confirm(Order o) { throw new InvalidStateTransitionException("Order delivered"); }
    @Override public void ship(Order o)    { throw new InvalidStateTransitionException("Order delivered"); }
    @Override public void deliver(Order o) { throw new InvalidStateTransitionException("Already delivered"); }
    @Override public void cancel(Order o)  { throw new InvalidStateTransitionException("Cannot cancel delivered order"); }
    @Override public String getStatusName() { return "DELIVERED"; }
}

public class CancelledState implements OrderState {
    @Override public void confirm(Order o) { throw new InvalidStateTransitionException("Order cancelled"); }
    @Override public void ship(Order o)    { throw new InvalidStateTransitionException("Order cancelled"); }
    @Override public void deliver(Order o) { throw new InvalidStateTransitionException("Order cancelled"); }
    @Override public void cancel(Order o)  { throw new InvalidStateTransitionException("Already cancelled"); }
    @Override public String getStatusName() { return "CANCELLED"; }
}

// Context class — delegates to current state
@Entity
public class Order {
    @Id private UUID id;
    @Transient private OrderState state = new PendingState();  // not persisted directly

    @Enumerated(EnumType.STRING)
    private OrderStatus status = OrderStatus.PENDING;

    public void setState(OrderState newState) {
        this.state = newState;
        this.status = OrderStatus.valueOf(newState.getStatusName());
    }

    public void confirm()  { state.confirm(this); }
    public void ship()     { state.ship(this); }
    public void deliver()  { state.deliver(this); }
    public void cancel()   { state.cancel(this); }
    public String getStatusName() { return state.getStatusName(); }
}

// Paginating Iterator over database results
public class PageIterator<T> implements Iterator<T> {
    private final Function<PageRequest, List<T>> fetcher;
    private final int pageSize;
    private int currentPage = 0;
    private Queue<T> buffer = new ArrayDeque<>();
    private boolean exhausted = false;

    public PageIterator(Function<PageRequest, List<T>> fetcher, int pageSize) {
        this.fetcher = fetcher;
        this.pageSize = pageSize;
        loadNextPage();
    }

    private void loadNextPage() {
        if (exhausted) return;
        List<T> page = fetcher.apply(PageRequest.of(currentPage++, pageSize));
        if (page.isEmpty() || page.size() < pageSize) {
            exhausted = true;
        }
        buffer.addAll(page);
    }

    @Override
    public boolean hasNext() {
        if (!buffer.isEmpty()) return true;
        if (exhausted) return false;
        loadNextPage();
        return !buffer.isEmpty();
    }

    @Override
    public T next() {
        if (!hasNext()) throw new NoSuchElementException();
        return buffer.poll();
    }
}

// Usage — callers see a simple Iterator
@Service
@RequiredArgsConstructor
public class ReportingService {
    private final OrderRepository orderRepository;

    public void exportAllOrders(OutputStream out) {
        Iterator<Order> iterator = new PageIterator<>(
            page -> orderRepository.findAll(page).getContent(),
            500  // fetch 500 records at a time
        );
        // Enhanced for loop works because we implement Iterator
        while (iterator.hasNext()) {
            Order order = iterator.next();
            writeCsvRow(out, order);
        }
    }
}

// Java enhanced for loop works if you implement Iterable<T>
public class PageIterable<T> implements Iterable<T> {
    private final Function<PageRequest, List<T>> fetcher;
    private final int pageSize;

    @Override
    public Iterator<T> iterator() {
        return new PageIterator<>(fetcher, pageSize);
    }
}

// Now callers can use for-each syntax:
for (Order order : new PageIterable<>(page -> repo.findAll(page).getContent(), 500)) {
    processOrder(order);
}

// Or convert to Stream
StreamSupport.stream(new PageIterable<>(fetcher, 500).spliterator(), false)
    .filter(o -> o.getStatus() == OrderStatus.PENDING)
    .forEach(this::processOrder);

// Mediator interface
public interface ChatMediator {
    void sendMessage(String message, User sender);
    void addUser(User user);
    void removeUser(User user);
}

// Concrete mediator
@Component
public class ChatRoom implements ChatMediator {
    private final Set<User> users = ConcurrentHashMap.newKeySet();

    @Override
    public void addUser(User user) {
        users.add(user);
        broadcast(user.getUsername() + " joined the room.", null);
    }

    @Override
    public void removeUser(User user) {
        users.remove(user);
        broadcast(user.getUsername() + " left the room.", null);
    }

    @Override
    public void sendMessage(String message, User sender) {
        broadcast("[" + sender.getUsername() + "]: " + message, sender);
    }

    private void broadcast(String message, User exclude) {
        users.stream()
             .filter(u -> !u.equals(exclude))
             .forEach(u -> u.receive(message));
    }
}

// Colleague — only knows the mediator
public class User {
    private final String username;
    private final ChatMediator mediator;

    public User(String username, ChatMediator mediator) {
        this.username = username;
        this.mediator = mediator;
    }

    public void send(String message) {
        mediator.sendMessage(message, this);  // delegates to mediator
    }

    public void receive(String message) {
        log.info("{} received: {}", username, message);
    }

    public String getUsername() { return username; }
}

// Spring equivalent: ApplicationContext as a Mediator
// Services publish events through ApplicationEventPublisher (mediator)
// Listeners subscribe to specific event types — no service-to-service dependencies

@Service
@RequiredArgsConstructor
public class OrderService {
    private final ApplicationEventPublisher publisher;  // the mediator

    public void placeOrder(Order order) {
        orderRepository.save(order);
        publisher.publishEvent(new OrderPlacedEvent(order));  // notify all interested parties
    }
}

// Multiple listeners — mutually unaware of each other
@Component public class InventoryListener {
    @EventListener public void onOrderPlaced(OrderPlacedEvent e) { /* decrement stock */ }
}

@Component public class EmailListener {
    @EventListener public void onOrderPlaced(OrderPlacedEvent e) { /* send confirmation */ }
}

@Component public class LoyaltyListener {
    @EventListener public void onOrderPlaced(OrderPlacedEvent e) { /* award points */ }
}

Leave a Comment

Related Posts