What is the Chain of Responsibility Pattern?
Learn the Chain of Responsibility pattern — decoupled request handling and escalation chains — with a Java example and interview Q&A.
Expected Interview Answer
The Chain of Responsibility pattern passes a request along a chain of handler objects until one of them decides to process it, decoupling the sender of a request from the specific object that ultimately handles it.
Each handler implements a common interface and holds a reference to the next handler in the chain. When a request arrives, a handler either processes it, passes it unchanged to the next handler, or does both — processing partially and still forwarding it on. The sender only knows about the first handler in the chain and has no knowledge of how many handlers exist or which one will actually act, which means handlers can be added, removed, or reordered without touching the sender’s code. This is commonly used for things like middleware pipelines, event bubbling in UI frameworks, and approval workflows where a request may need escalation through multiple levels of authority.
- Decouples the request sender from the eventual handler
- Lets handlers be added, removed, or reordered independently
- Supports multiple handlers reacting to or passing along one request
- Avoids a single class needing to know about every possible handler upfront
AI Mentor Explanation
An on-field appeal doesn’t go straight to the third umpire; it first goes to the on-field umpire, who either rules on it directly or, if uncertain, passes it up to the third umpire for a video review. The bowler making the appeal doesn’t know or care how many officials it takes to get a decision. That is the Chain of Responsibility pattern: the request travels through a sequence of handlers until one of them is able to resolve it.
Step-by-Step Explanation
Step 1
Define a handler interface
Declare a handle(request) method and a way to set the next handler in the chain.
Step 2
Implement concrete handlers
Each handler decides whether to process the request, pass it on, or both.
Step 3
Link handlers into a chain
Wire successors together in the desired order, often at application startup.
Step 4
Send the request to the first handler
The client only ever talks to the chain's entry point, unaware of how many handlers exist.
What Interviewer Expects
- A clear statement that the sender is decoupled from the eventual handler
- Understanding that handlers can process, forward, or do both
- A concrete example like middleware, event bubbling, or approval workflows
- Awareness that a request may go unhandled if no handler in the chain processes it
Common Mistakes
- Forgetting to explicitly forward the request when a handler doesn't fully process it
- Not handling the case where the request reaches the end of the chain unprocessed
- Confusing this with the Observer pattern (broadcast to all vs sequential handling)
- Hardcoding the chain order inside handlers instead of composing it externally
Best Answer (HR Friendly)
“The Chain of Responsibility pattern sends a request through a series of handler objects, one after another, until one of them deals with it. Whoever sends the request only needs to know about the first handler, not the whole chain, so you can add, remove, or reorder handlers without changing the sender’s code. It’s the same idea as an escalation process where a request moves up through levels until someone can act on it.”
Code Example
abstract class SupportHandler {
protected SupportHandler next;
void setNext(SupportHandler next) { this.next = next; }
abstract void handle(int severity, String message);
}
class Tier1Handler extends SupportHandler {
void handle(int severity, String message) {
if (severity <= 1) System.out.println("Tier1 resolved: " + message);
else if (next != null) next.handle(severity, message);
}
}
class Tier2Handler extends SupportHandler {
void handle(int severity, String message) {
if (severity <= 3) System.out.println("Tier2 resolved: " + message);
else if (next != null) next.handle(severity, message);
}
}
SupportHandler chain = new Tier1Handler();
chain.setNext(new Tier2Handler());
chain.handle(2, "Login failing intermittently"); // handled by Tier2Follow-up Questions
- What happens if no handler in the chain processes the request?
- How does Chain of Responsibility differ from the Observer pattern?
- Can multiple handlers act on the same request as it passes through?
- How would you implement this pattern for HTTP middleware?
MCQ Practice
1. Chain of Responsibility primarily decouples?
The sender only knows the first handler; it has no knowledge of which handler in the chain actually processes the request.
2. Each handler in the chain typically holds a reference to?
Handlers are linked sequentially, each forwarding unhandled requests to its designated successor.
3. A common real-world application of this pattern is?
Middleware pipelines and UI event bubbling both pass a request through a sequence of handlers, matching this pattern.
Flash Cards
Chain of Responsibility in one line? — Pass a request along a chain of handlers until one processes it.
What does the sender know? — Only the first handler in the chain, not how many exist or which will act.
Can a handler do both? — Yes — it can partially process a request and still forward it onward.
Common real-world example? — Middleware pipelines and UI event bubbling.