Patron Chaîne de responsabilité

Le patron Chaîne de responsabilité crée une chaîne d'objets récepteurs pour une requête. Ce patron découple l'expéditeur et le récepteur de la requête en fonction du type de requête. Ce type de patron de conception appartient aux patrons comportementaux.

Le patron Chaîne de responsabilité relie plusieurs gestionnaires (objets de traitement) dans une structure de chaîne, permettant à la requête d'être transmise le long de la chaîne jusqu'à ce qu'un gestionnaire la traite.

Le patron Chaîne de responsabilité permet à plusieurs objets d'avoir l'opportunité de traiter la requête, évitant ainsi le couplage entre l'expéditeur et le récepteur de la requête. Ces objets sont connectés en une chaîne, et la requête est transmise le long de la chaîne.

Introduction

intention

Permet à la requête de traverser la chaîne de gestionnaires jusqu'à ce que la requête soit traitée.

Principaux problèmes résolus

Découple l'émetteur et le récepteur de la requête, permettant à plusieurs objets d'avoir la possibilité de recevoir la requête, sans que l'émetteur ait besoin de savoir quel objet la traitera.

Cas d'utilisation

Lorsque plusieurs objets peuvent traiter une requête et que l'objet précis qui la traite est déterminé à l'exécution.
Lorsque vous devez soumettre une requête à l'un de plusieurs objets sans spécifier explicitement le récepteur.

Approche d'implémentation

Définir l'interface de gestionnaire: Tous les gestionnaires doivent implémenter la même interface.
Créer des gestionnaires concrets: Des classes concrètes implémentant l'interface, contenant la logique de traitement des requêtes et une référence au gestionnaire suivant dans la chaîne.

Code clé

Interface de gestionnaire: Définir une méthode pour traiter les requêtes.
Classe ConcreteHandler: Implémente l'interface Handler, contenant la logique de traitement des requêtes et une référence au gestionnaire suivant.

Exemple d'application

Patate chaude: Comportement de transmission dans un jeu, jusqu'à ce que la musique s'arrête.
Remontée d'événements: En JavaScript, les événements partent de l'élément le plus spécifique et se propagent vers le haut, niveau par niveau.
Serveur web: Les exemples incluent Apache Tomcat gérant l'encodage des caractères, les intercepteurs Struts2 et les filtres Servlet.

Avantages

Réduire le couplage: Découpler l'émetteur et le récepteur.
Simplifier les objets: L'objet n'a pas besoin de connaître la structure de la chaîne.
Flexibilité: Ajouter ou supprimer dynamiquement des responsabilités en modifiant les membres ou l'ordre de la chaîne.
Facile à étendre: Il est pratique d'ajouter de nouvelles classes de gestionnaires de requêtes.

Inconvénients

Requête non traitée: Il n'y a aucune garantie que la requête sera reçue par un gestionnaire de la chaîne.
Impact sur les performances: Peut affecter les performances du système, et le débogage est difficile, peut conduire à des appels circulaires.
Difficile à observer: Les caractéristiques d'exécution ne sont pas évidentes, ce qui peut entraver le débogage.

Suggestions d'utilisation

Lors du traitement d'une requête, s'il existe plusieurs gestionnaires potentiels, envisagez d'utiliser le modèle de chaîne de responsabilité.
Assurez-vous que chaque gestionnaire de la chaîne sait clairement comment transmettre la requête au maillon suivant de la chaîne.

Notes

Dans le développement Web Java, le modèle de chaîne de responsabilité est largement utilisé, comme les chaînes de filtres, les intercepteurs, etc.

Structure

Il implique principalement les rôles principaux suivants :

Gestionnaire abstrait :
- Définir une interface pour le traitement des requêtes, contenant généralement une méthode pour traiter la requête (telle quehandleRequest) et une référence au gestionnaire suivant (successeur).
Gestionnaire concret :
- Implémente l'interface abstraite de gestionnaire et est responsable du traitement des requêtes. S'il peut traiter la requête, il la traite directement ; sinon, il transmet la requête au gestionnaire suivant.
Client :
- Créer des objets gestionnaires et les relier en une chaîne de responsabilité. Habituellement, le client n'a besoin que d'envoyer la requête au premier gestionnaire de la chaîne, sans avoir à se soucier du traitement spécifique de la requête.

Implémentation

Nous créons une classe abstraiteAbstractLogger, avec des niveaux de journalisation détaillés. Ensuite, nous créons trois types de journaliseurs, qui étendent tousAbstractLogger. Chaque journaliseur vérifie si le niveau du message correspond à son propre niveau ; si oui, il l'affiche en conséquence ; sinon, il n'affiche pas et transmet le message au journaliseur suivant.

Étape 1

Créer une classe abstraite de journalisation.

AbstractLogger.java

public abstract class AbstractLogger { public static int INFO = 1; public static int DEBUG = 2; public static int ERROR = 3; protected int level; //L'élément suivant dans la chaîne de responsabilité 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); }

Étape 2

Créez des classes d'entité qui étendent la classe logger.

ConsoleLogger.java

public class ConsoleLogger extends AbstractLogger { public ConsoleLogger(int level){ this.level = level; } @Override protected void write(String message) { System.out.println("Console standard::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("Console d'erreur::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); } }

Étape 3

Créez différents types de loggers. Attribuez-leur différents niveaux d'erreur et définissez le logger suivant dans chaque logger. Le logger suivant dans chaque logger représente une partie de la chaîne.

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, "Ceci est une information."); loggerChain.logMessage(AbstractLogger.DEBUG, "Ceci est une information de niveau debug."); loggerChain.logMessage(AbstractLogger.ERROR, "Ceci est une information d'erreur."); } }

Étape 4

Exécutez le programme, résultats de sortie:

Standard Console::Logger: This is an information.
File::Logger: This is a debug level information.
Standard Console::Logger: This is a 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.

autres extensions

Patrons de conceptionAutres