Chaîne de motif de responsabilité
Comme son nom l'indique, chaîne de responsabilité (de la chaîne de responsabilité Pattern) pour la demande de création d'une chaîne d'un objet récepteur. Ce type de modèle donné à la demande, l'expéditeur et le destinataire de la demande de découplage. Ce type de modèles de conception appartiennent schémas comportementaux.
Dans ce mode, chaque destinataire contient généralement une référence à un autre destinataire. Si un objet ne peut pas traiter la demande, alors il sera la même demande au destinataire suivant, et ainsi de suite.
introduction
Intention: éviter de demander à l'expéditeur et le récepteur sont couplés ensemble de sorte que plusieurs objets sont susceptibles de recevoir des demandes, ces objets seront connectés dans une chaîne, et de passer la demande de la chaîne jusqu'à ce qu'un objet gère jusqu'à présent.
Processeur chaîne responsable du traitement des demandes de service, les clients ne doivent envoyer la demande à la chaîne de responsabilité peut, ne doit pas concerner les détails et le traitement des demandes de transfert de la demande, de sorte que la chaîne de responsabilité et de la demande dela demande de l'expéditeur: la principale solutiondécouplée.
Quand utiliser: en traitant avec beaucoup de route pour filtrer les messages.
Comment corriger: les classes d'interception de mettre en œuvre une interface unifiée.
Le code clé: Handler dans la polymérisation elle - même, dans HanleRequest le cas échéant afin de déterminer si, si les conditions sont transmises pas, devant qui passait dans l'ensemble.
Exemples d'application: 1, The Dream of Red Mansions "pass Drumming de passer."2, les événements JS bouillonnant. 3, JAVA Encodage WEB dans le Tomcat Apache pour le traitement, Struts2 intercepteur, Filtre jsp servlet.
Avantages: 1, réduisent le couplage.Il demande à l'expéditeur et le destinataire découplage. 2, objet simplifié. De sorte que les objets ne sont pas besoin de connaître la structure de la chaîne. 3, pour améliorer la flexibilité de l'objet assigné responsabilités. En changeant les membres de la chaîne ou de mobiliser leur ordre, permettant add dynamique ou supprimer la responsabilité. 4, ajouter une nouvelle classe demande de gestionnaire est très pratique.
Inconvénients: 1, ne peuvent pas garantir que la demande doit être reçue.2, la performance du système sera affecté, mais moins pratique pendant le débogage du code peut provoquer l'appel du cycle. 3, peuvent ne pas être facilement observables caractéristiques runtime entraver le débogage.
Scénarios d' utilisation:1, plus d'un objet peut gérer la même demande, en particulier quel objet pour traiter la demande est automatiquement déterminé par le temps d'exécution. 2, sans explicitement spécifier le destinataire à soumettre une demande à une pluralité d'objets. 3, un ensemble d'objets peuvent être affectés dynamiquement pour traiter la demande.
Remarque: rencontré dans de nombreuses applications en JAVA WEB.
réalisation
Nous créons uneAbstractLoggerclasseabstraite,avec le niveau de journalisation détaillée. Nous créons alors trois types d'enregistreurs sont étendusAbstractLogger.Chaque messages de l'enregistreur de niveau si leur propre niveau, si elle est ensuite imprimée en conséquence, sinon il ne sera pas imprimer le message à l'autre et d'un enregistreur.
Etape 1
Créer dossier de classe abstraite.
AbstractLogger.java
public abstract class AbstractLogger {
public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;
niveau int protégé;
// La chaîne de responsabilité dans l'élément suivant protégé AbstractLogger nextLogger;
setNextLogger public void (AbstractLogger nextLogger) {
this.nextLogger = nextLogger;
}
logMessage public void (niveau int, String message) {
if (this.level <= niveau) {
écrire (message);
}
if (nextLogger! = null) {
nextLogger.logMessage (niveau, message);
}
}
abstrait écriture protected void (message String);
}
Etape 2
Créer des classes d'entités qui étendent la classe d'enregistrement.
ConsoleLogger.java
ConsoleLogger public class AbstractLogger {
publique ConsoleLogger (niveau int) {
this.level = niveau;
}
@Override
écriture protected void (String message) {
( "L'enregistreur de la console standard:" + message) System.out.println;
}
}
ErrorLogger.java
ErrorLogger public class AbstractLogger {
publique ErrorLogger (niveau int) {
this.level = niveau;
}
@Override
écriture protected void (String message) {
System.out.println ( "Logger :: Error Console:" + message);
}
}
FileLogger.java
public class FileLogger étend AbstractLogger {
publique FileLogger (niveau int) {
this.level = niveau;
}
@Override
écriture protected void (String message) {
System.out.println ( "File :: Logger:" + message);
}
}
Etape 3
Créer différents types d'enregistreurs. Donnez-leur différents niveaux d'erreur, et établissant un record dans chacun de l'enregistreur. Chaque prochain représentant de l'enregistreur de l'enregistreur fait partie de la chaîne.
ChainPatternDemo.java
public class ChainPatternDemo {
getChainOfLoggers de AbstractLogger statiques privés () {
AbstractLogger errorLogger = new ErrorLogger (AbstractLogger.ERROR);
AbstractLogger fileLogger = new FileLogger (AbstractLogger.DEBUG);
AbstractLogger ConsoleLogger = new ConsoleLogger (AbstractLogger.INFO);
errorLogger.setNextLogger (fileLogger);
fileLogger.setNextLogger (ConsoleLogger);
retour errorLogger;
}
main (String [] args) {public static void
AbstractLogger loggerChain = getChainOfLoggers ();
loggerChain.logMessage (AbstractLogger.INFO,
"Ceci est une information.");
loggerChain.logMessage (AbstractLogger.DEBUG,
"Ceci est une information de niveau de débogage.");
loggerChain.logMessage (AbstractLogger.ERROR,
"Ceci est une information d'erreur.");
}
}
Etape 4
Vérifiez la sortie.
Le Logger Standard Console: Ceci est une information. File :: Logger: Ceci est une information de niveau de débogage. Le Logger Standard Console: Ceci est une information de niveau de débogage. L'enregistreur de la console d'erreur: Ceci est une information d'erreur. File :: Logger: Ceci est une information d'erreur. Le Logger Standard Console: Ceci est une information d'erreur.