Rasimsen: /* Step 3 */

2018-09-19T20:12:11Z

‎Step 3

Rasimsen at 20:11, 19 September 2018

2018-09-19T20:11:39Z

Rasimsen: Created page with "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 t..."

2018-09-18T22:09:41Z

Created page with "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 t..."

New page

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.

@@ Line 121: / Line 121: @@
+    }
+}
+</souce>
 =Step 4=
 Verify the output.

← Older revision		Revision as of 20:11, 19 September 2018
Line 5:		Line 5:
	=Implementation=		=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.		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.
		+
		+	https://www.tutorialspoint.com/design_pattern/images/chain_pattern_uml_diagram.jpg
		+
		+	=Step 1=
		+	Create an abstract logger class.
		+
		+	AbstractLogger.java
		+	<source>
		+	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);
		+
		+	}
		+
		+	</source>
		+
		+	=Step 2=
		+	Create concrete classes extending the logger.
		+
		+	ConsoleLogger.java
		+	<source>
		+	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);
		+	}
		+	}
		+	</source>
		+	ErrorLogger.java
		+	<source>
		+	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);
		+	}
		+	}
		+	</source>
		+	FileLogger.java
		+	<source>
		+	public class FileLogger extends AbstractLogger {
		+
		+	public FileLogger(int level){
		+	this.level = level;
		+	}
		+
		+	@Override
		+	protected void write(String message) {
		+	System.out.println("File::Logger: " + message);
		+	}
		+	}
		+	</source>
		+
		+
		+	=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
		+	<source>
		+	public class ChainPatternDemo {
		+
		+	private static AbstractLogger getChainOfLoggers(){
		+
		+	AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
		+	AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
		+	AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
		+
		+	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.
		+	<source>
		+	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.
		+	</source>

Chain of Responsibility Design Pattern - Revision history

Rasimsen: /* Step 3 */

Rasimsen at 20:11, 19 September 2018

Rasimsen: Created page with "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 t..."