Patron de chaîne de responsabilité Python

Le patron Chaîne de responsabilité est un patron de conception comportemental qui vous permet de transmettre des requêtes le long d'une chaîne de gestionnaires. À la réception d'une requête, chaque gestionnaire peut soit traiter la requête, soit la transmettre au gestionnaire suivant dans la chaîne.

Analogie de la vie réelle

Imaginez le processus d'approbation des congés dans une entreprise :

  • 1-3 jours→ Le chef d'équipe approuve
  • 4-7 jours→ Le responsable de département approuve
  • Plus de 8 jours→ Le directeur général approuve

Lorsque vous soumettez une demande de congé, elle est transmise le long de cette chaîne dans l'ordre jusqu'à ce qu'elle trouve une personne autorisée à la traiter. C'est une manifestation concrète du modèle de Chaîne de responsabilité.

Idée centrale du modèle

Le cœur du modèle de Chaîne de responsabilité estle découplage de l'émetteur et du récepteur d'une requête, permettant à plusieurs objets d'avoir l'opportunité de traiter la requête, évitant ainsi un couplage fort entre l'émetteur et le récepteur.


Structure du modèle de Chaîne de responsabilité

Comprenons la composition du modèle de Chaîne de responsabilité à travers un diagramme de classes UML :

Description des composants principaux

Handler (Gestionnaire abstrait)

  • Définit l'interface de traitement des requêtes
  • Contient une méthode pour définir le successeur
  • Peut implémenter le comportement par défaut pour la chaîne de successeurs

ConcreteHandler (gestionnaire concret)

  • Implémente une logique de traitement spécifique
  • Traite la requête s'il peut la traiter
  • Sinon, transmet la requête au successeur

Implémentation de base : système d'approbation de congés

Implémentons un système simple d'approbation de congés en Python pour comprendre le patron Chaîne de responsabilité.

Étape 1 : Définir le gestionnaire abstrait

Exemple

from abc import ABC, abstractmethod
from typing import Optional

class Approver(ABC):
    """Classe abstraite Approver"""
   
    def __init__(self, name: str):
        self.name = name
        self.successor: Optional['Approver'] = None
   
    def set_successor(self, successor: 'Approver'):
        """Définir l'approbateur successeur"""
        self.successor = successor
   
    @abstractmethod
    def process_request(self, leave_request: 'LeaveRequest'):
        """Méthode abstraite pour gérer les demandes de congé"""
        pass

Étape 2 : Définir l'objet de requête

Exemple

from dataclasses import dataclass

@dataclass
class LeaveRequest:
    """Classe de données de demande de congé"""
    employee_name: str    # Nom de l'employé
    leave_days: int       # Jours de congé
    reason: str           # Motif de congé
   
    def __str__(self):
        return f"{self.employee_name} demande un congé de {self.leave_days} jours, motif : {self.reason}"

Étape 3 : Implémenter les gestionnaires concrets

Exemple

class TeamLeader(Approver):
    """Chef d'équipe - gère les congés de 1-3 jours"""
   
    def process_request(self, leave_request: LeaveRequest):
        if leave_request.leave_days <= 3:
            print(f"Chef d'équipe {self.name} a approuvé {leave_request}")
        elif self.successor is not None:
            # Dépasse l'autorité, passer au niveau suivant
            print(f"Chef d'équipe {self.name} n'a pas l'autorité, transfert vers un niveau supérieur")
            self.successor.process_request(leave_request)
        else:
            print("Impossible de traiter la demande : aucun approbateur approprié")

class DepartmentManager(Approver):
    """Responsable de département - gère les congés de 4-7 jours"""
   
    def process_request(self, leave_request: LeaveRequest):
        if 4 <= leave_request.leave_days <= 7:
            print(f"Le chef de département {self.name} a approuvé {leave_request}")
        elif self.successor is not None:
            # Dépasse l'autorité, passer au niveau suivant
            print(f"Le chef de département {self.name} n'a pas l'autorité, transfert au niveau supérieur")
            self.successor.process_request(leave_request)
        else:
            print("Impossible de traiter la demande : aucun approbateur approprié")

class GeneralManager(Approver):
    """Directeur général - gère les congés de plus de 8 jours"""
   
    def process_request(self, leave_request: LeaveRequest):
        if leave_request.leave_days >= 8:
            print(f"Le directeur général {self.name} a approuvé {leave_request}")
        else:
            print("Impossible de traiter la demande : le nombre de jours de congé ne répond pas aux exigences")

Étape 4 : Construire la chaîne et tester

Exemple

def main():
    # Créer les approbateurs
    team_leader = TeamLeader("Zhang San")
    dept_manager = DepartmentManager("Li Si")
    general_manager = GeneralManager("Wang Wu")
   
    # Construire la chaîne : Chef d'équipe → Chef de département → Directeur général
    team_leader.set_successor(dept_manager)
    dept_manager.set_successor(general_manager)
   
    # Créer des cas de test
    test_cases = [
        LeaveRequest("Xiao Ming", 2, "Rhume et fièvre"),
        LeaveRequest("Xiao Hong", 5, "Rentrer à la maison pour rendre visite à sa famille"),
        LeaveRequest("Xiao Gang", 10, "Congé de mariage"),
        LeaveRequest("Xiao Li", 15, "Voyage à l'étranger")
    ]
   
    print("=== Test d'approbation des congés ==="\n")
   
    # Traiter toutes les demandes de congé
    for request in test_cases:
        print(f"Traitement de la demande : {request.employee_name} demande {request.leave_days} jours de congé")
        team_leader.process_request(request)
        print("-" * 50)

if __name__ == "__main__":
    main()

Sortie

=== 请假审批测试 ===

处理请求: 小明 请假 2 天
组长 张三 批准了 小明 申请请假 2 天,原因:感冒发烧
--------------------------------------------------
处理请求: 小红 请假 5 天
组长 张三 无权限,转交给上级处理
部门经理 李四 批准了 小红 申请请假 5 天,原因:回家探亲
--------------------------------------------------
处理请求: 小刚 请假 10 天
组长 张三 无权限,转交给上级处理
部门经理 李四 无权限,转交给上级处理
总经理 王五 批准了 小刚 申请请假 10 天,原因:结婚休假
--------------------------------------------------
处理请求: 小李 请假 15 天
组长 张三 无权限,转交给上级处理
部门经理 李四 无权限,转交给上级处理
总经理 王五 批准了 小李 申请请假 15 天,原因:出国旅游
--------------------------------------------------

Application avancée : Filtre de requête Web

Le patron de conception Chaîne de responsabilité est très courant dans le développement Web, en particulier dans les middlewares et les chaînes de filtres. Implémentons une simple chaîne de filtres de requêtes HTTP.

Étape 1 : Définir les objets Requête et Réponse

Exemple

from dataclasses import dataclass
from typing import Dict, Any

@dataclass
class HttpRequest:
    """Objet de requête HTTP"""
    method: str
    path: str
    headers: Dict[str, str]
    body: Any = None
    user: Dict[str, Any] = None

@dataclass  
class HttpResponse:
    """Objet de réponse HTTP"""
    status_code: int
    headers: Dict[str, str]
    body: Any = None

Étape 2 : implémenter la chaîne de filtres

Exemple

class Filter(ABC):
    """Classe abstraite Filter"""
   
    def __init__(self):
        self.next_filter: Optional['Filter'] = None
   
    def set_next(self, next_filter: 'Filter'):
        """Définir le filtre suivant"""
        self.next_filter = next_filter
   
    def do_filter(self, request: HttpRequest, response: HttpResponse) -> bool:
        """
Effectuer l'opération de filtrage
Retourner True pour continuer, False pour interrompre
        """

        if self.handle(request, response):
            if self.next_filter is not None:
                return self.next_filter.do_filter(request, response)
            return True
        return False
   
    @abstractmethod
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        """Logique de filtrage concrète"""
        pass

class AuthenticationFilter(Filter):
    """Filtre d'authentification"""
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print("Authentification en cours...")
       
        # Simuler la logique d'authentification
        token = request.headers.get('Authorization')
        if token == "Bearer valid-token":
            request.user = {"id": 1, "name": "Zhang San", "role": "user"}
            print("✓ Authentification réussie")
            return True
        else:
            response.status_code = 401
            response.body = {"error": "Accès non autorisé"}
            print("✗ Échec de l'authentification")
            return False

class LoggingFilter(Filter):
    """Filtre de journalisation"""
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print(f"Journalisation de la requête : {request.method} {request.path}")
        return True  # Toujours continuer

class PermissionFilter(Filter):
    """Filtre de vérification des permissions"""
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print("Vérification des permissions de l'utilisateur...")
       
        if request.user and request.user.get('role') == 'admin':
            print("✓ Vérification des permissions réussie")
            return True
        else:
            response.status_code = 403
            response.body = {"error": "Permissions insuffisantes"}
            print("✗ Échec de la vérification des permissions")
            return False

Étape 3 : Utiliser la chaîne de filtres pour gérer les requêtes

Exemple

def process_http_request(request: HttpRequest) -> HttpResponse:
    """Gérer la requête HTTP"""
   
    # Créer une réponse par défaut
    response = HttpResponse(
        status_code=200,
        headers={"Content-Type": "application/json"},
        body={"message": "Requête réussie"}
    )
   
    # Créer une chaîne de filtres
    auth_filter = AuthenticationFilter()
    logging_filter = LoggingFilter()
    permission_filter = PermissionFilter()
   
    # Construire la chaîne de filtres : Journalisation → Authentification → Autorisation
    logging_filter.set_next(auth_filter)
    auth_filter.set_next(permission_filter)
   
    # Exécuter la chaîne de filtres
    print("Démarrage du traitement de la requête HTTP...")
    logging_filter.do_filter(request, response)
    print("Traitement de la requête terminé")
   
    return response

# Tester différents scénarios de requête
def test_filter_chain():
    print("=== Test de la chaîne de filtres HTTP ==="\n")
   
    # Cas de test 1 : requête admin valide
    print("Cas de test 1 : requête admin valide")
    request1 = HttpRequest(
        method="GET",
        path="/admin/data",
        headers={"Authorization": "Bearer valid-token"}
    )
    response1 = process_http_request(request1)
    print(f"Code de statut de la réponse : {response1.status_code}")
    print(f"Corps de la réponse : {response1.body}"\n")
   
    # Cas de test 2 : requête non autorisée
    print("Cas de test 2 : requête non autorisée")
    request2 = HttpRequest(
        method="GET",
        path="/admin/data",
        headers={"Authorization": "Bearer invalid-token"}
    )
    response2 = process_http_request(request2)
    print(f"Code d'état de la réponse : {response2.status_code}")
    print(f"Corps de la réponse : {response2.body}"\n")

if __name__ == "__main__":
    test_filter_chain()

Avantages et inconvénients du patron de conception Chaîne de responsabilité

Avantages

Inconvénients

L'émetteur de la requête n'a pas besoin de savoir quel objet traitera sa requête, et le récepteur n'a pas besoin de connaître l'image complète de la requête.

2. Flexibilité accrue

Les gestionnaires peuvent être ajoutés, supprimés ou réordonnés dynamiquement sans affecter le code client.

3. Responsabilités des objets simplifiées

Chaque gestionnaire n'a besoin de se concentrer que sur les requêtes relevant de son propre périmètre de responsabilité, en respectant le principe de responsabilité unique.

4. Facile à étendre

Ajouter un nouveau gestionnaire est très facile ; il vous suffit d'implémenter l'interface de gestionnaire et de l'ajouter à la chaîne.

Inconvénients

1. Les requêtes peuvent rester non traitées

Si la chaîne de responsabilité n'est pas correctement configurée, une requête peut atteindre la fin de la chaîne sans être traitée par aucun gestionnaire.

2. Considérations sur les performances

Une chaîne de responsabilité plus longue peut affecter les performances, en particulier lors du traitement d'un grand nombre de requêtes.

3. Débogage difficile

Le chemin de traitement d'une requête peut être peu clair, ce qui rend difficile de tracer le flux de traitement complet lors du débogage.


Scénarios d'application concrets

1. Système de gestion d'événements

Le mécanisme de propagation d'événements dans les interfaces graphiques est une application typique du patron Chaîne de responsabilité.

Exemple

class Event:
    def __init__(self, name, target):
        self.name = name
        self.target = target
        self.handled = False

class Widget:
    def __init__(self, parent=None):
        self.parent = parent
   
    def handle_event(self, event):
        # Traitez-le d'abord vous-même ; s'il ne peut pas être traité, transmettez-le au composant parent
        if self.on_event(event):
            event.handled = True
        elif self.parent:
            self.parent.handle_event(event)
   
    def on_event(self, event):
        # Les sous-classes redéfinissent cette méthode pour implémenter une gestion spécifique des événements
        return False

2. Système de journalisation

Les messages de journalisation de différents niveaux sont traités par différents gestionnaires.

Exemple

import logging

# Créer un journaliseur
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)

# Créer une chaîne de gestionnaires
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')

# Définir les niveaux des gestionnaires
console_handler.setLevel(logging.WARNING)
file_handler.setLevel(logging.DEBUG)

# Ajouter au journaliseur
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Utilisation : les niveaux DEBUG et INFO seront uniquement journalisés dans un fichier ; WARNING et au-dessus seront également affichés dans la console.
logger.debug('Info de débogage')      # Uniquement journalisé dans un fichier
logger.warning('Message d'avertissement')    # Sortie à la fois vers la console et le fichier

Bonnes pratiques et considérations

1. Définir le comportement de traitement par défaut

Assurez-vous qu'il existe un gestionnaire par défaut à la fin de la chaîne de responsabilité pour éviter les requêtes perdues.

Exemple

class DefaultHandler(Approver):
    """Gestionnaire par défaut - prend en charge toutes les requêtes non traitées"""
   
    def process_request(self, leave_request: LeaveRequest):
        print(f"Gestionnaire par défaut : impossible de traiter {leave_request}, veuillez vérifier les paramètres de la requête")

2. Contrôler la longueur de la chaîne

Évitez de créer une chaîne de responsabilité trop longue, car cela réduit les performances et augmente la difficulté de débogage.

3. Règles de traitement claires

Assurez-vous que chaque gestionnaire a un périmètre de traitement clair afin d’éviter le chevauchement des responsabilités.

4. Envisagez d’utiliser le patron Composite

Pour les chaînes de responsabilité complexes, envisagez d’utiliser le patron Composite pour gérer les relations entre les gestionnaires.


Résumé

Le patron de conception Chaîne de responsabilité est un patron puissant et flexible. En découplant l’émetteur et le destinataire d’une requête, il offre une manière élégante de gérer les scénarios dans lesquels plusieurs objets doivent collaborer.

Points clés

  1. Idée centrale: Donner à plusieurs objets la possibilité de traiter la requête, en évitant le couplage entre l’émetteur et le destinataire de la requête.
  2. Scénarios applicables: Plusieurs objets peuvent traiter la même requête, mais l’objet qui la traite doit être déterminé à l’exécution.
  3. Points de mise en œuvre: Définir une interface de gestionnaire, construire la chaîne de gestionnaires et transmettre la requête.
  4. Fonctionnalités Python: En utilisant les fonctionnalités dynamiques de Python, le patron Chaîne de responsabilité peut être implémenté de manière plus flexible.
Autres extensions