Verantwortungskette Muster

Wie der Name schon sagt, Zuständigkeitskette-Muster (Zuständigkeitskette-Muster) für die Anforderung einer Kette von einem Empfänger-Objekt zu erstellen. Diese Art von Muster auf die Anforderung gegeben, der Absender und der Empfänger der Anforderung Entkopplung. Diese Art von Entwurfsmustern gehören Verhaltensmuster.

In diesem Modus enthält jeder Empfänger in der Regel ein Hinweis auf einen anderen Empfänger. Wenn ein Objekt die Anforderung nicht verarbeiten kann, dann wird es die gleiche Anfrage an den nächsten Empfänger, und so weiter.

Einführung

Intent: Vermeiden Sie die Sender und Empfänger anfordert zusammen gekoppelt sind , so dass mehrere Objekte wahrscheinlich Anfragen erhalten, werden diese Objekte in einer Kette verbunden werden, und die Anforderung entlang der Kette passieren , bis ein Objekt , um es so weit behandelt.

Prozessor Prozessorleistungskette verantwortlich für Anfragen Umgang mit Kunden müssen nur die Anforderung an die Verantwortungskette zu senden können, müssen die Anforderungsübertragungsverarbeitung Details und Anfragen nicht betreffen, so dass die Kette der Verantwortung und die Anforderung desAntrags des Absenders: die Hauptlösungentkoppelt.

Wann verwendet man :Wenn mit viel Straßen Umgang Nachrichten zu filtern.

Wie zu beheben: Abfangen Klassen eine einheitliche Schnittstelle zu implementieren.

Der Schlüsselcode: Handler innerhalb die Polymerisation selbst in HanleRequest gegebenenfalls zu bestimmen , ob, wenn die Bedingungen nicht bis übergeben werden, vor dem in den Satz übergeben.

Anwendungsbeispiele: 1, Der Traum der Roten Kammer "Drumming Pass zu verbringen."2, JS Ereignisse sprudeln. 3, JAVA WEB Encoding im Apache Tomcat für die Verarbeitung, Struts2 Interceptor, jsp Servlets Filter.

Vorteile: 1, reduzieren Sie die Kupplung.Er fordert den Sender und Empfänger Entkopplung. 2, vereinfachte Objekt. So, dass Objekte nicht brauchen, um die Struktur der Kette kennen. 3, um die Flexibilität der Objekt übertragenen Aufgaben zu verbessern. Durch die Kettenglieder zu ändern oder mobilisieren, um ihre Bestellung, so dass dynamische Hinzufügen oder Haftung löschen. 4, fügen Sie eine neue Anfrage-Handler-Klasse ist sehr bequem.

Nachteile: 1, kann nicht garantieren , dass der Antrag eingegangen sein muss.2, wird die Systemleistung beeinträchtigt werden, aber weniger bequem Code während des Debuggens kann den Zyklus-Aufruf verursachen. 3 kann nicht ohne weiteres beobachtbar Merkmale Laufzeit hinder Debuggen sein.

Einsatzszenarien: 1, mehr als ein Objekt die gleiche Anforderung verarbeiten, insbesondere die Objekt die Anforderung zu verarbeiten wird automatisch von der Laufzeit bestimmt.2, ohne explizit den Empfänger an eine Anforderung an eine Vielzahl von Objekten zu unterbreiten. 3 kann eine Reihe von Objekten dynamisch die Anforderung zu verarbeiten zugeordnet werden.

Hinweis: Bei vielen Anwendungen in Java Web begegnet.

Realisierung

Wir schaffen eine abstrakte KlasseAbstractLoggermit detaillierten Protokollebene. Dann erstellen wir drei Typen von RecordernAbstractLoggerwerdenerweitert.Jede Ebene Logger-Meldungen, ob ihre eigene Ebene, wenn es dann entsprechend ausgedruckt wird, sonst wird es nicht die Nachricht an den nächsten und einem Recorder drucken.

Schritt 1

Erstellen Sie abstrakte Klassenrekord.

AbstractLogger.java

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

   geschützt int Ebene;

   // Die Kette der Verantwortung im nächsten Element geschützt AbstractLogger nextLogger;

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

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

   abstrakt protected void write (String message);
	
}

Schritt 2

Erstellen von Entity-Klassen, die die Datensatzklasse erweitern.

ConsoleLogger.java

public class Console erweitert AbstractLogger {

   public Console (int level) {
      this.level = Ebene;
   }

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

ErrorLogger.java

public class ErrorLogger erstreckt AbstractLogger {

   public ErrorLogger (int level) {
      this.level = Ebene;
   }

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

FileLogger.java

public class Filelogger erweitert AbstractLogger {

   public Filelogger (int level) {
      this.level = Ebene;
   }

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

Schritt 3

Erstellen Sie verschiedene Arten von Rekordern. Geben Sie ihnen verschiedene Ebenen der Fehler, und eine Aufzeichnung in jeder der Recorder-Einstellung. Jeder Logger Recorder nächste Vertreter ist 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 Console = new Console (AbstractLogger.INFO);

      errorLogger.setNextLogger (Filelogger);
      fileLogger.setNextLogger (Console);

      Rückkehr errorLogger;	
   }

   public static void main (String [] args) {
      AbstractLogger loggerChain = getChainOfLoggers ();

      loggerChain.logMessage (AbstractLogger.INFO, 
         "Dies ist eine Information.");

      loggerChain.logMessage (AbstractLogger.DEBUG, 
         "Dies ist ein Debug-Level-Informationen.");

      loggerChain.logMessage (AbstractLogger.ERROR, 
         "Dies ist eine Fehlerinformation.");
   }
}

Schritt 4

Stellen Sie sicher, ausgegeben.

Standard-Konsole :: Logger: Dies ist eine Information.
File :: Logger: Dies ist ein Debug-Level-Informationen.
Standard-Konsole :: Logger: Dies ist ein Debug-Level-Informationen.
Fehlerkonsole :: Logger: Dies ist eine Fehlerinformation.
File :: Logger: Dies ist eine Fehlerinformation.
Standard-Konsole :: Logger: Dies ist eine Fehlerinformation.