Kette der Verantwortung: Kette der Verantwortung (COR) ist eine Reihe von Klassen, die versuchen, eine Anfrage zu bearbeiten. Mit anderen Worten, wenn eine Anfrage kommt, wird es zuerst die Klasse A verarbeitet.
So verwenden Sie die Kette des Verantwortungskettenmodells
Obwohl dieser Absatz COR verwendet, zeigt er auch, was COR ist.
Es gibt eine Handler -Schnittstelle:
Die Codekopie lautet wie folgt:
öffentliche Schnittstelle Handler {
öffentliches Leerlaufhandlerest ();
}
Dies ist ein Beispiel für die Bearbeitung von Anfragen.
◆ Die erste Lösung, die in den Sinn kommt, lautet: Fügen Sie der Schnittstelle mehrere Anforderungen hinzu:
Die Codekopie lautet wie folgt:
öffentliche Schnittstelle Handler {
public void talehelp ();
public void HandlePrint ();
public void HandleFormat ();
}
Insbesondere handelt es sich um einen Code, um die Schnittstelle zu implementieren:
Die Codekopie lautet wie folgt:
öffentliche Klasse ConcreteHandler implementiert Handler {
privater Handler -Nachfolger;
public concreteHandler (Handler -Nachfolger) {
this.successor = Nachfolger;
}
public void handelp () {
// spezifischer Code für die Verarbeitung der Hilfsanfrage ...
}
public void handlePrint () {
// Wenn es sich um einen Druck handelt, wenden Sie sich um den Druck zu verarbeiten
Nachfolger.Handleprint ();
}
public void handleFormat () {
// Wenn es sich um Format handelt, gehen Sie zum Prozessformat
Nachfolger.HandleFormat ();
}
}
Es gibt drei solche spezifischen Implementierungsklassen oben, bei denen es sich um die Verarbeitungshilfe handelt, und das Verarbeitung von Druck- und Verarbeitungsformat, die wahrscheinlich unsere am häufigsten verwendeten Programmierideen sind.
Obwohl die Idee einfach und klar ist, gibt es ein Erweiterungsproblem.
◆ Die zweite Lösung: Verwenden Sie jede Anforderung in eine Schnittstelle, sodass wir den folgenden Code haben:
Die Codekopie lautet wie folgt:
öffentliche Schnittstelle HelpHandler {
public void talehelp ();
}
öffentliche Schnittstelle PrinThandler {
public void HandlePrint ();
}
öffentliche Schnittstelle Formathandler {
public void HandleFormat ();
}
öffentliche Klasse Betonhandler
Implements HelpsHandler, PrinThandler, Formathandlet {
Private HelpHandler hilft nach außen;
private Printhandler Printsuccessor;
privates Formathandler Formatsuccessor;
öffentlicher Betonhandler (HelpHandler hilftuccessor, Printhandler Printsuccessor, Formathandler Formatsuccessor)
{
this.helpsuccessor = hilftuccessor;
this.printSuccessor = printSuccessor;
this.formatsuccessor = formateSuccessor;
}
public void handelp () {
.........
}
public void handlePrint () {this.printSuccessor = printSuccessor;}
public void handleFormat () {this.formatsuccessor = formatatuccessor;}
}
Beim Hinzufügen einer neuen Anfrageanforderung speichert diese Methode nur die Änderung der Schnittstelle, und die Schnittstellenimplementierung des Betonhandlers muss ebenfalls geändert werden. Und der Code ist offensichtlich nicht einfach und schön.
◆ Lösung 3: In der Handler -Schnittstelle wird nur eine Parametrisierungsmethode verwendet:
Die Codekopie lautet wie folgt:
öffentliche Schnittstelle Handler {
public void Handlrequest (String -Anfrage);
}
Dann lautet der Handler -Implementierungscode wie folgt:
öffentliche Klasse ConcreteHandler implementiert Handler {
privater Handler -Nachfolger;
public concreteHandler (Handler -Nachfolger) {
this.successor = Nachfolger;
}
public void Handlrequest (String -Anfrage) {
if (request.equals ("help")) {
// Hier ist der spezifische Code für den Umgang mit Hilfe} sonst
// an den nächsten Nachfolger übergehen. Handle (Anfrage);
}
}
}
Nehmen wir zunächst an, dass diese Anfrage vom Typ String ist. Natürlich können wir eine spezielle Klassenanfrage erstellen
◆ Die endgültige Lösung: Der Code des Schnittstellenhandlers lautet wie folgt:
Die Codekopie lautet wie folgt:
öffentliche Schnittstelle Handler {
öffentliches Leerlaufhandlerest (Anfrageanforderung);
}
Definition der Anfrageklasse:
öffentliche Klassenanfrage {
privater String -Typ;
öffentliche Anfrage (String -Typ) {this.type = type;}
public String gettType () {return tytyp;}
public void execute () {
// Anfrage der eigentlichen spezifischen Verhaltenscode}
}
Dann lautet der Handler -Implementierungscode wie folgt:
Die Codekopie lautet wie folgt:
öffentliche Klasse ConcreteHandler implementiert Handler {
privater Handler -Nachfolger;
public concreteHandler (Handler -Nachfolger) {
this.successor = Nachfolger;
}
public void Handlreequest (Anfrageanforderung) {
if (Requestinstance von HelpRequest) {
// Hier ist der spezifische Code für die Handhabung} else if (Requestinstance von PrinTrequest) {
request.execute ();
}anders
// an den nächsten Nachfolger übergehen. Handle (Anfrage);
}
}
}
Diese Lösung ist Cor.
1. Vorteile von COR: Da es unmöglich ist, vorherzusagen, welche Art von Anfragen aus der Außenwelt gehören, wenn jede Klasse auf eine Anfrage stößt, die sie nicht verarbeiten kann, geben Sie einfach auf. Dies reduziert zweifellos die Kopplung zwischen Klassen.
2. Der Nachteil von COR ist die Ineffizienz, da die Abschluss einer Anfrage möglicherweise bis zum Ende durchlaufen werden muss, bevor sie abgeschlossen werden kann. In Java AWT1.0 wird der Umgang mit Maustasten COR verwendet.
Die Skalierbarkeit ist schlecht, da es in COR einen einheitlichen Schnittstellenhandler geben muss.