Understanding Chain of Responsibility Design Pattern in Java

-

The Chain of Responsibility Design Pattern is a popular behavioral design pattern in Java used to process a request through a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. This approach reduces tight coupling, improves flexibility, and makes the request-processing pipeline highly maintainable.

If you build applications involving request validation, filtering, logging, authentication, authorization, exception handling, or event processing, you will find this pattern extremely valuable.

What is the Chain of Responsibility Pattern?

The Chain of Responsibility Pattern allows multiple objects to handle a request without the sender knowing which object will process it. The request flows through a chain of handlers until one of them handles it.

Real-Time Use Cases

  • Servlet Filters in Java Web Applications
  • Spring Security Authentication Chain
  • ATM withdrawal processing (different responsibilities)
  • Logging frameworks like Log4j, SLF4J
  • Customer request escalation (support level 1 → level 2 → level 3)

Chain of Responsibility Pattern – Real-Time Java Example (Support Ticket Handling)

Consider a customer support system where support tickets escalate automatically:

Level 1 → Level 2 → Level 3

If Level 1 can’t handle the request, it should pass it forward.

Step 1: Base Handler

public abstract class SupportHandler {

    protected SupportHandler nextHandler;

    public void setNextHandler(SupportHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(String issueType);
}

Step 2: Concrete Handlers

public class Level1Support extends SupportHandler {

    @Override
    public void handleRequest(String issueType) {

        if (issueType.equals("Basic")) {
            System.out.println("Level 1 Support: Issue resolved.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(issueType);
        }
    }
}


public class Level2Support extends SupportHandler {

    @Override
    public void handleRequest(String issueType) {
        if (issueType.equals("Advanced")) {
            System.out.println("Level 2 Support: Issue resolved.");
        } else if (nextHandler != null) {
            nextHandler.handleRequest(issueType);
        }
    }
}

public class Level3Support extends SupportHandler {

    @Override
    public void handleRequest(String issueType) {

        if (issueType.equals("Critical")) {
            System.out.println("Level 3 Support: Critical issue resolved.");
        } else {
            System.out.println("Issue cannot be handled.");
        }
    }
}

Step 3: Client Code – Building the Chain

public class SupportDemo {

    public static void main(String[] args) {

        SupportHandler level1 = new Level1Support();
        SupportHandler level2 = new Level2Support();
        SupportHandler level3 = new Level3Support();

        level1.setNextHandler(level2);
        level2.setNextHandler(level3);

        level1.handleRequest("Basic");
        level1.handleRequest("Advanced");

        level1.handleRequest("Critical");
    }
}

Output

Level 1 Support: Issue resolved.

Level 2 Support: Issue resolved.

Level 3 Support: Critical issue resolved.

Why Use Chain of Responsibility?

  • Decouples sender and receiver
  • Easy to add new handlers without changing existing code
  • Improves flexibility and maintainability
  • Enables dynamic ordering of request handlers

When Should You Use It?

  • When multiple objects can handle a request
  • When the handler should be selected at runtime
  • When you want to avoid huge if-else or switch statements

Advantages

  • Flexible chain configuration
  • Cleaner code compared to conditional logic
  • Follows Open/Closed Principle

Disadvantages

  • No guarantee a request will be handled
  • Debugging can become harder with long chains

Conclusion

The Chain of Responsibility Pattern in Java is perfect when you want to build clean, maintainable pipelines for request processing. From logging and filtering to validation and authentication, this pattern helps you avoid complex conditional logic and improve your system architecture.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more