Chain of Responsibility Pattern in Java: Definition, Roles, Code Examples, and Applications

The Chain of Responsibility pattern creates a processing chain where each node can handle a request or pass it to the next node, thereby decoupling the request sender from its receiver.

Typical implementation includes an abstract Handler class that holds a reference to the next handler and defines a method to process the request; concrete handlers implement the specific handling logic.

Example code first shows a simple if…else chain based on an integer parameter, then refactors it into a proper chain using an abstract Handler, a Request class, concrete handler classes, and a Client that links the handlers.

Roles defined in the pattern are:

Handler : abstract handler with a reference to the next handler and a request‑processing method.

ConcreteHandler : implements the actual handling logic and may forward the request.

Client : assembles the chain and initiates the request.

Real‑world applications include approval workflows (e.g., leave requests), marketing resource placement, and many Java framework mechanisms such as servlet FilterChain, Tomcat’s ApplicationFilterChain, and Spring MVC’s interceptor chain.

Advantages of the pattern are reduced coupling, easier extension of handlers, and simplified objects that do not need to know the chain structure. Drawbacks include potential performance impact for long chains and difficulty in debugging recursive request flows.

Typical usage scenarios are when multiple objects can handle the same request, the concrete handler is chosen at runtime, or a dynamic set of handlers needs to be assigned.

References: "研磨设计模式", https://wiki.jikexueyuan.com/project/java-design-pattern/chain-responsibility-pattern.html, https://refactoringguru.cn/design-patterns/chain-of-responsibility.