A complete guide on Behavioral Design Pattern and Chain of Responsibility Pattern in Java

Table of Content

In this blog, we’ll learn behavioral design patterns where and when we can use this particular pattern, and its types.

Also, we’ll particularly focus on the chain of responsibility pattern which is a type of behavioral design pattern.

What is Behavioral Design Pattern?

A design pattern in which more emphasis is given to how the objects interact with each other.

Also as the name suggests a chain of responsibility i.e., objects have their responsibilities/tasks to perform.

In behavioral design patterns, there should be minimum hard coding, the objects should be loosely coupled and coherence should be more.

Now, let us understand the terms coupling and coherence. These are significant terms in design patterns and also in software engineering.

Coupling - Coupling means interdependency here in terms of objects. The objects should be less dependent on each other for a particular task, otherwise, due to a failure or delay in one object can lead to a system failure.

Coherence - Coherence means that the objects/modules should work together so that they complement each other rather than creating a burden on the system.

Types of Behavioral Design Pattern:

What is a Chain of Responsibility Pattern?

A design pattern in which objects show a chain behavior is a chain of responsibility pattern.

Whenever a user sends a request it passes through a chain of an object and any object can send a response accordingly. So there is the least coupling between the objects.

Advantages of using Chain of Responsibility Pattern:

Example for Chain of Responsibility Pattern:

Now, let us understand the chain of responsibility pattern with an example. The given below UML diagram will make you easily understand.

[Source]

So here we have three different logger class which extends the main abstract logger class and a client class.

Each class has its attributes and methods like Logger has output info, error info, debug info as attributes, and set Logger, Message, display Log Info as methods.

Console Based Logger class has a console-based logger and displays Log Info as methods but no attributes of its own. Debug Based Logger has Debug Based Logger(int levels) and displays Log Info as methods but no attributes of it

The client class which is Chain of Responsibility Client has de chain() and main methods.

public abstract class Logger {  
    public static int OUTPUTINFO = 1;  
    public static int ERRORINFO = 2;  
    public static int DEBUGINFO = 3;  
    protected int levels;  
    protected Logger nextLevelLogger;  
public void setNextLevelLogger( Logger nextLevelLogger ) 
{  
        this.nextLevelLogger = nextLevelLogger;  
    }  
        public void logMessage( int levels, String msg )
{  
        if(this.levels <= levels){  
            displayLogInfo(msg);  
        }  
        if (nextLevelLogger != null) {  
            nextLevelLogger.logMessage(levels, msg);  
        }  
    }  
    protected abstract void displayLogInfo(String msg);  
}  

public class DebugBasedLogger extends Logger {  
    public DebugBasedLogger(int levels) {  
        this.levels = levels;  
    }  
    @Override  
    protected void displayLogInfo(String msg) {  
        System.out.println("DEBUG LOGGER INFO: " + msg);  
    }  
}

public class ErrorBasedLogger extends Logger {  
    public ErrorBasedLogger(int levels) {  
        this.levels=levels;  
    }  
    @Override  
    protected void displayLogInfo(String msg) {  
        System.out.println("ERROR LOGGER INFO: " + msg);  
    }  
}

public class ChainofResponsibilityClient {  
    private static Logger doChaining(){  
          Logger consoleLogger = new ConsoleBasedLogger(Logger.OUTPUTINFO);  
            
          Logger errorLogger = new ErrorBasedLogger(Logger.ERRORINFO);  
          consoleLogger.setNextLevelLogger(errorLogger);  
            
          Logger debugLogger = new DebugBasedLogger(Logger.DEBUGINFO);  
          errorLogger.setNextLevelLogger(debugLogger);  
            
          return consoleLogger;   
          }  
          public static void main(String args[]){  
          Logger chainLogger = doChaining();  
  
              chainLogger.logMessage(Logger.OUTPUTINFO, "Enter the sequence of values ");  
              chainLogger.logMessage(Logger.ERRORINFO, "An error has occurred now");  
              chainLogger.logMessage(Logger.DEBUGINFO, "This was the error now debugging is compiled");  
              }  
}  

Conclusion

So in this blog, we focused learning on the chain of responsibility pattern which is one of the behavioral design patterns, its uses, advantages, and also when to use these design patterns, etc. along with an example.