Muster der Verantwortungskette

Wie der Name schon sagt, erstellt das Verantwortungskettenmuster eine Kette von Empfängerobjekten für eine Anforderung. Dieses Muster entkoppelt Sender und Empfänger einer Anfrage basierend auf der Art der Anfrage. Dieses Muster fällt unter Verhaltensmuster.

In diesem Muster enthält normalerweise jeder Empfänger einen Verweis auf einen anderen Empfänger. Wenn ein Objekt die Anforderung nicht verarbeiten kann, gibt es dasselbe an den nächsten Empfänger weiter und so weiter.

Implementierung

Wir haben eine abstrakte Klasse AbstractLogger mit einer Protokollierungsstufe erstellt. Dann haben wir drei Arten von Loggern erstellt, die den AbstractLogger erweitern . Jeder Logger überprüft die Nachrichtenebene auf ihre Ebene und druckt entsprechend. Andernfalls wird die Nachricht nicht gedruckt und an den nächsten Logger weitergeleitet.

Schritt 1

Erstellen Sie eine abstrakte Logger-Klasse.

AbstractLogger.java

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);
	
}

Schritt 2

Erstellen Sie konkrete Klassen, die den Logger erweitern.

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);
   }
}

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);
   }
}

Schritt 3

Erstellen Sie verschiedene Arten von Loggern. Weisen Sie ihnen Fehlerstufen zu und legen Sie in jedem Logger den nächsten Logger fest. Der nächste Logger in jedem Logger repräsentiert den Teil der Kette.

ChainPatternDemo.java

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.");
   }
}

Schritt 4

Überprüfen Sie die Ausgabe.

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.