Reaktormono Asynchroner Kettenanruf: Holen Sie sich Felder aus einem Mono -Ergebnis und geben Sie sie weiter

In diesem Artikel wird eingehend untersucht, wie ein bestimmtes Feld aus einem Monoergebnis extrahiert werden kann, ohne einen Faden in der Reaktor -Responsive -Programmierung zu blockieren und es als Parameter für nachfolgende asynchrone Operationen zu übergeben. Die sequentiellen Abhängigkeitsaufrufe werden über FlatMap implementiert, und die Ergebnisse der Mono.zip-Aggregation mehrerer asynchroner Operationen sind so erstellt, dass eine effiziente, nicht blockierende Datenverarbeitungskette erstellt wird, um die Reaktionsfähigkeit der Systeme und die Ressourcenauslastung sicherzustellen.

Einführung: Herausforderungen reaktionsschneller Kettenaufrufe

Bei responsiven Programmierungen basierend auf dem Projektreaktor stoßen wir häufig auf Szenarien, in denen eine Reihe von asynchronen Operationen erforderlich ist, und das Ergebnis einer Operation ist die Eingabe des nächsten Vorgangs. Zum Beispiel müssen wir zuerst eine Bestellung abfragen und dann die entsprechenden LKW -Informationen basierend auf einer ID in der Bestellung (wie Truckid) abfragen. In diesem Fall ist der Schlüssel, wie Sie die erforderlichen Felder aus dem Ergebnis des ersten Monos elegant extrahieren können, ohne den Hauptfaden zu blockieren und an die Erstellungsfunktion des zweiten Monos zu übergeben. Obwohl der Wert durch direkt unter Verwendung der Block () -Methode erhalten werden kann, verstößt dies gegen das nicht blockierende Prinzip der reaktionsschnellen Programmierung und führt zu Leistungsengpässen und Skalierbarkeitsproblemen.

Szenario Beschreibung: Holen Sie sich LKW -Informationen aus Bestellungen

Angenommen, wir haben zwei Servicemethoden, die Mono bzw. Mono zurückgeben:

 // Bestelldienst bestellen, bestellen basierend auf id mono <order> order = orderService.getById (UUID -ID);

// Fahrzeugservice, erhalten Sie LKW -Mono <truck> Truck = VehicleService.getByTruckid (UUID Truckid);</truck></order>

Unsere Bestellkurs ist wie folgt definiert, die ein Truckid -Feld enthält:

 Klassenbestellung {
    private Uuid -ID;
    privater Zeichenfolge Name;
    private Uuid Truckid; // Felder müssen wir extrahieren // ... andere Felder und Methoden}}

Unser Ziel ist: Erhalten Sie zunächst ein Auftragsobjekt, extrahieren Sie dann die Lkw -ID aus diesem Auftragsobjekt und nennen Sie diese LKWID schließlich die Methode des Vehicleservice.getByTruckid (). Der gesamte Prozess muss nicht blockiert sein.

Lösung 1: Verwenden Sie FlatMap für sequentielle Abhängigkeitsoperationen

FlatMap ist ideal, wenn nachfolgende asynchrone Operationen vollständig auf den erfolgreichen Ergebnissen des vorherigen Mono beruhen, und wir kümmern uns nur um die Ausgabe des endgültigen Vorgangs. Der Flatmap -Operator wandelt ein Mono in mono um, wobei R vom Wert von T abhängig wird.

Arbeitsprinzip: FlatMap empfängt eine Funktion als Parameter. Die Eingabe dieser Funktion ist das vom vorherige Mono (d. H. Das Orderobjekt) emittierte Element, und die Ausgabe ist ein neues Mono (d. H. Mono ). Wenn das vorherige Mono seinen Wert ausgibt, nennt FlatMap diese Funktion und abonniert das neu generierte Mono. Schließlich wird der Flatmap -Operator das Ergebnis dieses neuen Mono ausgeben.

Beispielcode:

 Import Reactor.core.Publisher.Mono;
import Java.util.uuid;

// Angenommene Auftrags- und LKW -Klassen und Service -Schnittstellenklassenauftrag {{
    private Uuid -ID;
    privater Zeichenfolge Name;
    private Uuid Truckid;

    öffentliche Bestellung (UUID -ID, String -Name, UUID Truckid) {
        this.id = id;
        this.name = name;
        this.truckid = truckid;
    }

    public uUid gettruckid () {
        Rückkehr Truckid;
    }
    // ... Getters, Setzer
}

Klassenwagen {
    private Uuid -ID;
    privates Zeichenfolgenmodell;

    öffentlicher Lkw (UUID -ID, String -Modell) {
        this.id = id;
        this.model = Modell;
    }

    @Override
    public String toString () {
        return "truck {id =" id ", model = '" Modell "'}";
    }
    // ... Getters, Setzer
}

Schnittstelle ordnerservice {
    Mono <order> getbyid (uUid id);
}

Schnittstelle Vehicleservice {
    Mono <truck> GetByTruckid (uUid truckid);
}

öffentliche Klasse ReactivechainingExample {

    privates endgültiger Bestandsservice ordnerservice;
    private Final VehicaLservice Vehicleservice;

    public reactiveching -example (orderService orderService, vehicleService Vehicleservice) {
        this.orderservice = orderService;
        this.vehicleservice = vehicleService;
    }

    /**
     * Ermitteln Sie nach Erhalt der Bestellung die LKW -Informationen basierend auf dem Truckid in der Bestellung* @param OrderID Order ID
     * @return mono mit LKW -Informationen enthält Informationen
     */
    public mono <truck> GetTruckbyorderid (uUid orderid) {
        Mono <order> orderMono = orderService.getById (orderId);

        // mit FlatMap den LKW aus der Bestellung extrahieren und Vehicleservice anrufen, um LKW zu erhalten
        Mono <truck> truckmono = orderMono.flatmap (Order ->
            vehicleService.getByTruckid (Order.GetRuckid ())
        );

        Rückkehr Truckmono;
    }

    public static void main (String [] args) {
        // Simulation des Dienstes, um orderService mockorderservice = id -> mono.just (Neue Order (ID, "Test Order", uUid.Randomuuid ()) implementieren;
        VehicleService MockVehiclesservice = Truckid -> Mono.Just (neuer LKW (Truckid, "Volvo FH");

        ReactivechainingExample Beispiel = Neue ReactivechainingExample (Mockorderservice, MockVehiclesservice);

        UUid TestOrderID = uUid.randomuuid ();
        Beispiel.GetRuckbyorderID (TestOrderID)
                .abonnieren(
                        Truck -> System.out.println ("erfolgreich erhaltener LKW:" Truck),
                        Fehler -> system.err.println ("Der LKW hat nicht erhalten:" Fehler.getMessage ())
                );

        // Um ​​den Haupt -Thread zu warten, bis die asynchrone Operation abgeschlossen ist, versuchen Sie es {{{{
            Thread.sleep (1000);
        } catch (InterruptedException e) {
            Thread.currentThread (). Interrupt ();
        }
    }
}</truck></order></truck></truck></order>

Im obigen Code zeigt OrderMono.flatMap (Order -> VehicaLService.getByTruckid (order.GetRuckid ()) deutlich, wie die LKWID aus dem Order -Objekt abgerufen und als Parameter an die VehicleService.getByTruckid () -Methode () weitergegeben werden kann, wodurch nicht blockierende Kettenanrufe implementiert werden können.

Lösung 2: Verwenden Sie Mono.zip, um mehrere asynchrone Ergebnisse zu aggregieren

Manchmal brauchen wir nicht nur die endgültigen LKW -Informationen, sondern auch die ursprünglichen Auftragsinformationen, oder die Ergebnisse mehrerer asynchroner Operationen müssen in ein einzelnes Verbindungsergebnis zusammengefasst werden. In diesem Fall ist der Mono.zip -Operator sehr nützlich. Mono.zip kann mehrere mono in einen mono > verschmelzen, wobei Tuplen alle von der Quellmono emittierten Werte enthält.

Wie es funktioniert: Mono.zip wird darauf warten, dass alle teilnehmenden Mono ihre Werte ausstellen. Sobald alle Mono beendet sind und die Werte emittiert sind, verpackt Mono.zip diese Werte in ein Tupel und Emit. Wenn ein teilnehmendes Mono fehlschlägt, schlägt auch der gesamte Postleitzahl fehl.

Beispielcode:

 Import Reactor.core.Publisher.Mono;
Import Reactor.util.Function.tuple2; // Tuple2 importieren
import Java.util.uuid;

// ... Bestellung, LKW, ordnerservice, VehicleService -Klassendefinition ist die gleiche wie oben // Definieren Sie eine Ergebnisklasse, um Bestellung und LKW zu verkapseln
Klasse orderTruckResult {
    private Bestellung;
    Privatwagen;

    public orderTruckResult (Bestellung, Lkw) {
        this.order = order;
        this.truck = truck;
    }

    öffentliche Order getorder () {
        Rücklaufauftrag;
    }

    öffentlicher Lkw getTruck () {
        Rückfahrwagen;
    }

    @Override
    public String toString () {
        return "orderTruckResult {order =" order.id ", truck =" truck.model "}";
    }
}

öffentliche Klasse ReactiveaggregationExample {

    privates endgültiger Bestandsservice ordnerservice;
    private Final VehicaLservice Vehicleservice;

    public reactiveaggregationexample (orderService orderService, Vehicleservice Vehicleservice) {
        this.orderservice = orderService;
        this.vehicleservice = vehicleService;
    }

    /**
     * Holen Sie sich die Bestellung und die entsprechenden LKW -Informationen und aggregieren Sie sie in ein Ergebnisobjekt* @Param Orderid Order ID
     * @Return Mono mit Bestellung und LKW -Informationen
     */
    public mono <ordertruckresult> getorderandtruck (uUid orderId) {
        Mono <order> orderMono = orderService.getById (orderId);

        // Schlüsselschritte: Verwenden Sie Flatmap, um Truckid aus OrderMono zu extrahieren und Truckmono zu erstellen
        Mono <truck> truckmono = orderMono.flatmap (Order ->
            vehicleService.getByTruckid (Order.GetRuckid ())
        );

        // original original ordermono und neu erstellte Truckmono mit mono.zip aggregieren // HINWEIS: Hier ziehen wir den ursprünglichen Ordermono und den Truckmono ab, der davon abhängt.
        // Das Abonnement von OrderMono wird ausgelöst und das Ergebnis wird verwendet, um einen Truckmono zu erstellen.
        // Schließlich kombiniert sie, wenn beide Mono Ergebnisse haben, sie kombinieren sie.
        Mono <ordertruckresult> resultMono = mono.zip (OrderMono, Truckmono)
                .flatmap (tuple -> {
                    Order order = tuple.gett1 (); // Bestellung bekommen
                    Truck Truck = tuple.gett2 (); // LKW bekommen
                    Return Mono.Just (New OrderTruckResult (Order, LKW));
                });

        return resultMono;
    }

    public static void main (String [] args) {
        // Simulationsdienst implementiert ordnerservice mockorderservice = id -> mono.just (neue order (id, "test order" id.toString (). Substring (0,4), uuid.randomuuid ()));
        VehicleService MockVehiclesservice = Truckid -> Mono.Just (neuer LKW (Truckid, Modell- "Truckid.toString (). Substring (0,4));

        ReactiveaggregationExample Beispiel = Neue ReactiveaggregationExample (Mockorderservice, MockVehiclesservice);

        UUid TestOrderID = uUid.randomuuid ();
        Beispiel.GetOrderAndruck (TestOrderID)
                .abonnieren(
                        Ergebnis -> System.out.println ("erfolgreich erhaltene Bestellung und LKW:" Ergebnis),
                        Fehler -> System.err.println ("Bestellung und LKW nicht erhalten:" Fehler.getMessage ())
                );

        versuchen {
            Thread.sleep (1000);
        } catch (InterruptedException e) {
            Thread.currentThread (). Interrupt ();
        }
    }
}</ordertruckresult></truck></order></ordertruckresult>

In diesem Beispiel verwenden wir zuerst FlatMap, um die Truckid von OrderMono von OrderMono zu holen und den Truckmono zu erstellen. Anschließend verwenden wir Mono.zip (OrderMono, Truckmono), um die Ergebnisse des ursprünglichen Ordermono und des neu erzeugten Truckmono zu verschmelzen. Der ZIP -Betrieb wartet, bis beide Mono erfolgreich abgeschlossen werden können, und verkapulieren dann ihre Ergebnisse in Tuple2. Schließlich verwenden wir erneut FlatMap, um Tuple2 in unser benutzerdefiniertes OrderTruckResult-Objekt umzuwandeln, um es lesbarer und typer sicherer zu machen.

Notizen und Best Practices

1. Vermeiden Sie Blockierung von Operationen: Vermeiden Sie immer die Block () -Methode in reaktionsschnellen Ketten. Block () wandelt reaktionsschnelle Streams in Blockierung von Anrufen um und verliert die Vorteile der reaktionsschnellen Programmierung.
2. Wählen Sie den richtigen Operator aus:
   • Wenn das Ergebnis einer asynchronen Operation der Eingang zum nächsten asynchronen Betrieb ist, verwenden Sie FlatMap.
   • Mono.zip (oder flux.zip) wird verwendet, wenn mehrere asynchrone Operationen, die nicht parallel voneinander abhängig sind, und ihre Ergebnisse aggregieren.
   • Verwenden Sie Mono.First (), wenn mehrere asynchrone Operationen parallel durchgeführt werden müssen, aber nur das erste abgeschlossene Ergebnis kümmern müssen.
3. Benutzerdefinierte Ergebniskapselung: Wenn aggregierte Ergebnisse aus mehreren asynchronen Operationen aggregiert sind, kann die Definition eines dedizierten Pojo (z. B. orderTruckResult) die Kapitulation dieser Ergebnisse, anstatt Tuple direkt zu verwenden, die Lesbarkeit und die Type des Codes verbessern.
4. Fehlerbehebung: In praktische Anwendungen stellen Sie jeder Mono -Kette die Fehlerbehandlungslogik hinzu, z.
5. Heiße und kalte Fluss verstehen: Mono und Fluss sind standardmäßig kalte Flüsse und werden nur dann ausgeführt, wenn sie abonniert werden. Im Mono.zip -Szenario werden alle teilnehmenden Mono abonniert.

Zusammenfassen

Bei Reaktor -Responsive -Programmierung ist das Extrahieren von Feldern aus den Ergebnissen eines Monos und der Übergabe an nachfolgende asynchrone Operationen eine häufige Voraussetzung. Indem wir die beiden Kernbetreiber-Flatmap und Mono.zip flexibel verwenden, können wir eine effiziente, nicht blockierende und gut strukturierte asynchrone Datenverarbeitungspipeline erstellen. FlatMap ist für nacheinander abhängige Kettenaufrufe geeignet, während mono.zip gut darin ist, die Ergebnisse mehrerer asynchroner Operationen zu aggregieren. Das Beherrschen dieser Muster ist der Schlüssel zum Schreiben von robusten, skalierbaren und reaktionsschnellen Anwendungen.

Das obige ist der detaillierte Inhalt vonReaktormono Asynchroner Kettenanruf: Holen Sie sich Felder aus einem Mono -Ergebnis und geben Sie sie weiter. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!