Reactor Mono异步链式调用：从一个Mono结果中获取字段并传递

// 订单服务，根据ID获取订单
Mono<Order> order = orderService.getById(UUID id);

// 车辆服务，根据卡车ID获取卡车
Mono<Truck> truck = vehicleService.getByTruckId(UUID truckId);

class Order {
    private UUID id;
    private String name;
    private UUID truckId; // 我们需要提取的字段
    // ... 其他字段和方法
}

import reactor.core.publisher.Mono;
import java.util.UUID;

// 假设的Order和Truck类以及服务接口
class Order {
    private UUID id;
    private String name;
    private UUID truckId;

    public Order(UUID id, String name, UUID truckId) {
        this.id = id;
        this.name = name;
        this.truckId = truckId;
    }

    public UUID getTruckId() {
        return truckId;
    }
    // ... getters, setters
}

class Truck {
    private UUID id;
    private String model;

    public Truck(UUID id, String model) {
        this.id = id;
        this.model = model;
    }

    @Override
    public String toString() {
        return "Truck{id=" + id + ", model='" + model + "'}";
    }
    // ... getters, setters
}

interface OrderService {
    Mono<Order> getById(UUID id);
}

interface VehicleService {
    Mono<Truck> getByTruckId(UUID truckId);
}

public class ReactiveChainingExample {

    private final OrderService orderService;
    private final VehicleService vehicleService;

    public ReactiveChainingExample(OrderService orderService, VehicleService vehicleService) {
        this.orderService = orderService;
        this.vehicleService = vehicleService;
    }

    /**
     * 获取订单后，根据订单中的truckId获取卡车信息
     * @param orderId 订单ID
     * @return 包含卡车信息的Mono
     */
    public Mono<Truck> getTruckByOrderId(UUID orderId) {
        Mono<Order> orderMono = orderService.getById(orderId);

        // 使用flatMap从Order中提取truckId，并调用vehicleService获取Truck
        Mono<Truck> 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(new Truck(truckId, "Volvo FH"));

        ReactiveChainingExample example = new ReactiveChainingExample(mockOrderService, mockVehicleService);

        UUID testOrderId = UUID.randomUUID();
        example.getTruckByOrderId(testOrderId)
                .subscribe(
                        truck -> System.out.println("成功获取卡车: " + truck),
                        error -> System.err.println("获取卡车失败: " + error.getMessage())
                );

        // 为了让main线程等待异步操作完成，实际应用中通常不需要
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

import reactor.core.publisher.Mono;
import reactor.util.function.Tuple2; // 导入Tuple2
import java.util.UUID;

// ... Order, Truck, OrderService, VehicleService 类定义同上

// 定义一个结果类来封装Order和Truck
class OrderTruckResult {
    private Order order;
    private Truck truck;

    public OrderTruckResult(Order order, Truck truck) {
        this.order = order;
        this.truck = truck;
    }

    public Order getOrder() {
        return order;
    }

    public Truck getTruck() {
        return truck;
    }

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

public class ReactiveAggregationExample {

    private final OrderService orderService;
    private final VehicleService vehicleService;

    public ReactiveAggregationExample(OrderService orderService, VehicleService vehicleService) {
        this.orderService = orderService;
        this.vehicleService = vehicleService;
    }

    /**
     * 获取订单和对应的卡车信息，并聚合为一个结果对象
     * @param orderId 订单ID
     * @return 包含Order和Truck信息的Mono
     */
    public Mono<OrderTruckResult> getOrderAndTruck(UUID orderId) {
        Mono<Order> orderMono = orderService.getById(orderId);

        // 关键步骤：使用flatMap从orderMono中提取truckId，创建truckMono
        Mono<Truck> truckMono = orderMono.flatMap(order ->
            vehicleService.getByTruckId(order.getTruckId())
        );

        // 使用Mono.zip将原始的orderMono和新创建的truckMono聚合
        // 注意：这里我们zip的是原始的orderMono和依赖于它的truckMono。
        // orderMono的订阅会触发，然后其结果会用于创建truckMono，
        // 最终当两个Mono都有结果时，zip会组合它们。
        Mono<OrderTruckResult> resultMono = Mono.zip(orderMono, truckMono)
                .flatMap(tuple -> {
                    Order order = tuple.getT1(); // 获取Order
                    Truck truck = tuple.getT2(); // 获取Truck
                    return Mono.just(new OrderTruckResult(order, truck));
                });

        return resultMono;
    }

    public static void main(String[] args) {
        // 模拟服务实现
        OrderService mockOrderService = id -> Mono.just(new Order(id, "Test Order " + id.toString().substring(0,4), UUID.randomUUID()));
        VehicleService mockVehicleService = truckId -> Mono.just(new Truck(truckId, "Model-" + truckId.toString().substring(0,4)));

        ReactiveAggregationExample example = new ReactiveAggregationExample(mockOrderService, mockVehicleService);

        UUID testOrderId = UUID.randomUUID();
        example.getOrderAndTruck(testOrderId)
                .subscribe(
                        result -> System.out.println("成功获取订单和卡车: " + result),
                        error -> System.err.println("获取订单和卡车失败: " + error.getMessage())
                );

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}