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 abc import ABC, abstractmethod
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

from dataclasses import dataclass

@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

class TeamLeader(Approver):
    """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

def main():
    # 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 dataclasses import dataclass
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

class Filter(ABC):
    """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

def process_http_request(request: HttpRequest) -> HttpResponse:
    """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

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):
        # 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

import logging

# 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

class DefaultHandler(Approver):
    """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

  1. 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.
  2. Anwendbare Szenarien: Mehrere Objekte können dieselbe Anfrage bearbeiten, aber welches Objekt sie bearbeitet, muss zur Laufzeit entschieden werden.
  3. Implementierungspunkte: Definieren Sie eine Handler-Schnittstelle, bauen Sie die Handler-Kette auf und übergeben Sie die Anfrage.
  4. Python-Features: Mithilfe der dynamischen Features von Python kann das Chain-of-Responsibility-Muster flexibler implementiert werden.
Weitere Erweiterungen