Detaillierte Erläuterung der Pipeline und des Ventils im Tomcat-Pipeline-Modus

Vorwort

Wenn in einem relativ komplexen großen System ein Objekt oder ein Datenfluss vorhanden ist, der mit komplexer Logik verarbeitet werden muss, können wir diese komplexen logischen Prozesse in einer großen Komponente ausführen. Diese Methode erreicht zwar das Ziel, ist aber einfach und grob. Vielleicht bringt dieser einfache und grobe Ansatz in einigen Fällen einige Probleme mit sich. Wenn ich beispielsweise einen Teil der Verarbeitungslogik ändern, dem Prozess Verarbeitungslogik hinzufügen oder die Verarbeitungslogik im Prozess reduzieren möchte, erschweren einige scheinbar einfache Änderungen hier den Anfang, außer dass wir die gesamte Komponente ändern. Das gesamte System scheint weder skalierbar noch wiederverwendbar zu sein.

Gibt es ein Modell, das den gesamten Verarbeitungsablauf in Details aufteilen kann, wobei jedes kleine Modul unabhängig von den anderen ist und für einen Teil der Logikverarbeitung verantwortlich ist? Diese kleinen Logikverarbeitungsmodule sind der Reihe nach verbunden, wobei die Ausgabe des vorherigen Moduls die Eingabe des nächsten Moduls und die Ausgabe des letzten Moduls das endgültige Verarbeitungsergebnis ist. Auf diese Weise muss beim Ändern der Logik nur ein bestimmtes Modul geändert werden. Das Hinzufügen oder Reduzieren der Verarbeitungslogik kann auch auf eine bestimmte Modulgranularität verfeinert werden. Jedes Modul kann wiederverwendet werden, was die Wiederverwendbarkeit erheblich verbessert. Dieser Modus ist der Pipeline-Modus, der in diesem Kapitel besprochen wird.

Wie der Name schon sagt, verbindet der Pipeline-Modus mehrere Objekte wie eine Pipeline. Das Gesamtbild sieht aus wie mehrere in der Pipeline verschachtelte Ventile, und die Verarbeitungslogik wird auf den Ventilen platziert. Wie in der folgenden Abbildung gezeigt, durchläuft das zu verarbeitende Objekt, nachdem es in die Pipeline gelangt ist, jeweils Ventil eins, Ventil zwei, Ventil drei und Ventil vier. Jedes Ventil führt eine logische Verarbeitung des eingehenden Objekts durch. Nach der Verarbeitungsschicht wird es vom Ende der Pipeline aus verarbeitet. Zu diesem Zeitpunkt ist das Objekt das verarbeitete Zielobjekt.

Da der Pipeline-Modus so nützlich ist, hoffen wir, ihn im Programm angemessen einsetzen zu können. Um diesen Modus zu realisieren, müssen mehrere Objekte zusammenarbeiten. Bitte beachten Sie das folgende Klassendiagramm. Die Valve-Schnittstelle definiert die Aufrufmethode des Ventils. Da die Ventile über eine einzelne verknüpfte Listenstruktur miteinander verbunden sind, müssen Operationen für „Next“ bereitgestellt werden. Implementieren Sie einfach ein Ventil und erweitern Sie es. Die Pipeline-Schnittstelle definiert die Methoden zum Bedienen von Ventilen in der Pipeline, einschließlich Methoden wie das Abrufen des ersten Ventils, das Abrufen des Basisventils und das Hinzufügen von Ventilen. Die Pipeline muss es erweitern.

Schauen wir uns an, wie man einfach ein Pipeline-Muster implementiert:

① Ventilschnittstelle

öffentliche Schnittstelle Valve {
 öffentliches Valve getNext();
 öffentliche void setNext(Ventil Ventil);
 public void invoke (String-Behandlung);
}

② Pipeline-Schnittstelle

öffentliche Schnittstelle Pipeline {
öffentliches Valve getFirst();
öffentliches Valve getBasic();
öffentliche void setBasic(Ventil Ventil);
öffentliche void addValve(Ventil Ventil);
}

③ Grundlegendes Ventil : Die Verarbeitungslogik besteht einfach darin, "aa" in der eingehenden Zeichenfolge durch "bb" zu ersetzen.

öffentliche Klasse BasicValve implementiert Valve {
geschütztes Ventil nächstes = null; 
öffentliches Valve getNext() {
als nächstes zurückkehren;
}
public void invoke(String-Behandlung) {
    Handhabung = Handhabung.Alles ersetzen("aa", "bb");
System.out.println("Nach der grundlegenden Ventilverarbeitung: " + Handhabung);
}
öffentliche void setNext(Ventil Ventil) {
dies.nächstes = Ventil;
}
}

④ Das zweite Ventil ersetzt "11" in der eingehenden Zeichenfolge durch "22"

öffentliche Klasse SecondValve implementiert Valve {
geschütztes Ventil nächstes = null; 
öffentliches Valve getNext() {
als nächstes zurückkehren;
}
public void invoke(String-Behandlung) {
Handhabung = Handhabung.Alles ersetzen("11", "22");
System.out.println("Nachdem das zweite Ventil behandelt wurde: " + Behandlung);
getNext().invoke(Behandlung);
}
öffentliche void setNext(Ventil Ventil) {
dies.nächstes = Ventil;
}
}

⑤ Das dritte Ventil ersetzt "zz" in der eingehenden Zeichenfolge durch "yy".

öffentliche Klasse ThirdValve implementiert Valve {
geschütztes Ventil nächstes = null; 
öffentliches Valve getNext() {
als nächstes zurückkehren;
}
public void invoke(String-Behandlung) {
Handhabung = Handhabung.Alles ersetzen("zz", "yy");
System.out.println("Nachdem das dritte Ventil behandelt wurde: " + Behandlung);
getNext().invoke(Behandlung);
}
öffentliche void setNext(Ventil Ventil) {
dies.nächstes = Ventil;
}
}

⑥ Bei Pipelines besteht unsere allgemeine Vorgehensweise darin, zuerst das Basisventil über setBasic einzustellen und dann nacheinander weitere Ventile hinzuzufügen. Die Ausführungsreihenfolge lautet: Das zuerst hinzugefügte Ventil wird zuerst ausgeführt und das Basisventil wird zuletzt ausgeführt.

öffentliche Klasse StandardPipeline implementiert Pipeline {
geschütztes Ventil zuerst = null; 
geschütztes Ventil basic = null; 
öffentliche Leere addValve (Ventil Ventil) {
wenn (erste == null) {
zuerst = Ventil;
valve.setNext(grundlegend);
} anders {
Ventilstrom = zuerst;
während (aktuell != null) {
wenn (current.getNext() == basic) {
aktuell.setNext(Ventil);
valve.setNext(grundlegend);
brechen;
}
aktuell = aktuell.getNext();
}
}
}
öffentliches Valve getBasic() {
Rückgabegrundsatz;
}
öffentliches Valve getFirst() {
zuerst zurückkehren;
}
öffentliche void setBasic(Ventil Ventil) {
dies.basic = Ventil;
}
}

⑦ Testklasse

öffentliche Klasse Main {
öffentliche statische void main(String[] args) {
Zeichenfolgenbehandlung="aabb1122zzyy";
StandardPipeline-Pipeline = neue StandardPipeline();
BasicValve basicValve = neues BasicValve();
Zweites Ventil zweites Ventil = neues Zweites Ventil();
Drittes Ventil drittes Ventil = neues Drittes Ventil();
pipeline.setBasic(basicValve);
pipeline.addValve(zweitesValve);
pipeline.addValve(dritteValve);
pipeline.getFirst().invoke(Behandlung);
}
}

Die Ausgabe lautet wie folgt:

Nachdem das zweite Ventil verarbeitet wurde: aabb2222zzyy
Nachdem das dritte Ventil verarbeitet wurde: aabb2222yyyy
Nachdem das Basisventil verarbeitet wurde: bbbb2222yyyy

Dies ist der Pipeline-Modus, bei dem ein oder mehrere Ventile in der Pipeline angeschlossen sind. Jedes Ventil ist für einen Teil der logischen Verarbeitung verantwortlich und die Daten fließen in der vorgeschriebenen Reihenfolge nach unten. Dieser Modus zerlegt die logischen Verarbeitungsaufgaben, wodurch die Installation und Demontage einer Aufgabeneinheit vereinfacht und somit die Skalierbarkeit, Wiederverwendbarkeit, Mobilität und Flexibilität des Prozesses verbessert wird.

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.