원자로 모노 비동기 체인 호출 : 모노 결과에서 필드를 가져 와서 통과

이 기사는 원자로 응답 형 프로그래밍에서 스레드를 차단하지 않고 모노 결과에서 특정 필드를 추출하는 방법을 깊이 탐구하고이를 후속 비동기 연산으로 매개 변수로 전달합니다. 순차적 종속성 호출은 FlatMap을 통해 구현되며 Mono.zip의 결과는 시스템 응답 성 및 리소스 활용을 보장하기 위해 효율적이고 비 차단 데이터 처리 체인을 구축하기 위해 구축됩니다.

소개 : 응답 체인 호출의 도전

프로젝트 원자로를 기반으로 한 응답 형 프로그래밍에서, 우리는 종종 일련의 비동기 작업이 필요한 시나리오를 만나고, 한 작업의 결과는 다음 작업의 입력입니다. 예를 들어, 먼저 주문을 쿼리 한 다음 순서 (예 : Truckid)의 ID를 기반으로 해당 트럭 정보를 쿼리해야 할 수도 있습니다. 이 경우 키는 메인 스레드를 차단하지 않고 첫 번째 모노 결과에서 필요한 필드를 우아하게 추출하여 두 번째 모노의 생성 기능으로 전달하는 방법입니다. Block () 메소드를 직접 사용하여 값을 얻을 수 있지만, 이는 응답 형 프로그래밍의 비 차단 원리를 위반하고 성능 병목 현상 및 확장 성 문제로 이어질 것입니다.

시나리오 설명 : 주문에서 트럭 정보를 얻습니다

우리가 두 가지 서비스 방법이 있다고 가정합니다.

 // 주문 서비스, id mono <sord> order = orderservice.getByid (uuid id)를 기반으로 순서를 얻습니다.

// 차량 서비스, 트럭 mono <cruck> truck = Vehicleservice.getBytruckid (uuid truckid);</cruck></sord>

주문 클래스는 다음과 같이 정의되며 트럭 필드가 포함되어 있습니다.

 클래스 주문 {
    개인 UUID ID;
    개인 문자열 이름;
    개인 uuid truckid; // 추출 해야하는 필드 // ... 기타 필드 및 방법}

우리의 목표는 다음과 같습니다. 먼저 주문 객체를 얻은 다음이 주문 객체에서 트럭을 추출한 다음 마지막 으로이 트럭을 사용하여 VehicleserVice.getBytruckid () 메소드를 호출하십시오. 전체 프로세스는 차단이 없어야합니다.

솔루션 1 : 순차적 의존성 작업에는 FlatMap을 사용하십시오

FlatMap은 후속 비동기 작업이 이전 모노의 성공적인 결과에 전적으로 의존 할 때 이상적이며 최종 작업의 출력에만 관심이 있습니다. FlatMap 연산자는 mono 를 모노 로 변환합니다. 여기서 r은 T의 값에 따라 생성됩니다.

작업 원칙 : FlatMap은 매개 변수로 함수를 수신합니다. 이 함수의 입력은 이전 모노 (즉, 주문 객체)에 의해 방출 된 요소이며 출력은 새로운 모노 (즉, 모노 )입니다. 이전 모노가 그 값을 내면 FlatMap 은이 기능을 호출하고 새로 생성 된 모노를 구독합니다. 마지막으로, 플랫 맵 연산자는이 새로운 모노의 결과를 방출합니다.

샘플 코드 :

 import Reactor.core.publisher.mono;
java.util.uuid import;

// 주문 및 트럭 클래스 및 서비스 인터페이스 클래스 주문 {
    개인 UUID ID;
    개인 문자열 이름;
    개인 uuid truckid;

    공공 주문 (uuid id, 문자열 이름, uuid truckid) {
        this.id = id;
        this.name = 이름;
        this.truckid = truckid;
    }

    public uuid gettruckid () {
        반환 트럭;
    }
    // ... getters, setters
}

클래스 트럭 {
    개인 UUID ID;
    개인 문자열 모델;

    공개 트럭 (UUID ID, 문자열 모델) {
        this.id = id;
        this.model = 모델;
    }

    @보수
    공개 문자열 tostring () {
        "트럭 {id ="id ", model = '"model "'}"을 반환합니다.
    }
    // ... getters, setters
}

인터페이스 Orderservice {
    mono <order> getbyid (uuid id);
}

인터페이스 VEHICLESERVICE {
    모노 <crub> getbytruckid (uuid truckid);
}

공개 클래스 ReactiveHainingExample {

    개인 최종 Orderservice Orderservice;
    개인 최종 차량 서비스 차량 서비스;

    Public ReactiveChainingExample (Orderservice Orderservice, Vehicleservice Vehicleservice) {
        this.orderservice = Orderservice;
        this.vehicleservice = Vehicleservice;
    }

    /**
     * 주문을받은 후에는 트럭을 기준으로 트럭 정보를 주문* @param Orderid 주문 ID
     * 트럭 정보가 포함 된 @return mono
     */
    Public Mono <cruck> gettruckbyOrderid (uuid OrderId) {
        mono <order> ordermono = Orderservice.getById (OrderId);

        // FlatMap을 사용하여 주문에서 트럭을 추출하고 차량에 전화하여 트럭을 얻습니다.
        mono <cruct> truckmono = Ordermono.flatmap (Order ->
            vehicleservice.getBytruckid (order.gettruckid ())
        );

        Return Truckmono;
    }

    public static void main (String [] args) {
        // Orderservice mockorderservice = id-> mono.just (new Order (id, "test order", uuid.randomuuid ()))를 구현하기위한 서비스 시뮬레이션;
        Vehicleservice mockvehicleservice = truckid-> mono.just (새 트럭 (Truckid, "Volvo fh"));

        ReactiveChainingExample 예 = 새로운 ReactiveHainingExample (Mockorderservice, MockveHicleservice);

        uuid testOrderId = uuid.randomuuid ();
        example.getTruckByOrderID (testOrderId)
                .구독하다(
                        트럭 -> System.out.println ( "성공적으로 얻은 트럭 :"트럭),
                        error-> system.err.println ( "트럭을 얻지 못했습니다 :"error.getMessage ())
                );

        // 메인 스레드가 비동기 조작이 완료 될 때까지 대기하려면 {를 시도하십시오.
            Thread.sleep (1000);
        } catch (InterruptedException e) {
            thread.currentthread (). 인터럽트 ();
        }
    }
}</cruct></order></cruck></crub></order>

위의 코드에서 Ordermono.flatmap (order-> vehicleservice.getBytruckid (order.gettruckid ()))는 Truckid를 Order Object에서 가져 와서 차량으로 전달하는 방법을 명확하게 보여줍니다.

솔루션 2 : Mono.zip을 사용하여 여러 비동기 결과를 집계하십시오

때로는 최종 트럭 정보뿐만 아니라 원래 주문 정보도 필요하거나 여러 비동기 작업 결과가 단일 화합물 결과로 병합되어야합니다. 이 경우 mono.zip 연산자는 매우 유용합니다. mono.zip은 다중 모노를 mono >로 병합 할 수 있습니다.

작동 방식 : Mono.zip은 참여하는 모든 Mono가 자신의 가치를 발급하기를 기다립니다. 모든 모노가 완료되고 값이 방출되면 Mono.zip은 이러한 값을 튜플로 패키지하고 방출합니다. 참여 모노가 실패하면 전체 지퍼 작업도 실패합니다.

샘플 코드 :

 import Reactor.core.publisher.mono;
import reactor.util.function.tuple2; // 튜플을 가져옵니다
java.util.uuid import;

// ... Order, Truck, Orderservice, Vehicleservice 클래스 정의는 위와 동일합니다. // 순서 및 트럭을 캡슐화하기위한 결과 클래스를 정의합니다.
클래스 OrderTruckresult {
    개인 주문 명령;
    개인 트럭 트럭;

    Public OrderTruckresult (주문, 트럭 트럭) {
        this.order = 순서;
        this.truck = 트럭;
    }

    공공 주문 getOrder () {
        반환 명령;
    }

    공개 트럭 GetTruck () {
        반환 트럭;
    }

    @보수
    공개 문자열 tostring () {
        "OrderTruckresult {order ="order.id ", truck ="truck.model "}을 반환합니다.
    }
}

공개 클래스 ReactiveAggegationExample {

    개인 최종 Orderservice Orderservice;
    개인 최종 차량 서비스 차량 서비스;

    Public ReactiveAggregationExample (Orderservice Orderservice, Vehicleservice Vehicleservice) {
        this.orderservice = Orderservice;
        this.vehicleservice = Vehicleservice;
    }

    /**
     * 주문 및 해당 트럭 정보를 가져 와서 결과 개체로 집계하십시오* @param OrderId 주문 ID
     * 주문 및 트럭 정보가 포함 된 @return mono
     */
    퍼블릭 모노 <ordertruckresult> getOrderAndtruck (uuid OrderId) {
        mono <order> ordermono = Orderservice.getById (OrderId);

        // 주요 단계 : FlatMap을 사용하여 OrderMono에서 Truckid를 추출하고 Truckmono를 만듭니다.
        mono <cruct> truckmono = Ordermono.flatmap (Order ->
            vehicleservice.getBytruckid (order.gettruckid ())
        );

        // mono.zip // 참고를 사용하여 원래 Ordermono와 새로 만든 Truckmono를 집계하십시오.
        // OrderMono의 구독이 트리거되고 결과는 Truckmono를 만드는 데 사용됩니다.
        // 마지막으로, 두 모노에 결과가있을 때 Zip은 결합합니다.
        mono <ordertruckresult> resultmono = mono.zip (Ordermono, truckmono)
                .flatmap (tuple-> {
                    주문 순서 = tuple.gett1 (); // 주문을받습니다
                    트럭 트럭 = tuple.gett2 (); // 트럭을 얻습니다
                    return mono.just (New OrderTruckresult (주문, 트럭));
                });

        Return resultmono;
    }

    public static void main (String [] args) {
        // Simulation Service 구현 Orderservice MockorderService = id-> mono.just (new Order (id, "test order"id.toString (). substring (0,4), uuid.randomuuid ()));
        Vehicleservice mockvehicleservice = truckid-> mono.just (새 트럭 (Truckid, "model-"truckid.tostring (). substring (0,4)));

        ReactiveAgggeationExample Example = 새로운 ReactiveAgggregationExample (MockorderService, MockveHicleservice);

        uuid testOrderId = uuid.randomuuid ();
        example.getorderAndtruck (testOrderId)
                .구독하다(
                        결과 -> System.out.println ( "성공적으로 주문 및 트럭 :"결과),
                        error-> system.err.println ( "주문 및 트럭을 얻지 못했습니다 :"error.getMessage ())
                );

        노력하다 {
            Thread.sleep (1000);
        } catch (InterruptedException e) {
            thread.currentthread (). 인터럽트 ();
        }
    }
}</ordertruckresult></cruct></order></ordertruckresult>

이 예에서는 먼저 FlatMap을 사용하여 OrderMono에서 Truckid를 얻고 Truckmono를 만듭니다. 그런 다음 Mono.zip (Ordermono, Truckmono)을 사용하여 원래 Ordermono와 새로 생성 된 Truckmono의 결과를 병합합니다. Zip 작업은 Mono가 성공적으로 완료되기를 기다린 다음 결과를 Tuple2로 캡슐화합니다. 마지막으로, 우리는 다시 한 번 FlatMap을 사용하여 tuple2를 사용자 정의 OrderTruckresult 객체로 변환하여 더 읽기 쉬운 유형 안전을 만듭니다.

메모 및 모범 사례

1. 차단 작업을 피하십시오 : 항상 반응 체인에서 블록 () 메소드를 사용하지 마십시오. Block ()는 응답 형 스트림을 차단 호출로 변환하여 응답 형 프로그래밍의 장점을 잃게됩니다.
2. 올바른 연산자 선택 :
   • 비동기 작업의 결과가 다음 비동기 작업에 입력되면 FlatMap을 사용하십시오.
   • mono.zip (또는 flux.zip)은 병렬에서 상호 의존적이지 않은 다중 비동기 작업이 결과를 집계 할 때 사용됩니다.
   • 다중 비동기 연산을 병렬로 수행해야하지만 첫 번째 완료된 결과에만 적용되는 경우 mono.first ()를 사용하십시오.
3. 사용자 정의 결과 캡슐화 : 여러 비동기 연산에서 집계 된 결과가 집계 된 경우 튜플을 직접 사용하는 대신 이러한 결과를 캡슐화하기 위해 전용 POJO (예 : OrderTruckresult)를 정의하면 코드의 가독성 및 유형 안전성을 향상시킬 수 있습니다.
4. 오류 처리 : 실제 애플리케이션에서는 onerrorresume, onerrorreturn 또는 doonerror 사용과 같은 각 모노 체인에 오류 처리 로직을 추가하십시오.
5. 뜨거운 흐름 이해 : 모노와 플럭스는 기본적으로 냉간 흐름이며 구독 할 때만 실행됩니다. Mono.zip 시나리오에서는 모든 참여 모노가 구독됩니다.

요약

원자로 반응 형 프로그래밍에서, 모노의 결과에서 필드를 추출하여 후속 비동기 작업으로 전달하는 것이 일반적인 요구 사항입니다. 두 핵심 연산자 FlatMap 및 Mono.zip을 유연하게 사용하여 효율적이고 비 블로킹 및 잘 구조화 된 비동기 데이터 처리 파이프 라인을 구축 할 수 있습니다. FlatMap은 순차적으로 종속 체인 호출에 적합하지만 mono.zip은 여러 비동기 작업의 결과를 집계하는 데 능숙합니다. 이러한 패턴을 마스터하는 것은 강력하고 확장 가능하며 반응이 좋은 응용 프로그램을 작성하는 데 중요합니다.

위 내용은 원자로 모노 비동기 체인 호출 : 모노 결과에서 필드를 가져 와서 통과의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!