Python-Zuständigkeitskettenmuster
Das Chain-of-Responsibility-Muster ist ein Verhaltens-Entwurfsmuster, das es ermöglicht, Anfragen entlang einer Kette von Handlern weiterzugeben. Beim Empfang einer Anfrage kann jeder Handler die Anfrage entweder verarbeiten oder sie an den nächsten Handler in der Kette weitergeben.
Analogie aus dem echten Leben
Stell dir den Urlaubsgenehmigungsprozess in einem Unternehmen vor:
- 1-3 Tage→ Teamleiter genehmigt
- 4-7 Tage→ Abteilungsleiter genehmigt
- Mehr als 8 Tage→ Geschäftsführer genehmigt
Wenn Sie einen Urlaubsantrag einreichen, wird er diese Kette der Reihe nach entlanggereicht, bis eine Person gefunden wird, die berechtigt ist, ihn zu bearbeiten. Dies ist eine reale Ausprägung des Chain-of-Responsibility-Musters.
Kernidee des Musters
Der Kern des Chain-of-Responsibility-Musters istdie Entkopplung von Sender und Empfänger einer Anfrage, wodurch mehrere Objekte die Möglichkeit erhalten, die Anfrage zu bearbeiten, und so eine enge Kopplung zwischen Sender und Empfänger vermieden wird.
Struktur des Chain-of-Responsibility-Musters
Lassen Sie uns den Aufbau des Chain-of-Responsibility-Musters anhand eines UML-Klassendiagramms verstehen:

Beschreibung der Kernkomponenten
Handler (Abstrakter Handler)
- Definiert die Schnittstelle zur Bearbeitung von Anfragen
- Enthält eine Methode zum Festlegen des Nachfolgers
- Kann Standardverhalten für die Nachfolgerkette implementieren
ConcreteHandler (Konkreter Handler)
- Implementiert spezifische Verarbeitungslogik
- Verarbeitet die Anfrage, wenn er sie verarbeiten kann
- Andernfalls leitet er die Anfrage an den Nachfolger weiter
Grundlegende Implementierung: Urlaubsgenehmigungssystem
Lassen Sie uns ein einfaches Urlaubsgenehmigungssystem in Python implementieren, um das Chain-of-Responsibility-Muster zu verstehen.
Schritt 1: Den abstrakten Handler definieren
Beispiel
from typing import Optional
class Approver(ABC):
"""Abstrakte Klasse Approver"""
def __init__(self, name: str):
self.name = name
self.successor: Optional['Approver'] = None
def set_successor(self, successor: 'Approver'):
"""Nachfolgenden Genehmiger festlegen"""
self.successor = successor
@abstractmethod
def process_request(self, leave_request: 'LeaveRequest'):
"""Abstrakte Methode zur Bearbeitung von Urlaubsanträgen"""
pass
Schritt 2: Das Antragsobjekt definieren
Beispiel
@dataclass
class LeaveRequest:
"""Datenklasse für Urlaubsanträge"""
employee_name: str # Name des Mitarbeiters
leave_days: int # Urlaubstage
reason: str # Urlaubsgrund
def __str__(self):
return f"{self.employee_name} beantragt Urlaub für {self.leave_days} Tage, Grund: {self.reason}"
Schritt 3: Konkrete Handler implementieren
Beispiel
"""Teamleiter - bearbeitet Urlaub von 1-3 Tagen"""
def process_request(self, leave_request: LeaveRequest):
if leave_request.leave_days <= 3:
print(f"Teamleiter {self.name} hat {leave_request} genehmigt")
elif self.successor is not None:
# Überschreitet die Befugnis, an die nächste Ebene weiterleiten
print(f"Teamleiter {self.name} hat keine Befugnis, wird an eine höhere Ebene weitergeleitet")
self.successor.process_request(leave_request)
else:
print("Anfrage kann nicht bearbeitet werden: kein geeigneter Genehmiger")
class DepartmentManager(Approver):
"""Abteilungsleiter - bearbeitet Urlaub von 4-7 Tagen"""
def process_request(self, leave_request: LeaveRequest):
if 4 <= leave_request.leave_days <= 7:
print(f"Abteilungsleiter {self.name} hat {leave_request} genehmigt")
elif self.successor is not None:
# Überschreitet die Befugnis, an die nächste Ebene weiterleiten
print(f"Abteilungsleiter {self.name} hat keine Befugnis, wird an eine höhere Ebene weitergeleitet")
self.successor.process_request(leave_request)
else:
print("Anfrage kann nicht bearbeitet werden: kein geeigneter Genehmiger")
class GeneralManager(Approver):
"""Generaldirektor - bearbeitet Urlaub von mehr als 8 Tagen"""
def process_request(self, leave_request: LeaveRequest):
if leave_request.leave_days >= 8:
print(f"Generaldirektor {self.name} hat {leave_request} genehmigt")
else:
print("Anfrage kann nicht bearbeitet werden: Die Anzahl der Urlaubstage entspricht nicht den Anforderungen")
Schritt 4: Kette aufbauen und testen
Beispiel
# Genehmiger erstellen
team_leader = TeamLeader("Zhang San")
dept_manager = DepartmentManager("Li Si")
general_manager = GeneralManager("Wang Wu")
# Kette aufbauen: Teamleiter → Abteilungsleiter → Generaldirektor
team_leader.set_successor(dept_manager)
dept_manager.set_successor(general_manager)
# Testfälle erstellen
test_cases = [
LeaveRequest("Xiao Ming", 2, "Erkältung und Fieber"),
LeaveRequest("Xiao Hong", 5, "Nach Hause fahren, um die Familie zu besuchen"),
LeaveRequest("Xiao Gang", 10, "Heiratsurlaub"),
LeaveRequest("Xiao Li", 15, "Auslandsreise")
]
print("=== Test der Urlaubsgenehmigung ==="\n")
# Alle Urlaubsanträge verarbeiten
for request in test_cases:
print(f"Verarbeite Anfrage: {request.employee_name} beantragt {request.leave_days} Tage Urlaub")
team_leader.process_request(request)
print("-" * 50)
if __name__ == "__main__":
main()
Ausgabe
=== 请假审批测试 === 处理请求: 小明 请假 2 天 组长 张三 批准了 小明 申请请假 2 天,原因:感冒发烧 -------------------------------------------------- 处理请求: 小红 请假 5 天 组长 张三 无权限,转交给上级处理 部门经理 李四 批准了 小红 申请请假 5 天,原因:回家探亲 -------------------------------------------------- 处理请求: 小刚 请假 10 天 组长 张三 无权限,转交给上级处理 部门经理 李四 无权限,转交给上级处理 总经理 王五 批准了 小刚 申请请假 10 天,原因:结婚休假 -------------------------------------------------- 处理请求: 小李 请假 15 天 组长 张三 无权限,转交给上级处理 部门经理 李四 无权限,转交给上级处理 总经理 王五 批准了 小李 申请请假 15 天,原因:出国旅游 --------------------------------------------------
Fortgeschrittene Anwendung: Web-Anfragefilter
Das Chain-of-Responsibility-Muster ist in der Webentwicklung sehr verbreitet, insbesondere in Middleware- und Filterketten. Lass uns eine einfache HTTP-Anfragefilterkette implementieren.
Schritt 1: Anfrage- und Antwortobjekte definieren
Beispiel
from typing import Dict, Any
@dataclass
class HttpRequest:
"""HTTP-Anfrageobjekt"""
method: str
path: str
headers: Dict[str, str]
body: Any = None
user: Dict[str, Any] = None
@dataclass
class HttpResponse:
"""HTTP-Antwortobjekt"""
status_code: int
headers: Dict[str, str]
body: Any = None
Schritt 2: Filterkette implementieren
Beispiel
"""Abstrakte Filterklasse"""
def __init__(self):
self.next_filter: Optional['Filter'] = None
def set_next(self, next_filter: 'Filter'):
"""Nächsten Filter setzen"""
self.next_filter = next_filter
def do_filter(self, request: HttpRequest, response: HttpResponse) -> bool:
"""
Filtervorgang ausführen
True zurückgeben, um fortzufahren, False, um abzubrechen
"""
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:
"""Konkrete Filterlogik"""
pass
class AuthenticationFilter(Filter):
"""Authentifizierungsfilter"""
def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
print("Authentifizierung wird durchgeführt...")
# Authentifizierungslogik simulieren
token = request.headers.get('Authorization')
if token == "Bearer valid-token":
request.user = {"id": 1, "name": "Zhang San", "role": "user"}
print("✓ Authentifizierung erfolgreich")
return True
else:
response.status_code = 401
response.body = {"error": "Unbefugter Zugriff"}
print("✗ Authentifizierung fehlgeschlagen")
return False
class LoggingFilter(Filter):
"""Protokollierungsfilter"""
def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
print(f"Protokolliere Anfrage: {request.method} {request.path}")
return True # Immer fortfahren
class PermissionFilter(Filter):
"""Filter zur Berechtigungsprüfung"""
def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
print("Überprüfe Benutzerberechtigungen...")
if request.user and request.user.get('role') == 'admin':
print("✓ Berechtigungsprüfung bestanden")
return True
else:
response.status_code = 403
response.body = {"error": "Unzureichende Berechtigungen"}
print("✗ Berechtigungsprüfung fehlgeschlagen")
return False
Schritt 3: Verwenden Sie die Filterkette, um Anfragen zu verarbeiten
Beispiel
"""HTTP-Anfrage verarbeiten"""
# Standardantwort erstellen
response = HttpResponse(
status_code=200,
headers={"Content-Type": "application/json"},
body={"message": "Anfrage erfolgreich"}
)
# Filterkette erstellen
auth_filter = AuthenticationFilter()
logging_filter = LoggingFilter()
permission_filter = PermissionFilter()
# Filterkette aufbauen: Logging → Authentifizierung → Berechtigung
logging_filter.set_next(auth_filter)
auth_filter.set_next(permission_filter)
# Filterkette ausführen
print("Starte Verarbeitung der HTTP-Anfrage...")
logging_filter.do_filter(request, response)
print("Anfrageverarbeitung abgeschlossen")
return response
# Verschiedene Anfrageszenarien testen
def test_filter_chain():
print("=== HTTP-Filterkette-Test ==="\n")
# Testfall 1: Gültige Admin-Anfrage
print("Testfall 1: Gültige Admin-Anfrage")
request1 = HttpRequest(
method="GET",
path="/admin/data",
headers={"Authorization": "Bearer valid-token"}
)
response1 = process_http_request(request1)
print(f"Antwort-Statuscode: {response1.status_code}")
print(f"Antwort-Body: {response1.body}"\n")
# Testfall 2: Nicht autorisierte Anfrage
print("Testfall 2: Nicht autorisierte Anfrage")
request2 = HttpRequest(
method="GET",
path="/admin/data",
headers={"Authorization": "Bearer invalid-token"}
)
response2 = process_http_request(request2)
print(f"Antwort-Statuscode: {response2.status_code}")
print(f"Antwortkörper: {response2.body}"\n")
if __name__ == "__main__":
test_filter_chain()
Vor- und Nachteile des Chain-of-Responsibility-Musters
Vorteile
Nachteile
Der Absender der Anfrage muss nicht wissen, welches Objekt seine Anfrage bearbeiten wird, und der Empfänger muss nicht das Gesamtbild der Anfrage kennen.
2. Verbesserte Flexibilität
Handler können dynamisch hinzugefügt, entfernt oder neu angeordnet werden, ohne den Client-Code zu beeinflussen.
3. Vereinfachte Objektverantwortlichkeiten
Jeder Handler muss sich nur auf Anfragen innerhalb seines eigenen Verantwortungsbereichs konzentrieren und dabei das Single-Responsibility-Prinzip einhalten.
4. Einfach zu erweitern
Das Hinzufügen eines neuen Handlers ist sehr einfach; man muss nur die Handler-Schnittstelle implementieren und ihn der Kette hinzufügen.
Nachteile
1. Anfragen bleiben möglicherweise unbehandelt
Wenn die Verantwortungskette nicht ordnungsgemäß konfiguriert ist, kann eine Anfrage das Ende der Kette erreichen, ohne von einem Handler behandelt zu werden.
2. Performance-Überlegungen
Eine längere Verantwortungskette kann die Leistung beeinträchtigen, insbesondere bei der Verarbeitung einer großen Anzahl von Anfragen.
3. Schwieriges Debugging
Der Verarbeitungspfad einer Anfrage kann unklar sein, was es schwierig macht, den vollständigen Verarbeitungsablauf während des Debuggings nachzuvollziehen.
Anwendungsszenarien aus der Praxis
1. Ereignisbehandlungssystem
Der Event-Bubbling-Mechanismus in grafischen Oberflächen ist eine typische Anwendung des Verantwortungskettenmusters.
Beispiel
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):
# Zuerst selbst behandeln; wenn es nicht behandelt werden kann, an die übergeordnete Komponente weitergeben
if self.on_event(event):
event.handled = True
elif self.parent:
self.parent.handle_event(event)
def on_event(self, event):
# Unterklassen überschreiben diese Methode, um eine spezifische Ereignisbehandlung zu implementieren
return False
2. Protokollierungssystem
Log-Meldungen unterschiedlicher Stufen werden von unterschiedlichen Handlern verarbeitet.
Beispiel
# Einen Logger erstellen
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)
# Eine Handler-Kette erstellen
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')
# Handler-Level festlegen
console_handler.setLevel(logging.WARNING)
file_handler.setLevel(logging.DEBUG)
# Zum Logger hinzufügen
logger.addHandler(console_handler)
logger.addHandler(file_handler)
# Verwendung: DEBUG- und INFO-Level werden nur in eine Datei protokolliert; WARNING und höher werden zusätzlich auf der Konsole ausgegeben.
logger.debug('Debug info') # Wird nur in die Datei protokolliert
logger.warning('Warning message') # Wird sowohl auf der Konsole als auch in die Datei ausgegeben
Best Practices und Überlegungen
1. Standardverhalten für die Behandlung festlegen
Stellen Sie sicher, dass sich am Ende der Verantwortlichkeitskette ein Standard-Handler befindet, um verlorene Anfragen zu vermeiden.
Beispiel
"""Standard-Handler - verarbeitet alle nicht behandelten Anfragen"""
def process_request(self, leave_request: LeaveRequest):
print(f"Standard-Handler: kann {leave_request} nicht verarbeiten, bitte überprüfen Sie die Anfrageparameter")
2. Länge der Kette steuern
Vermeiden Sie das Erstellen einer übermäßig langen Verantwortlichkeitskette, da dies die Leistung verringert und die Fehlersuche erschwert.
3. Klare Verarbeitungsregeln
Stellen Sie sicher, dass jeder Handler eine klare Verarbeitungsgrenze hat, um Überschneidungen bei den Zuständigkeiten zu vermeiden.
4. Erwägen Sie die Verwendung des Composite-Musters
Erwägen Sie bei komplexen Verantwortlichkeitsketten die Verwendung des Composite-Musters, um die Beziehungen zwischen den Handlern zu verwalten.
Zusammenfassung
Das Chain-of-Responsibility-Muster ist ein leistungsstarkes und flexibles Entwurfsmuster. Durch die Entkopplung von Sender und Empfänger einer Anfrage bietet es eine elegante Möglichkeit, Szenarien zu behandeln, in denen mehrere Objekte zusammenarbeiten müssen.
Kernpunkte
- Kernidee: Geben Sie mehreren Objekten die Möglichkeit, die Anfrage zu bearbeiten, und vermeiden Sie die Kopplung zwischen dem Sender und dem Empfänger der Anfrage.
- Anwendbare Szenarien: Mehrere Objekte können dieselbe Anfrage bearbeiten, aber welches Objekt sie bearbeitet, muss zur Laufzeit entschieden werden.
- Implementierungspunkte: Definieren Sie eine Handler-Schnittstelle, bauen Sie die Handler-Kette auf und übergeben Sie die Anfrage.
- Python-Features: Mithilfe der dynamischen Features von Python kann das Chain-of-Responsibility-Muster flexibler implementiert werden.