Catena di modello responsabilità

Come suggerisce il nome, catena di modello Responsabilità (catena di responsabilità Pattern) per la richiesta di creare una catena di un oggetto ricevitore. Questo tipo di modello dato alla richiesta, il mittente e il destinatario della richiesta disaccoppiamento. Questo tipo di modelli di progettazione appartengono modelli comportamentali.

In questo modo, ogni destinatario di solito contiene un riferimento a un altro destinatario. Se un oggetto non può elaborare la richiesta, allora sarà la stessa richiesta al destinatario successivo, e così via.

introduzione

Intento: Evitare che richiede il mittente e il destinatario sono accoppiati insieme in modo che più oggetti sono suscettibili di ricevere le richieste, questi oggetti saranno collegati in una catena, e passare la richiesta lungo la catena fino a quando un oggetto gestisce finora.

Processore catena dovere responsabile per la gestione delle richieste, i clienti solo bisogno di inviare la richiesta alla catena di responsabilità può, non deve riguardare i dettagli di elaborazione richiesta di trasferimento e le richieste, in modo che la catena di responsabilità e la richiesta dellarichiesta del mittente: la soluzione principaledisaccoppiato.

Quando utilizzare: quando si tratta di un sacco di strada per filtrare i messaggi.

Come risolvere: le classi di intercettazione implementano una interfaccia unificata.

Il codice chiave: Handler all'interno della polimerizzazione in sé, in HanleRequest se del caso per determinare se, se le condizioni sono tramandate non all'altezza, davanti al quale passò nel set.

Esempi di applicazione: 1, il sogno di Red Mansions "passaggio Drumming da spendere."2, gli eventi JS spumeggiante. 3, Java Web codifica in Apache Tomcat per l'elaborazione, Struts2 intercettore, Filtro jsp di servlet.

Vantaggi: 1, riducono l'accoppiamento.Esso chiede al mittente e il destinatario disaccoppiamento. 2, oggetto semplificata. Così che gli oggetti non hanno bisogno di conoscere la struttura della catena. 3, per migliorare la flessibilità delle responsabilità degli oggetti assegnati. Modificando i componenti della catena o mobilitare il loro ordine, permettendo dinamica aggiungere o eliminare la responsabilità. 4, aggiungere una nuova classe di richiesta del gestore è molto conveniente.

Svantaggi: 1, non può garantire che la richiesta deve essere ricevuto.2, le prestazioni del sistema saranno interessati, ma meno comodo durante il debug di codice può causare il richiamo del ciclo. 3, non possono essere le caratteristiche facilmente osservabili runtime ostacolare il debugging.

scenari di utilizzo: 1, più di un oggetto in grado di gestire la stessa richiesta, in particolare quale oggetto per elaborare la richiesta viene determinata automaticamente dal tempo di esecuzione.2, senza specificare esplicitamente il destinatario di inviare una richiesta a una pluralità di oggetti. 3, una serie di oggetti possono essere assegnati dinamicamente per elaborare la richiesta.

Nota: incontrato in molte applicazioni in Java Web.

realizzazione

Creiamo unAbstractLoggerclasseastratta,con livello di registrazione dettagliata. Abbiamo quindi creare tre tipi di registratori sono estesiAbstractLogger.Ogni livello messaggi logger se il proprio livello, se viene poi stampato di conseguenza, altrimenti non stampare il messaggio al successivo e un registratore.

fase 1

Creare record di classe astratta.

AbstractLogger.java

classe astratta pubblica AbstractLogger {
   public static int INFO = 1;
   int DEBUG public static = 2;
   int ERROR public static = 3;

   livello int protetta;

   // La catena di responsabilità nel successivo elemento protetto AbstractLogger nextLogger;

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

   logMessage public void (livello int, String message) {
      if (this.level <= livello) {
         scrittura (messaggio);
      }
      if (nextLogger! = null) {
         nextLogger.logMessage (livello, messaggio);
      }
   }

   astratto protetto da scrittura void (String message);
	
}

fase 2

Creare classi di entità che estendono la classe record.

ConsoleLogger.java

public class ConsoleLogger estende AbstractLogger {

   pubblico ConsoleLogger (livello int) {
      this.level = livello;
   }

   @Override
   protetto da scrittura void (String message) {		
      System.out.println ( "Standard Console :: Logger:" + messaggio);
   }
}

ErrorLogger.java

public class ErrorLogger estende AbstractLogger {

   pubblico ErrorLogger (livello int) {
      this.level = livello;
   }

   @Override
   protetto da scrittura void (String message) {		
      System.out.println ( "Errore Console :: Logger:" + messaggio);
   }
}

FileLogger.java

public class FileLogger estende AbstractLogger {

   pubblico FileLogger (livello int) {
      this.level = livello;
   }

   @Override
   protetto da scrittura void (String message) {		
      System.out.println ( "File :: Logger:" + messaggio);
   }
}

fase 3

Creare diversi tipi di registratori. Dare loro diversi livelli di errore, e stabilendo un record in ciascuna del registratore. Ogni rappresentante prossimo registratore logger è parte della catena.

ChainPatternDemo.java

public class ChainPatternDemo {
	
   getChainOfLoggers AbstractLogger statici privati ​​() {

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

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

      tornare errorLogger;	
   }

   Main (string [] args) {public static void
      AbstractLogger loggerChain = getChainOfLoggers ();

      loggerChain.logMessage (AbstractLogger.INFO, 
         "Si tratta di una informazione.");

      loggerChain.logMessage (AbstractLogger.DEBUG, 
         "Questo è un livello di debug informazioni.");

      loggerChain.logMessage (AbstractLogger.ERROR, 
         "Si tratta di una informazione di errore.");
   }
}

fase 4

Verifica uscita.

Standard Console :: Logger: Si tratta di una informazione.
File :: Logger: Questo è un dato livello di debug.
Standard Console :: Logger: Questo è un dato livello di debug.
Errore Console :: Logger: Si tratta di una informazione di errore.
File :: Logger: Si tratta di una informazione di errore.
Standard Console :: Logger: Si tratta di una informazione di errore.