Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Le modèle de chaîne de responsabilité est un modèle de conception comportemental qui permet à plusieurs objets de gérer les demandes en séquence, et chaque objet peut choisir de gérer la demande ou de la transmettre à l'objet suivant. Ce modèle offre une plus grande flexibilité et évolutivité en dissociant l'expéditeur et le destinataire des requêtes. Ce qui suit est une introduction détaillée au modèle de chaîne de responsabilité :

1. Définition et idées principales

Le cœur du modèle de chaîne de responsabilité consiste à concevoir une chaîne de demande et à identifier la fin de la chaîne. Il connecte plusieurs objets de gestion de requêtes dans une chaîne et permet à la requête de passer dans la chaîne jusqu'à ce qu'un objet de la chaîne décide de gérer la requête. Le client qui fait la demande ne sait pas quel objet de la chaîne traitera finalement la demande, ce qui permet au système de se réorganiser et d'attribuer dynamiquement les responsabilités sans affecter le client.

2. Diagramme de classes et rôles principaux

Diagramme de classes :

Le modèle de chaîne de responsabilité comprend principalement les rôles suivants :

1. Gestionnaire abstrait (gestionnaire) : Définir une interface de traitement des requêtes. Si nécessaire, l'interface peut définir une méthode pour définir et renvoyer une référence à l'interface suivante. Ce rôle est généralement implémenté par une classe abstraite ou une interface.

2. Manipulateur de béton : Après avoir reçu la demande, le processeur spécifique peut choisir de traiter la demande ou de transmettre la demande à la partie suivante. Étant donné que le processeur de béton détient une référence à la maison suivante, il peut accéder à la maison suivante si nécessaire.

3. Classe client (Client): Créez une chaîne de traitement et soumettez une requête à l'objet processeur spécifique du responsable de la chaîne.

3. Scénarios applicables

Le modèle de chaîne de responsabilité convient aux scénarios suivants :

1. Plusieurs objets traitent conjointement une tâche: Par exemple, un système d'approbation à plusieurs niveaux transmet la demande d'approbation au niveau d'approbateur suivant en fonction de l'autorité et du niveau de l'approbateur jusqu'à ce que le résultat final de l'approbation soit obtenu.

2. Flux de traitement de combinaison dynamique: En configurant de manière flexible la chaîne de responsabilité, les objets de traitement peuvent être combinés dynamiquement pour mettre en œuvre différents processus de traitement.

3. Évitez le couplage direct entre l’expéditeur et le destinataire d’une requête: En transmettant la demande à la chaîne de responsabilité, l'expéditeur de la demande n'a pas besoin de connaître l'objet de traitement spécifique, ce qui réduit la dépendance entre les objets.

4. Avantages et inconvénients

avantage

1. Réduire l'accouplement: Il découple l'expéditeur et le destinataire de la requête. La requête est uniquement envoyée, peu importe qui la traite.
2. Flexibilité améliorée dans l’affectation des objets: Permet l'ajout ou la suppression dynamique de responsabilités en changeant les membres au sein de la chaîne ou en déplaçant leur ordre.
3. Simplifier les objets: L'objet n'a pas besoin de connaître la structure de la chaîne.
4. Il est pratique d'ajouter de nouvelles classes de traitement des requêtes: Suivant le principe d'ouverture et de fermeture, de nouveaux processeurs peuvent être ajoutés à la chaîne de responsabilité à tout moment sans modifier le code existant, offrant une bonne évolutivité.

défaut

1. Il n'y a aucune garantie que la demande sera acceptée: Si la chaîne de responsabilité n'est pas configurée correctement, ou si un processeur ne traite pas correctement la demande, la demande peut ne pas être traitée.
2. Les problèmes de performance: Lorsque la chaîne de responsabilité est trop longue ou que des demandes sont fréquemment transmises dans la chaîne de responsabilité, les performances peuvent être affectées.
3. Le débogage n'est pas pratique: Lorsque la chaîne de responsabilité est particulièrement longue et comporte de nombreux maillons, la logique peut être plus compliquée lors du débogage en raison d'une approche récursive.

5. Scénarios d'application

Le modèle de chaîne de responsabilité est largement utilisé dans de nombreux domaines, notamment :

1. Système de journalisation: Transmettez les messages de journal à différents enregistreurs en fonction du niveau de journalisation, tels que l'enregistreur de console, l'enregistreur de fichiers, l'enregistreur de base de données, etc.
2. Système de gestion des exceptions: Classez les exceptions selon leurs types, tels que la journalisation, les notifications par e-mail, l'affichage des exceptions, etc.
3. Système d'approbation à plusieurs niveaux: Par exemple, approbation de congé, approbation d'achat, etc., la demande d'approbation est transmise à l'approbateur de niveau suivant en fonction de l'autorité et du niveau de l'approbateur.

6. Exemples de mise en œuvre

Ce qui suit est un exemple simple d'implémentation du modèle de chaîne de responsabilité, qui est utilisé pour traiter les messages de journal et transmettre les messages à différents processeurs en fonction du niveau de journalisation (tel que DEBUG, INFO, WARN, ERROR) :

// 抽象处理者  
abstract class LogHandler {  
    protected int level;  
    protected LogHandler nextHandler;  
  
    public void setNextHandler(LogHandler nextHandler) {  
        this.nextHandler = nextHandler;  
    }  
   
    //这个是精髓：他除了处理自己的逻辑，还会调用nextHandler进行处理
    public void logMessage(int level, String message) {  
        if (this.level <= level) {  
            write(message);  
        }  
        if (nextHandler != null) {  
            nextHandler.logMessage(level, message);  
        }  
    }  
  
    abstract protected void write(String message);  
}  
  
// 具体处理者：ErrorLogHandler  
class ErrorLogHandler extends LogHandler {  
    public ErrorLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("ErrorLogHandler: " + message);  
    }  
}  
  
// 具体处理者：WarnLogHandler  
class WarnLogHandler extends LogHandler {  
    public WarnLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("WarnLogHandler: " + message);  
    }  
}  
  
// 具体处理者：InfoLogHandler  
class InfoLogHandler extends LogHandler {  
    public InfoLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("InfoLogHandler: " + message);  
    }  
}  
  
// 客户端代码  
public class ChainPatternDemo {  
    private static LogHandler getChainOfLoggers() {  
        // 创建链中的处理者  
        LogHandler errorLogHandler = new ErrorLogHandler(3);  
  
        LogHandler warnLogHandler = new WarnLogHandler(2);  
        warnLogHandler.setNextHandler(errorLogHandler);  
  
        LogHandler infoLogHandler = new InfoLogHandler(1);  
        infoLogHandler.setNextHandler(warnLogHandler);  
  
        return infoLogHandler;  
    }  
  
    public static void main(String[] args) {  
        LogHandler loggerChain = getChainOfLoggers();  
  
        loggerChain.logMessage(1, "This is an informational message.");  
        loggerChain.logMessage(2, "This is a warning message.");  
        loggerChain.logMessage(3, "This is an error message.");  
    }  
}

Dans cet exemple, nous définissons trois classes concrètes de gestionnaire de journaux (ErrorLogHandler、WarnLogHandler、InfoLogHandler ), ils gèrent respectivement différents niveaux de messages de journal. Chaque gestionnaire contient un niveau (level ), utilisé pour déterminer si les messages de ce niveau doivent être traités.En appelantlogMessageméthode, la requête est transmise au premier gestionnaire de la chaîne (infoLogHandler ), il décide s'il doit traiter le message en fonction de son propre niveau et de sa logique de traitement, puis (s'il n'est pas traité) transmet la demande au processeur suivant de la chaîne. Ce processus se poursuit jusqu'à la fin de la chaîne ou jusqu'à ce que la demande soit traitée.

Notez que dans une application réelle, vous devrez peut-êtreLogHandler La classe ajoute davantage de méthodes et de propriétés pour prendre en charge une logique et une configuration de traitement des journaux plus complexes. De plus, les niveaux de journalisation utilisent généralement des énumérations (enum) au lieu de nombres entiers pour améliorer la lisibilité et la maintenabilité du code.

7. Conclusion

Le modèle de chaîne de responsabilité permet un traitement flexible des demandes et une évolutivité du système en connectant plusieurs objets qui gèrent les demandes dans une chaîne et en permettant aux demandes de passer le long de la chaîne jusqu'à ce qu'un objet de la chaîne décide de traiter la demande.

Si le modèle de chaîne de responsabilité vous est utile, pensez à l'aimer et à le sauvegarder.