Beispiele zur Erläuterung der Anwendung des Chain-of-Responsibility-Musters in der Java-Entwurfsmusterprogrammierung

Definition: Ermöglichen Sie mehreren Objekten die Möglichkeit, Anforderungen zu verarbeiten, und vermeiden Sie so die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anforderung. Diese Objekte werden zu einer Kette verbunden und die Anforderung wird entlang der Kette weitergeleitet, bis sie von einem Objekt verarbeitet wird.
Typ: Verhaltensklassenmuster
Klassendiagramm:

Erster Blick auf einen Codeabschnitt:

public void test(int i, Request request){
  if(i==1){
    Handler1.response(request);
  }else if(i == 2){
    Handler2.response(request);
  }else if(i == 3){
    Handler3.response(request);
  }else if(i == 4){
    Handler4.response(request);
  }else{
    Handler5.response(request);
  }
}

Die Geschäftslogik des Codes ist wie folgt: eine Ganzzahl i und eine Anfrage. Wenn i==1, wird sie von Handler1 bearbeitet i==2, wird von Handler2 verarbeitet und so weiter. In der Programmierung ist diese Methode der Geschäftsverarbeitung sehr verbreitet. Alle Klassen, die Anfragen verarbeiten, verfügen über if...else...-Bedingungsanweisungen, die eine Verantwortungskette für die Bearbeitung von Anfragen bilden. Der Vorteil dieser Methode besteht darin, dass sie sehr intuitiv, einfach und klar ist und relativ leicht zu warten ist. Allerdings weist diese Methode auch einige problematische Probleme auf:
Aufgeblähter Code: Die Beurteilungsbedingungen in tatsächlichen Anwendungen sind normalerweise nicht so einfach. Um festzustellen, ob es sich um 1 oder 2 handelt, sind möglicherweise komplexe Berechnungen, Abfragen der Datenbank usw. erforderlich, was viel zusätzlichen Code erfordert. Wenn es mehr Beurteilungsbedingungen gibt, funktioniert diese if...else...-Anweisung grundsätzlich nicht . Habe es gesehen.
Hoher Kopplungsgrad: Wenn wir weiterhin Klassen zur Verarbeitung von Anforderungen hinzufügen möchten, müssen wir weiterhin andere Beurteilungsbedingungen hinzufügen. Außerdem ist die Reihenfolge dieser Bedingungsbeurteilung fest codiert In der Reihenfolge können wir nur diese bedingte Anweisung ändern.
Da wir uns nun über die Mängel im Klaren sind, müssen wir Wege finden, sie zu beheben. Die Geschäftslogik dieses Szenarios ist sehr einfach: Wenn Bedingung 1 erfüllt ist, wird sie von Handler1 verarbeitet, wenn nicht, wird sie weitergegeben, wenn Bedingung 2 erfüllt ist, wird sie von Handler2 verarbeitet, wenn sie nicht erfüllt ist , es wird weiterhin weitergegeben usw., bis die Bedingung endet. Tatsächlich ist die Verbesserungsmethode auch sehr einfach, nämlich den Teil der Beurteilungsbedingung in die Verarbeitungsklasse einzufügen. Dies ist das Prinzip des Verantwortungskettenmodells.

Die Struktur des Chain-of-Responsibility-Musters
Das Klassendiagramm des Chain-of-Responsibility-Musters ist sehr einfach. Es besteht aus einer abstrakten Verarbeitungsklasse und einer Reihe ihrer Implementierungsklassen:
Abstrakte Verarbeitung Klasse: In der abstrakten Verarbeitungsklasse enthält sie hauptsächlich eine Mitgliedsvariable nextHandler, die auf die nächste Verarbeitungsklasse zeigt, und eine Methode handRequest zum Verarbeiten von Anforderungen. Die Hauptidee der handRequest-Methode besteht darin, dass diese Verarbeitungsklasse erfüllt wird wird es verarbeiten, andernfalls wird es von nextHandler verarbeitet.
Spezifische Verarbeitungsklasse: Die spezifische Verarbeitungsklasse implementiert hauptsächlich eine spezifische Verarbeitungslogik und anwendbare Bedingungen für die Verarbeitung.
Beispiel

Das Chain-of-Responsibility-Muster hat zwei Rollen:
Abstrakter Handler (Handler)-Rolle: Definiert eine angeforderte Schnittstelle. Bei Bedarf können Sie eine Methode definieren, um einen Verweis auf das nächste Objekt festzulegen und zurückzugeben.
ConcreteHandler-Rolle: Wenn sie verarbeitet werden kann, wird die Anforderung verarbeitet. Wenn sie nicht verarbeitet werden kann, wird die Anforderung zur Verarbeitung an die nächste Partei weitergeleitet. Dies bedeutet, dass es die Anfragen bearbeitet, die es verarbeiten kann, und Zugriff auf sein nächstes Zuhause hat.
Der Testcode für den oben genannten Modus lautet wie folgt:

package chainOfResp;
/**
 *描述：抽象处理角色
 */
public abstract class Handler {
 
 protected Handler successor;
 /**
  *描述：处理方法
  */
 public abstract void handlerRequest(String condition);
  
  
 public Handler getSuccessor() {
  return successor;
 }
 public void setSuccessor(Handler successor) {
  this.successor = successor;
 }
  
}

package chainOfResp;
/**
 *描述：具体处理角色
 */
public class ConcreteHandler1 extends Handler {
 
 @Override
 public void handlerRequest(String condition) {
  // 如果是自己的责任，就自己处理，负责传给下家处理
  if(condition.equals("ConcreteHandler1")){
   System.out.println( "ConcreteHandler1 handled ");
   return ;
  }else{
   System.out.println( "ConcreteHandler1 passed ");
   getSuccessor().handlerRequest(condition);
  }
 }
 
}

package chainOfResp;
/**
 *描述：具体处理角色
 */
public class ConcreteHandler2 extends Handler {
  
 @Override
 public void handlerRequest(String condition) {
  // 如果是自己的责任，就自己处理，负责传给下家处理
  if(condition.equals("ConcreteHandler2")){
   System.out.println( "ConcreteHandler2 handled ");
   return ;
  }else{
   System.out.println( "ConcreteHandler2 passed ");
   getSuccessor().handlerRequest(condition);
  }
 }
 
}

package chainOfResp;
/**
 *描述：具体处理角色
 */
public class ConcreteHandlerN extends Handler {
 
 /**
  * 这里假设n是链的最后一个节点必须处理掉
  * 在实际情况下，可能出现环，或者是树形，
  * 这里并不一定是最后一个节点。
  *
  */
 @Override
 public void handlerRequest(String condition) {
 
  System.out.println( "ConcreteHandlerN handled");
   
 }
 
}

package chainOfResp;
/**
 *描述：测试类
 */
public class Client {
 
 /**
  *描述：
  */
 public static void main(String[] args) {
  
  Handler handler1 = new ConcreteHandler1();
  Handler handler2 = new ConcreteHandler2();
  Handler handlern = new ConcreteHandlerN();
   
  //链起来
  handler1.setSuccessor(handler2);
  handler2.setSuccessor(handlern);
   
  //假设这个请求是ConcreteHandler2的责任
  handler1.handlerRequest("ConcreteHandler2");
   
   
 }
 
}

Um ein Beispiel zu geben, in der Produktionswerkstatt einer Spielzeugfabrik, dem Fließband. Es handelt sich um eine Verantwortungskette. Beispielsweise besteht ein Spielzeugflugzeug aus einem Rohbaumonteur, einem Triebwerksmonteur, einem Propellermonteur und einem Modellverpacker. Wenn dieses Objekt zu wem auch immer fließt, ist er für die Installation des Teils verantwortlich, für den er verantwortlich ist. Nachdem die Installation dieses Teils abgeschlossen ist, fließt es zum nächsten Link, bis alle Umgebungen abgeschlossen sind. Dies ist eine lebenslange Kette von Verantwortung. Es gibt auch eine Qualitätskontrollkette, und die Qualitätskontrolle ist ebenfalls in mehrere Teile unterteilt, darunter Gehäuseinspektion, Motorinspektion, Propellerinspektion und Verpackungsinspektion. Wenn das Produkt dem Inspektor zur Inspektion des Teils überlassen wird, für das er verantwortlich ist, wird es bei einem Problem direkt abgeholt. Wenn kein Problem vorliegt, wird es an den nächsten Inspektor weitergegeben, bis alle Inspektionen abgeschlossen sind. Beides sind Verantwortungsketten, aber der Unterschied besteht darin, dass jeder die generierte Verantwortungskette und einen Teil davon verwaltet, während die Verantwortungskette für die Qualitätsprüfung beurteilt wird und entweder verarbeitet wird oder nicht. Dies sind die beiden Klassifizierungen von Verantwortungsketten. Die letztere wird als reine Verantwortungskette bezeichnet, und die erstere wird als unreine Verantwortungskette bezeichnet. In der Praxis gibt es selten und die häufigste ist die unreine Verantwortungskette wird durch die Simulation einer reinen Verantwortungskette gehandhabt.

Vor- und Nachteile des Verantwortungskettenmodells
Im Vergleich zu if...else... weist das Verantwortungskettenmodell eine geringere Kopplung auf, da es Bedingungsbestimmungen auf verschiedene Verarbeitungsklassen verteilt und die Priorität dieser Verarbeitungsklassen Die Verarbeitung Die Reihenfolge kann beliebig festgelegt werden. Das Verantwortungskettenmodell weist auch Mängel auf, die mit denen von if...else...-Anweisungen identisch sind, dh alle Beurteilungsbedingungen müssen ausgeführt werden, bevor die richtige Verarbeitungsklasse gefunden wird relativ lange, Leistungsprobleme sind schwerwiegender.

Anwendbare Szenarien des Chain-of-Responsibility-Modells
Genau wie im ersten Beispiel: Wenn Sie sich bei der Verwendung von if...else...-Anweisungen zum Organisieren einer Verantwortungskette unzulänglich fühlen und der Code schlecht aussieht, Sie können das Verantwortungskettenmuster für die Rekonstruktion verwenden.

Zusammenfassung
Das Chain-of-Responsibility-Modell ist eigentlich eine flexible Version der if...else...-Anweisung. Der Vorteil davon ist, dass es so ist flexibler, aber es bringt auch Risiken mit sich. Wenn Sie beispielsweise die Beziehung zwischen Verarbeitungsklassen einrichten, müssen Sie besonders sorgfältig darauf achten, die bedingte Beziehung zwischen der Logik vor und nach der Verarbeitungsklasse zu bestimmen, und darauf achten, keine Zirkelverweise in der zu verursachen Kette.

Weitere Beispiele zur Erläuterung der Anwendung des Verantwortungskettenmusters in der Java-Designmusterprogrammierung finden Sie auf der chinesischen PHP-Website für verwandte Artikel!