23 Entwurfsmuster Kapitel 19: Java Responsibility Chain Modell
Definition: Ermöglicht mehrere Objekte die Möglichkeit, die Anforderung zu verarbeiten, wodurch die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anfrage vermieden wird. Schließen Sie diese Objekte mit einer Kette an und geben Sie die Anforderung entlang der Kette über, bis ein Objekt sie verarbeitet.
Typ: Verhaltensmuster
Klassendiagramm:
Schauen wir uns zuerst einen Code an:
public void test (int i, request request) {if (i == 1) {Handler1.Response (Anfrage); } else if (i == 2) {Handler2.Response (Request); } else if (i == 3) {Handler3.Response (Anfrage); } else if (i == 4) {Handler4.Response (Anfrage); } else {Handler5.Response (Anfrage); }}Die Geschäftslogik des Codes lautet wie folgt: Die Methode enthält zwei Parameter: die Ganzzahl I und eine Anforderungsanforderung. Nach dem Wert von i, der die Anfrage bearbeitet, wird es von Handler1 behandelt, wenn i == 2 es von Handler2 und so weiter behandelt wird.
Bei der Programmierung ist diese Art der Geschäftsbearbeitungsmethode sehr häufig. Alle Klassen, die Prozessanfragen enthalten, wenn ... sonst ... bedingte Beurteilungsanweisungen in eine Verantwortungskette zur Verarbeitung der Anfrage verbunden sind. Ich glaube, jeder benutzt es oft. Die Vorteile dieser Methode sind, dass sie sehr intuitiv, einfach und klar und relativ einfach zu pflegen ist, aber diese Methode hat auch mehrere Kopfschmerzen:
Code aufgebläht: In den tatsächlichen Anwendungen sind die Urteilsbedingungen normalerweise nicht so einfach zu bestimmen, ob es sich um 1 oder 2. handelt. Möglicherweise erfordern sie komplexe Berechnungen, möglicherweise die Abfrage der Datenbank usw. Dies hat eine Menge zusätzlicher Code. Wenn es viele Urteilsbedingungen gibt, dann ist dies, wenn ... sonst ... eine Aussage im Grunde genommen nicht zu lesen ist.
Hoher Kupplungsabschluss: Wenn wir weiterhin Klassen hinzufügen möchten, die Prozessanfragen beantragen, müssen wir weiterhin anders hinzufügen, wenn die Beurteilungsbedingungen; Darüber hinaus wird die Reihenfolge dieser Bedingung auch an die Toten geschrieben. Wenn wir die Reihenfolge ändern möchten, können wir diese Bedingungsanweisung nur ändern.
Da wir die Mängel bereits verstanden haben, müssen wir einen Weg finden, sie zu lösen. Die Geschäftslogik dieses Szenarios ist sehr einfach: Wenn der Zustand 1 erfüllt ist, wird es von Handler1 verarbeitet und wenn er nicht erfüllt ist, wird sie weitergegeben. Wenn der Zustand 2 erfüllt ist, wird er von Handler2 verarbeitet, und wenn er nicht erfüllt ist, wird es bis zum Ende des Zustands weitergegeben. Tatsächlich ist die Verbesserungsmethode auch sehr einfach, nämlich den Teil der Urteilsbedingungen in die Verarbeitungsklasse einzubeziehen. Dies ist das Prinzip des Verantwortungsverbindungsmodells.
Die Struktur der Kette des Verantwortungskettenmodells
Das Klassendiagramm der Kette des Verantwortungsmusters ist sehr einfach, es besteht aus einer abstrakt verarbeiteten Klasse und ihrer Reihe von Implementierungsklassen:
Abstrakte Verarbeitungsklasse: Die abstrakte Verarbeitungsklasse enthält hauptsächlich eine Mitgliedsvariable NextHandler, die auf die nächste Verarbeitungsklasse hinweist, und eine Methode, die die Anforderung bearbeitet. Die Hauptidee der Handrequest -Methode ist, dass diese Verarbeitungsklasse, wenn die Verarbeitungsbedingungen erfüllt sind, verarbeitet wird, sonst wird sie von NextHandler verarbeitet.
Spezifische Verarbeitungsklasse: Spezifische Verarbeitungsklasse implementiert hauptsächlich die spezifische Verarbeitungslogik und die anwendbaren Bedingungen für die Verarbeitung.
Nach dem Verständnis der allgemeinen Vorstellung des Verantwortungskettenmodells ist es einfacher zu verstehen, wenn Sie sich den Code ansehen:
Klassenstufe {private int Level = 0; public Level (int Level) {this.level = Level; }; public boolean oben (Level Level) {if (this.level> = Level.level) {return true; } return false; }} Klasse Anfrage {Ebene; öffentliche Anfrage (Stufe) {this.level = Level; } public Level getlevel () {return Level; }} Klasse Antwort {} Abstract Class Handler {private Handler NextHandler; öffentliche endgültige Antworthandlrequest (Anfrageanforderung) {Antwort Antwort = NULL; if (this.getHandlerLevel (). oben (request.getlevel ()) {response = this.response (request); } else {if (this.NexHandler! } else {System.out.println ("----------"); }} Rückgabeantwort; } public void setNeTandhandler (Handler -Handler) {this.NexHandler = Handler; } geschützter abstrakter Ebene GetHandlerLevel (); öffentliche abstrakte Antwort Antwort (Anfrageanforderung); } class ConcreteHandler1 erweitert Handler {Protected Level GetHandlerLevel () {neue Ebene zurückgeben (1); } öffentliche Antwort Antwort (Anfrageanforderung) { System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ class ConcreteHandler2 erweitert Handler {Protected Level GetHandLevel () {Neue Ebene zurückgeben (3); System.out.println ("------ Anfragen werden von Prozessor 3 -----"); Handler1.SetNextHandler (Handler2);Im Code simuliert die Ebene der Ebene die Bestimmungsbedingungen; Anfrage und Antwort entsprechen Anforderungen bzw. Antworten; Der abstrakte Klassenhandler beurteilt hauptsächlich die Bedingungen, und hier wird eine Verarbeitungsstufe simuliert. Nur die Verarbeitungsstufe der Verarbeitungsklasse ist höher als die Niveau der Anfrage kann verarbeitet werden, da sie ansonsten an den nächsten Prozessor zur Verarbeitung übergeben wird.
Stellen Sie die Vorder- und Rückausführungsbeziehung der Kette in der Client -Klasse ein und geben Sie die Anfrage während der Ausführung an die erste Verarbeitungsklasse. Dies ist das Verantwortungskettenmuster. Die Funktion, die sie ausführt, ist die gleiche wie die Anweisung if ... sonst ... im vorherigen Artikel.
Vor- und Nachteile des Verantwortungskettenmodells
Im Vergleich zu wenn… sonst… das Verantwortungskettenmuster hat eine geringere Kopplungsfähigkeit, da es die bedingten Urteile in verschiedene Verarbeitungsklassen verteilt und die vorrangige Verarbeitungsreihenfolge dieser Verarbeitungsklassen nach Belieben festgelegt werden kann. Das Verantwortungskettenmodell hat auch seine Nachteile, was dem if ... sonst ... Anweisung entspricht, dh, bevor die korrekte Verarbeitungsklasse gefunden wird, müssen alle Urteilsbedingungen ausgeführt werden. Wenn die Verantwortungskette relativ lang ist, ist das Leistungsproblem schwerwiegender.
Anwendbare Szenarien für die Kette des Verantwortungskettenmodells
Genau wie beim Anfangsbeispiel, wenn Sie sich überfordert fühlen, wenn Sie die Anweisung if… sonst… anwesend… eine Verantwortungskette organisieren, können Sie die Kette des Verantwortungsmodus verwenden, um sie neu zu überarbeiten.
Zusammenfassen
Das Verantwortungskettenmodell ist eigentlich eine flexible Version von if ... sonst ... Anweisung. Es steckt diese Urteilsbedingungen in jede Verarbeitungsklasse. Der Vorteil davon ist, dass es flexibler ist, aber auch Risiken bringt. Wenn Sie beispielsweise die Beziehung zwischen der Verarbeitungsklasse vor und nach der Verarbeitungsklasse aufbauen, müssen Sie sehr vorsichtig sein, um die Beziehung zwischen der bedingten Logik vor und nach der Verarbeitungsklasse zu beurteilen und darauf zu achten, keine kreisförmigen Referenzen in der Kette zu haben.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.