Chain of Responsibility pattern

Overview

Chain of Responsibility passes a request along a chain of handlers; each handler either processes it, passes it on, or both. The sender does not know which handler will act. Handlers can be added, removed, or reordered without changing the sender.

It is the pattern behind middleware pipelines (auth, rate limit, logging, validation), approval workflows (manager, director, VP approve by amount), support escalation, and ATM cash dispensing by denomination. Each handler has one responsibility, and the chain composes them.

When to use it

• Several objects may handle a request, decided at runtime.
• A pipeline of checks or processing steps.
• Escalation by level or amount.

Where it shows up in interviews

Where it is used in real software

Key terms

Handler

Processes or forwards a request.

Successor / next

The next handler in the chain.

Short-circuit

Stop the chain (reject or fully handle).

Pipeline

Every handler processes and passes on.

How it works, step by step

1. 1
   Define the handler interface

   handle(request) with a next reference.

2. 2
   Implement one concern per handler

   Auth, rate limit, validation.

3. 3
   Decide: handle, pass, or stop

   Each handler chooses.

4. 4
   Assemble the chain

   Order matters; build in one place.

5. 5
   Handle the end of the chain

   Default handler or error if unhandled.

Expense approval chain

TeamLead approves <= 1,000; Manager <= 10,000; Director <= 50,000; else CFO

Changing limits or adding a level edits the chain assembly, not the request code.

Implementation

1public abstract class CashHandler {2    private CashHandler next;3    private final int denomination;4    private int available;5 6    protected CashHandler(int denomination, int available) {7        this.denomination = denomination;8        this.available = available;9    }10 11    public CashHandler then(CashHandler next) { this.next = next; return next; }12 13    public void dispense(int amount, Map<Integer, Integer> out) {14        int notes = Math.min(amount / denomination, available);15        if (notes > 0) {16            out.put(denomination, notes);17            available -= notes;18            amount -= notes * denomination;19        }20        if (amount == 0) return;21        if (next == null) throw new IllegalStateException("Cannot dispense remaining " + amount);22        next.dispense(amount, out);23    }24}25 26final class Hundreds extends CashHandler { Hundreds(int n) { super(100, n); } }27final class Fifties extends CashHandler { Fifties(int n) { super(50, n); } }28final class Twenties extends CashHandler { Twenties(int n) { super(20, n); } }29final class Tens extends CashHandler { Tens(int n) { super(10, n); } }30 31CashHandler chain = new Hundreds(10);32chain.then(new Fifties(10)).then(new Twenties(20)).then(new Tens(20));33Map<Integer, Integer> notes = new LinkedHashMap<>();34chain.dispense(380, notes); // {100=3, 50=1, 20=1, 10=1}

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Order-dependent bugs.

  Fix: Build the chain in one place and test the order (auth before rate limit, etc.).

• Handlers doing multiple jobs.

  Fix: One concern per handler.

Interview questions

Practice problems