DEV Community

Dev Cookies
Dev Cookies

Posted on

📝 Day Eight: Chain of Responsibility Design Pattern in Java

🔗 What is the Chain of Responsibility Pattern?

The Chain of Responsibility is a behavioral design pattern that allows a request to pass through a chain of handlers. Each handler decides either to process the request or pass it along the chain.

🧠 Real-Life Analogy

Think of technical support:

  • Level 1 support → Level 2 → Level 3.
  • If one can’t solve your issue, it escalates to the next level.

That’s the chain!

✅ When to Use

  • When multiple objects can handle a request.
  • When you want to decouple sender and receiver.
  • When you don’t know the handler at compile time.

💡 Real-World Example: Logging System

We'll create a logging system where messages flow through different log levels: INFO, DEBUG, ERROR. Each handler decides if it can handle the message or pass it along.

🔧 Step-by-Step Java Implementation

✅ 1. Define the Abstract Handler 

public abstract class Logger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;
    protected Logger nextLogger;

    public void setNextLogger(Logger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) {
        if (this.level <= level) {
            write(message);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level, message);
        }
    }

    protected abstract void write(String message);
}
Enter fullscreen mode Exit fullscreen mode

✅ 2. Create Concrete Handlers 

public class InfoLogger extends Logger {
    public InfoLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("INFO: " + message);
    }
}
Enter fullscreen mode Exit fullscreen mode 
public class DebugLogger extends Logger {
    public DebugLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("DEBUG: " + message);
    }
}
Enter fullscreen mode Exit fullscreen mode 
public class ErrorLogger extends Logger {
    public ErrorLogger(int level) {
        this.level = level;
    }

    @Override
    protected void write(String message) {
        System.out.println("ERROR: " + message);
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ 3. Chain Setup Utility 

public class LoggerChain {
    public static Logger getChainOfLoggers() {
        Logger errorLogger = new ErrorLogger(Logger.ERROR);
        Logger debugLogger = new DebugLogger(Logger.DEBUG);
        Logger infoLogger = new InfoLogger(Logger.INFO);

        errorLogger.setNextLogger(debugLogger);
        debugLogger.setNextLogger(infoLogger);

        return errorLogger; // head of chain
    }
}
Enter fullscreen mode Exit fullscreen mode

✅ 4. Client Code 

public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Logger loggerChain = LoggerChain.getChainOfLoggers();

        loggerChain.logMessage(Logger.INFO, "This is an INFO message.");
        loggerChain.logMessage(Logger.DEBUG, "This is a DEBUG message.");
        loggerChain.logMessage(Logger.ERROR, "This is an ERROR message.");
    }
}
Enter fullscreen mode Exit fullscreen mode

🧪 Output 

INFO: This is an INFO message.
DEBUG: This is a DEBUG message.
INFO: This is a DEBUG message.
ERROR: This is an ERROR message.
DEBUG: This is an ERROR message.
INFO: This is an ERROR message.
Enter fullscreen mode Exit fullscreen mode

📦 Structure Recap 

+---------+      +---------+      +---------+
| LoggerA | ---> | LoggerB | ---> | LoggerC |
+---------+      +---------+      +---------+
Enter fullscreen mode Exit fullscreen mode
  • Each logger decides whether to handle or forward.
  • Chain is flexible and can be dynamically modified.

🎯 Key Benefits

Benefit Explanation
Decoupling Sender doesn’t know who handles the request
Flexibility Add/remove handlers without affecting code
Responsibility sharing Multiple handlers can act

🧠 Real Use Cases

  • Servlet filters in Java EE
  • Event bubbling in UI frameworks
  • Authentication → Authorization chains
  • Middleware in Express.js or Spring Interceptor chains

🧰 Bonus Tips

  • Combine with Command Pattern to create task pipelines.
  • Combine with Decorator for dynamic enhancements.

🗺 UML Diagram (Text-based) 

+-----------------+
|     Logger      |<--------------------------------------+
+-----------------+                                       |
| -level          |                                       |
| -nextLogger     |                                       |
| +setNextLogger()|                                       |
| +logMessage()   |                                       |
+-----------------+                                       |
        ^                                                 |
        |                                                 |
+-----------------+   +-----------------+   +-----------------+
|   InfoLogger    |   |  DebugLogger    |   |  ErrorLogger    |
+-----------------+   +-----------------+   +-----------------+
| +write()        |   | +write()        |   | +write()        |
+-----------------+   +-----------------+   +-----------------+
Enter fullscreen mode Exit fullscreen mode

💬 Summary Table

Element Role
Logger Abstract base class
InfoLogger, DebugLogger, ErrorLogger Concrete handlers
LoggerChain Assembles chain
Client Sends request into the chain

Let me know when you're ready for Day 9 — shall we cover the State pattern or Strategy next? Both are super useful and often asked in system design interviews.

You're doing epic work — just 3 more patterns left in the series! 🚀

Top comments (0)