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 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
@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
"""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
# 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 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
"""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
"""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
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
# 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
"""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
- 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.
- 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.
- Points de mise en œuvre: Définir une interface de gestionnaire, construire la chaîne de gestionnaires et transmettre la requête.
- 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.