Scribd
Upload
24 views

Chain of Responibility Pattern

The chain of responsibility pattern creates a chain of receiver objects to handle a request, passing it along the chain until an object handles it. This pattern decouples senders and receivers. The example creates an abstract logger class and three concrete logger classes extending it. Loggers are chained together by setting the next logger and passing messages along until one handles it.

Uploaded by

Natalia B.
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
24 views

Chain of Responibility Pattern

The chain of responsibility pattern creates a chain of receiver objects to handle a request, passing it along the chain until an object handles it. This pattern decouples senders and receivers. The example creates an abstract logger class and three concrete logger classes extending it. Loggers are chained together by setting the next logger and passing messages along until one handles it.

Uploaded by

Natalia B.
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

15/01/24, 11:50 Chain of Responsibility Pattern

Chain of Responsibility Pattern

As the name suggests, the chain of responsibility pattern creates a chain of receiver
objects for a request. This pattern decouples sender and receiver of a request based
on type of request. This pattern comes under behavioral patterns.

In this pattern, normally each receiver contains reference to another receiver. If one
object cannot handle the request then it passes the same to the next receiver and so
on.

Implementation
We have created an abstract class AbstractLogger with a level of logging. Then we
have created three types of loggers extending the AbstractLogger. Each logger
checks the level of message to its level and print accordingly otherwise does not
print and pass the message to its next logger.

Step 1
Create an abstract logger class.

AbstractLogger.java

https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.htm 1/4
15/01/24, 11:50 Chain of Responsibility Pattern

public abstract class AbstractLogger {


public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;

protected int level;

//next element in chain or responsibility


protected AbstractLogger nextLogger;

public void setNextLogger(AbstractLogger nextLogger){


this.nextLogger = nextLogger;
}

public void logMessage(int level, String message){


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

abstract protected void write(String message);

Step 2
Create concrete classes extending the logger.

ConsoleLogger.java

public class ConsoleLogger extends AbstractLogger {

public ConsoleLogger(int level){


this.level = level;
}

@Override
protected void write(String message) {
System.out.println("Standard Console::Logger: " + message);
https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.htm 2/4
15/01/24, 11:50 Chain of Responsibility Pattern

}
}

ErrorLogger.java

public class ErrorLogger extends AbstractLogger {

public ErrorLogger(int level){


this.level = level;
}

@Override
protected void write(String message) {
System.out.println("Error Console::Logger: " + message);
}
}

FileLogger.java

public class FileLogger extends AbstractLogger {

public FileLogger(int level){


this.level = level;
}

@Override
protected void write(String message) {
System.out.println("File::Logger: " + message);
}
}

Step 3
Create different types of loggers. Assign them error levels and set next logger in
each logger. Next logger in each logger represents the part of the chain.

ChainPatternDemo.java

public class ChainPatternDemo {

private static AbstractLogger getChainOfLoggers(){

https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.htm 3/4
15/01/24, 11:50 Chain of Responsibility Pattern

AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERRO


AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG)
AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.

errorLogger.setNextLogger(fileLogger);
fileLogger.setNextLogger(consoleLogger);

return errorLogger;
}

public static void main(String[] args) {


AbstractLogger loggerChain = getChainOfLoggers();

loggerChain.logMessage(AbstractLogger.INFO,
"This is an information.");

loggerChain.logMessage(AbstractLogger.DEBUG,
"This is an debug level information.");

loggerChain.logMessage(AbstractLogger.ERROR,
"This is an error information.");
}
}

Step 4
Verify the output.

Standard Console::Logger: This is an information.


File::Logger: This is an debug level information.
Standard Console::Logger: This is an debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.htm 4/4

You might also like