Technologieaustausch

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

Das Chain of Responsibility Pattern ist ein Verhaltensentwurfsmuster, das es mehreren Objekten ermöglicht, Anfragen nacheinander zu bearbeiten, und jedes Objekt kann wählen, ob es die Anfrage bearbeiten oder an das nächste Objekt weiterleiten möchte. Dieses Muster bietet eine größere Flexibilität und Skalierbarkeit durch die Entkopplung von Absender und Empfänger von Anfragen. Im Folgenden finden Sie eine detaillierte Einführung in das Chain-of-Responsibility-Modell:

1. Definition und Kernideen

Der Kern des Chain-of-Responsibility-Modells besteht darin, eine Anforderungskette zu entwerfen und das Ende der Kette zu identifizieren. Es verbindet mehrere Objekte zur Bearbeitung von Anfragen zu einer Kette und ermöglicht die Weiterleitung der Anfrage in der Kette, bis ein Objekt in der Kette beschließt, die Anfrage zu bearbeiten. Der Client, der die Anfrage stellt, weiß nicht, welches Objekt in der Kette die Anfrage letztendlich bearbeiten wird, was es dem System ermöglicht, sich dynamisch neu zu organisieren und Verantwortlichkeiten zuzuweisen, ohne dass dies Auswirkungen auf den Client hat.

2. Klassendiagramm und Hauptrollen

Klassen Diagramm:

Das Chain-of-Responsibility-Modell umfasst hauptsächlich die folgenden Rollen:

1. Abstrakter Handler (Handler) : Definieren Sie eine Schnittstelle zur Verarbeitung von Anfragen. Bei Bedarf kann die Schnittstelle eine Methode definieren, um einen Verweis auf die nächste Schnittstelle festzulegen und zurückzugeben. Diese Rolle wird normalerweise durch eine abstrakte Klasse oder Schnittstelle implementiert.

2. Betonhandler : Nach Erhalt der Anfrage kann der jeweilige Bearbeiter wählen, ob er die Anfrage bearbeiten oder an die nächste Partei weiterleiten möchte. Da der konkrete Prozessor einen Verweis auf das nächste Zuhause hält, kann der konkrete Prozessor bei Bedarf auf das nächste Zuhause zugreifen.

3. Client-Klasse (Client): Erstellen Sie eine Verarbeitungskette und senden Sie eine Anfrage an das spezifische Prozessorobjekt des Kettenkopfes.

3. Anwendbare Szenarien

Das Chain-of-Responsibility-Modell eignet sich für folgende Szenarien:

1. Mehrere Objekte bearbeiten gemeinsam eine Aufgabe: Beispielsweise leitet ein mehrstufiges Genehmigungssystem die Genehmigungsanfrage basierend auf der Autorität und Ebene des Genehmigers an die nächste Ebene des Genehmigers weiter, bis das endgültige Genehmigungsergebnis vorliegt.

2. Dynamischer Kombinationsverarbeitungsablauf: Durch die flexible Konfiguration der Verantwortungskette können Verarbeitungsobjekte dynamisch kombiniert werden, um unterschiedliche Verarbeitungsprozesse zu implementieren.

3. Vermeiden Sie eine direkte Kopplung zwischen Sender und Empfänger einer Anfrage: Durch die Übergabe der Anforderung an die Verantwortungskette muss der Absender der Anforderung das spezifische Verarbeitungsobjekt nicht kennen, wodurch die Abhängigkeit zwischen Objekten verringert wird.

4. Vor- und Nachteile

Vorteil

1. Kopplung reduzieren: Es entkoppelt den Absender und den Empfänger der Anfrage. Die Anfrage wird nur gesendet, unabhängig davon, wer sie bearbeitet.
2. Erhöhte Flexibilität bei der Objektzuweisung: Ermöglicht das dynamische Hinzufügen oder Löschen von Verantwortlichkeiten durch Ändern von Mitgliedern innerhalb der Kette oder Verschieben ihrer Reihenfolge.
3. Vereinfachen Sie Objekte: Das Objekt muss die Struktur der Kette nicht kennen.
4. Es ist praktisch, neue Anforderungsverarbeitungsklassen hinzuzufügen: Nach dem Öffnungs- und Schließprinzip können jederzeit neue Prozessoren zur Verantwortungskette hinzugefügt werden, ohne den vorhandenen Code zu ändern, was eine gute Skalierbarkeit gewährleistet.

Mangel

1. Es gibt keine Garantie dafür, dass die Anfrage angenommen wird: Wenn die Verantwortungskette nicht korrekt konfiguriert ist oder ein Bearbeiter die Anfrage nicht korrekt bearbeitet, wird die Anfrage möglicherweise nicht bearbeitet.
2. Performance-Probleme: Wenn die Verantwortungskette zu lang ist oder Anfragen in der Verantwortungskette häufig weitergegeben werden, kann die Leistung beeinträchtigt werden.
3. Das Debuggen ist unbequem: Wenn die Verantwortungskette besonders lang ist und viele Glieder hat, kann die Logik beim Debuggen aufgrund eines rekursiven Ansatzes komplizierter sein.

5. Anwendungsszenarien

Das Modell der Verantwortungskette wird in vielen Bereichen häufig verwendet, unter anderem in:

1. Protokollierungssystem: Protokollnachrichten entsprechend der Protokollebene an verschiedene Logger weiterleiten, z. B. Konsolen-Logger, Datei-Logger, Datenbank-Logger usw.
2. Ausnahmebehandlungssystem: Ausnahmen nach ihrem Typ klassifizieren, z. B. Protokollierung, E-Mail-Benachrichtigungen, Ausnahmeanzeige usw.
3. Mehrstufiges Genehmigungssystem: Zum Beispiel Urlaubsgenehmigung, Kaufgenehmigung usw., die Genehmigungsanfrage wird entsprechend der Autorität und Ebene des Genehmigers an den Genehmiger der nächsten Ebene weitergeleitet.

6. Implementierungsbeispiele

Im Folgenden finden Sie ein einfaches Implementierungsbeispiel für das Chain-of-Responsibility-Muster, das zum Verarbeiten von Protokollnachrichten und zum Weiterleiten der Nachrichten an verschiedene Prozessoren entsprechend der Protokollebene (z. B. DEBUG, INFO, WARN, ERROR) verwendet wird:

// 抽象处理者  
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.");  
    }  
}

In diesem Beispiel definieren wir drei konkrete Protokollhandlerklassen (ErrorLogHandler、WarnLogHandler、InfoLogHandler ), verarbeiten sie jeweils unterschiedliche Ebenen von Protokollmeldungen. Jeder Handler enthält eine Ebene (level ), wird verwendet, um zu bestimmen, ob Nachrichten dieser Ebene verarbeitet werden sollen.Per AnruflogMessage-Methode wird die Anfrage an den ersten Handler in der Kette übergeben (infoLogHandler ), entscheidet er auf der Grundlage seiner eigenen Ebene und Verarbeitungslogik, ob die Nachricht verarbeitet werden soll, und leitet die Anforderung dann (falls nicht verarbeitet) an den nächsten Prozessor in der Kette weiter. Dieser Vorgang wird bis zum Ende der Kette oder bis zur Bearbeitung der Anfrage fortgesetzt.

Beachten Sie, dass dies in einer realen Anwendung möglicherweise erforderlich istLogHandler Die Klasse fügt weitere Methoden und Eigenschaften hinzu, um komplexere Protokollverarbeitungslogik und -konfiguration zu unterstützen. Darüber hinaus verwenden Protokollebenen normalerweise Aufzählungen (enum) anstelle von Ganzzahlen, um die Lesbarkeit und Wartbarkeit des Codes zu verbessern.

7. Fazit

Das Chain-of-Responsibility-Muster ermöglicht eine flexible Verarbeitung von Anfragen und eine Skalierbarkeit des Systems, indem es mehrere Objekte, die Anfragen bearbeiten, zu einer Kette verbindet und die Weiterleitung der Anfrage in der Kette ermöglicht, bis ein Objekt in der Kette beschließt, die Anfrage zu bearbeiten.

Wenn das Modell der Verantwortungskette für Sie nützlich ist, denken Sie daran, es zu mögen und zu sammeln.