Łańcuch zobowiązań

Jak sama nazwa wskazuje, Sieć wzorca odpowiedzialności (łańcuch zobowiązań) na żądanie, aby utworzyć łańcuch obiektu odbiornika. Ten rodzaj wzorca zwrócić na żądanie, nadawcy i odbiorcy żądanie oddzielenia. Tego rodzaju wzorców projektowych należą wzorców zachowań.

W tym trybie, każdy odbiorca zazwyczaj zawierają odniesienie do innego odbiorcy. Jeśli obiekt nie może przetworzyć żądania, to samo zapytanie do kolejnego odbiorcy, a więc na nim.

wprowadzenie

Intencja: Unikać zainteresowanie nadawca i odbiorca są połączone ze sobą tak, że wiele obiektów mogą odbierać żądania, obiekty te zostaną połączone w łańcuch, i przekazać wniosek w łańcuchu, aż obiekt obsługuje go do tej pory.

Łańcuch obowiązkiem Procesor Procesor odpowiedzialny za obsługę żądań, klienci muszą tylko wysłać żądanie do łańcucha odpowiedzialności może, nie musi dotyczyć szczegóły przetwarzania transferu żądania i prośby, więc łańcuch odpowiedzialności i wniosekżądania nadawcy: główny rozwiązanie oddzielone.

Kiedy stosować: gdy mamy do czynienia z dużo drogi do filtrowania wiadomości.

Jak naprawić: zajęcia przechwytywania wdrożyć jednolity interfejs.

Kod klawisza: Handler wewnątrz samego polimeryzacji w HanleRequest w stosownych przypadkach w celu ustalenia, czy jeżeli są przekazywane warunki dół nie w górę, przed którym przeszedł do zestawu.

Przykłady zastosowań: 1, Dream of Red Mansions "Drumming wprost wydać."2, imprezy JS pęcherzyków. 3, Java Web Kodowanie w Apache Tomcat do przetworzenia, Struts2 przechwytujących, jsp Filtr apletu.

Zalety: 1, zmniejszyć sprzęgła.Zwraca się do nadawcy i odbiorcy oddzielenia. 2, uproszczone obiektu. Tak, że przedmioty nie trzeba znać strukturę łańcucha. 3, w celu zwiększenia elastyczności obiektu przypisany odpowiedzialności. Poprzez zmianę elementów łańcucha lub mobilizować ich kolejność, umożliwiając dynamiczne dodawanie lub usuwanie odpowiedzialności. 4, należy dodać nową klasę żądania obsługi jest bardzo wygodne.

Wady: 1, nie może zagwarantować, że wniosek musi być przyjęty.2, wydajność systemu będzie miała wpływu, ale mniej wygodne podczas debugowania kodu może spowodować wywołanie cyklu. 3, nie mogą być łatwo obserwowalne cechy wykonawcze utrudniać debugowania.

Scenariusze użycia: 1, więcej niż jeden obiekt może obsługiwać ten sam wniosek, w szczególności, które sprzeciwiają się przetworzyć żądania jest określana automatycznie w momencie uruchomienia.2, bez wyraźnego określenia odbiorcy, aby złożyć wniosek do wielu obiektów. 3, zestaw obiektów może być dynamicznie przydzielany do przetwarzania żądania.

Uwaga: spotykanych w wielu aplikacjach w Java Web.

realizacja

Tworzymy klasę abstrakcyjnąAbstractLogger,ze szczegółowym poziomie rejestrowania. Następnie tworzymy trzy rodzaje rejestratorów są rozszerzoneAbstractLogger.Każdy komunikaty poziomu rejestratora, czy swoim poziomie, jeśli jest następnie wydrukowany odpowiednio, w przeciwnym razie nie będzie wydrukować wiadomość do następnego i rejestratora.

Etap 1

Tworzenie klasy abstrakcyjnej rekord.

AbstractLogger.java

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

   chronione int poziom;

   // Łańcuch odpowiedzialności następnego elementu chronione AbstractLogger nextLogger;

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

   public void LogMessage (int poziomie, komunikat String) {
      if (this.level <= poziom) {
         write (message);
      }
      if (nextLogger! = null) {
         nextLogger.logMessage (poziom, message);
      }
   }

   abstrakcyjne protected void write (komunikat String);
	
}

Etap 2

Tworzenie klas encji, które rozszerzają klasę rekordu.

ConsoleLogger.java

public class ConsoleLogger rozciąga AbstractLogger {

   publicznego ConsoleLogger (int level) {
      this.level = poziom;
   }

   @Override
   protected void write (komunikat String) {		
      System.out.println ( "standard Console :: Rejestrator:" + komunikat);
   }
}

ErrorLogger.java

public class ErrorLogger rozciąga AbstractLogger {

   publicznego ErrorLogger (int level) {
      this.level = poziom;
   }

   @Override
   protected void write (komunikat String) {		
      System.out.println ( "Konsola błędów :: Rejestrator:" + komunikat);
   }
}

FileLogger.java

public class FileLogger rozciąga AbstractLogger {

   publicznego FileLogger (int level) {
      this.level = poziom;
   }

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

etap 3,

Tworzyć różne rodzaje rejestratorów. Daj im różne poziomy błędu i ustanawiając rekord w każdej z rejestratora. Każdy rejestrator rejestrator obok przedstawicielem jest częścią łańcucha.

ChainPatternDemo.java

{public class ChainPatternDemo
	
   private static getChainOfLoggers AbstractLogger () {

      AbstractLogger errorLogger = new ErrorLogger (AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger (AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger (AbstractLogger.INFO);

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

      powrót errorLogger;	
   }

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

      loggerChain.logMessage (AbstractLogger.INFO, 
         "To jest informacja.");

      loggerChain.logMessage (AbstractLogger.DEBUG, 
         "To jest informacja poziom debugowania.");

      loggerChain.logMessage (AbstractLogger.ERROR, 
         "To jest informacja o błędzie.");
   }
}

Etap 4

Sprawdź, czy wyjście.

Standardu Console :: Rejestrator: To jest informacja.
File :: Rejestrator: Jest to informacja poziom debugowania.
Standardu Console :: Rejestrator: Jest to informacja poziom debugowania.
Konsola błędów :: Rejestrator: To jest informacja o błędzie.
File :: Rejestrator: To jest informacja o błędzie.
Standardu Console :: Rejestrator: To jest informacja o błędzie.