Beispielanalyse des Verantwortungskettenmusters in Java-Entwurfsmustern-javaLernprogramm-php.cn

In diesem Artikel werden hauptsächlich die relevanten Informationen zum Entwurfsmuster und zum Verantwortungskettenmuster im Detail vorgestellt. Interessierte Freunde können sich auf

Definition beziehen: Geben Sie mehrere an Objekten eine Chance, die Anfrage zu bearbeiten, wodurch die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anfrage vermieden wird. Diese Objekte werden zu einer Kette verbunden und die Anforderung wird entlang der Kette weitergeleitet, bis sie von einem Objekt verarbeitet wird.

Typ: Verhaltensmuster

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); 
 } 
}

Nach dem Login kopieren

Die Geschäftslogik des Codes ist wie folgt: eine Ganzzahl i und eine Anfrage. Der Wert von i bestimmt, wer bearbeitet wird die Anfrage. Wenn i==1, wird sie von Handler1 verarbeitet, wenn i==2, wird sie 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. Diese Methode weist jedoch auch einige problematische Probleme auf:

aufgeblähter Code: Die Beurteilungsbedingungen in tatsächlichen Anwendungen sind normalerweise nicht so einfach wie die Beurteilung, ob es 1 oder 2 ist. Es können komplexe Berechnungen, Abfragen der Datenbank usw. erforderlich sein, was viel zusätzlichen Code erfordert Wenn es zu viele Beurteilungsbedingungen gibt, wird die if...else...-Anweisung grundsätzlich unleserlich.
Hoher Kopplungsgrad: Wenn wir weiterhin Klassen zur Verarbeitung von Anforderungen hinzufügen möchten, müssen wir zusätzlich die Reihenfolge dieser Beurteilungsbedingungen hinzufügen Die Bedingungsbeurteilung ist ebenfalls fest codiert. Wenn Sie die Reihenfolge ändern möchten, können Sie nur diese Bedingungsanweisung ä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.

Struktur des Chain of Responsibility-Musters

Das Klassendiagramm des Chain of Responsibility-Musters ist sehr einfach, es besteht aus einer Abstraktion Behandelt eine Klasse und ihren Satz von Implementierungsklassenzusammensetzung:

Abstrakte Verarbeitungsklasse: Die abstrakte Verarbeitungsklasse enthält hauptsächlich eine Mitgliedsvariable nextHandler, die auf zeigt Die nächste Verarbeitungsklasse und eine Verarbeitungsanforderungsmethode handRequest. Die Hauptidee der handRequest-Methode besteht darin, dass diese Verarbeitungsklasse sie verarbeitet, wenn die Verarbeitungsbedingungen erfüllt sind, andernfalls wird sie von nextHandler verarbeitet.

Spezifische Verarbeitungsklasse: Spezifische Verarbeitungsklasse implementiert hauptsächlich spezifische Verarbeitungslogik und anwendbare Bedingungen für die Verarbeitung.

Nachdem Sie die allgemeine Idee des Verantwortungskettenmodells verstanden haben, wird es einfacher zu verstehen, wenn Sie sich den Code ansehen:

class Level { 
  private int level = 0; 
  public Level(int level){ 
    this.level = level; 
  }; 
   
  public boolean above(Level level){ 
   if(this.level >= level.level){ 
      return true; 
    } 
    return false; 
  } 
} 
 
class Request { 
  Level level; 
  public Request(Level level){ 
    this.level = level; 
  } 
   
  public Level getLevel(){ 
    return level; 
  } 
} 
 
class Response { 
 
} 

abstract class Handler { 
  private Handler nextHandler;   
  public final Response handleRequest(Request request){ 
    Response response = null; 
     
   if(this.getHandlerLevel().above(request.getLevel())){ 
      response = this.response(request); 
    }else{ 
      if(this.nextHandler != null){ 
        this.nextHandler.handleRequest(request); 
      }else{ 
        System.out.println("-----没有合适的处理器-----"); 
      } 
    } 
    return response; 
  } 
  public void setNextHandler(Handler handler){ 
   this.nextHandler = handler; 
  } 
  protected abstract Level getHandlerLevel(); 
   public abstract Response response(Request request); 
} 
 
class ConcreteHandler1 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(1); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器1进行处理-----"); 
    return null; 
  } 
} 
 
class ConcreteHandler2 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(3); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器2进行处理-----"); 
    return null; 
  } 
} 
 
class ConcreteHandler3 extends Handler { 
  protected Level getHandlerLevel() { 
    return new Level(5); 
  } 
  public Response response(Request request) { 
    System.out.println("-----请求由处理器3进行处理-----"); 
    return null; 
  } 
} 
 
public class Client { 
  public static void main(String[] args){ 
    Handler handler1 = new ConcreteHandler1(); 
    Handler handler2 = new ConcreteHandler2(); 
    Handler handler3 = new ConcreteHandler3(); 
 
    handler1.setNextHandler(handler2); 
    handler2.setNextHandler(handler3); 
     
    Response response = handler1.handleRequest(new Request(new Level(4))); 
  } 
}

Nach dem Login kopieren

Ebenenklasse im Code Es handelt sich um eine simulierte Beurteilungsbedingung; die abstrakte Klasse Handler führt hier hauptsächlich eine Verarbeitungsebene durch ist höher als die Ebene der Anfrage, die verarbeitet werden kann, andernfalls wird sie an die nächste Verarbeitung oder Verarbeitung übergeben. Legen Sie die Vor- und Nachher-Beziehungen der Kette in der Client-Klasse fest und übergeben Sie die Anforderung während der Ausführung an die erste Verarbeitungsklasse. Die ausgeführte Funktion ist dieselbe wie die if...else...-Anweisung im vorherigen Artikel.

Vor- und Nachteile des Verantwortungskettenmodells

Im Vergleich zu if...else... weist das Verantwortungskettenmodell eine geringere Kopplung auf weil Es verteilt bedingte Urteile auf verschiedene Verarbeitungsklassen und die Prioritätsverarbeitungsreihenfolge dieser Verarbeitungsklassen kann nach Belieben 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 unzulänglich fühlen Um eine Verantwortungskette zu organisieren: Wenn Ihr Code schlecht aussieht, verwenden Sie das Chain of Responsibility-Muster, um ihn umzugestalten.

Zusammenfassung

Das Chain-of-Responsibility-Modell ist eigentlich eine flexible Version der if...else...-Anweisung. Es fügt diese Beurteilungsbedingungsanweisungen in jede Verarbeitungsklasse ein. Der Vorteil davon ist, dass es flexibler ist, aber auch Wenn Sie beispielsweise die Beziehung zwischen Verarbeitungsklassen einrichten, müssen Sie besonders darauf achten, die bedingte Beziehung zwischen der Logik vor und nach der Verarbeitungsklasse zu bestimmen und darauf zu achten, dass keine Zirkelverweise in der Kette entstehen.

Das obige ist der detaillierte Inhalt vonBeispielanalyse des Verantwortungskettenmusters in Java-Entwurfsmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!