Reactor链式操作：从Mono中提取数据并进行服务编排

public class Order {
    private UUID id;
    private String name;
    private UUID truckId; // 我们需要提取的字段

    // 构造函数、Getter/Setter略
    public UUID getTruckId() {
        return truckId;
    }
}

public class Truck {
    private UUID id;
    private String model;

    // 构造函数、Getter/Setter略
}

// 假设的服务接口
interface OrderService {
    Mono<Order> getById(UUID id);
}

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

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

public class ReactiveDataExtraction {

    private OrderService orderService; // 假设已注入
    private VehicleService vehicleService; // 假设已注入

    // 模拟服务方法
    private Mono<Order> getById(UUID id) {
        // 实际应用中会调用orderService.getById(id)
        return Mono.just(new Order(id, "Test Order", UUID.randomUUID()));
    }

    private Mono<Truck> getByTruckId(UUID truckId) {
        // 实际应用中会调用vehicleService.getByTruckId(truckId)
        return Mono.just(new Truck(truckId, "Volvo FH"));
    }

    public Mono<Truck> getTruckFromOrder(UUID orderId) {
        Mono<Order> orderMono = getById(orderId);

        // 使用flatMap从Mono<Order>中提取truckId并调用getByTruckId
        Mono<Truck> truckMono = orderMono.flatMap(order -> getByTruckId(order.getTruckId()));

        return truckMono;
    }

    public static void main(String[] args) {
        ReactiveDataExtraction example = new ReactiveDataExtraction();
        UUID testOrderId = UUID.randomUUID();

        example.getTruckFromOrder(testOrderId)
                .subscribe(
                        truck -> System.out.println("成功获取到卡车信息: " + truck.getModel()),
                        error -> System.err.println("获取卡车信息失败: " + error.getMessage())
                );

        // 为了演示非阻塞，通常需要等待异步操作完成
        try {
            Thread.sleep(1000); // 实际应用中不会这样阻塞
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

public class Result {
    private Order order;
    private Truck truck;

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

    // Getter/Setter略
    @Override
    public String toString() {
        return "Result{" +
               "orderId=" + (order != null ? order.getId() : "null") +
               ", orderName='" + (order != null ? order.getName() : "null") + '\'' +
               ", truckId=" + (truck != null ? truck.getId() : "null") +
               ", truckModel='" + (truck != null ? truck.getModel() : "null") + '\'' +
               '}';
    }
}

import reactor.core.publisher.Mono;
import reactor.util.function.Tuple2; // 用于Mono.zip的默认输出
import java.util.UUID;

public class ReactiveDataAggregation {

    private OrderService orderService; // 假设已注入
    private VehicleService vehicleService; // 假设已注入

    // 模拟服务方法
    private Mono<Order> getById(UUID id) {
        return Mono.just(new Order(id, "Test Order " + id.toString().substring(0,4), UUID.randomUUID()));
    }

    private Mono<Truck> getByTruckId(UUID truckId) {
        return Mono.just(new Truck(truckId, "Model-" + truckId.toString().substring(0,4)));
    }

    public Mono<Result> getOrderAndTruck(UUID orderId) {
        Mono<Order> orderMono = getById(orderId);

        // 1. 从orderMono派生出truckMono
        // 注意：这里truckMono的生成依赖于orderMono，它们是串行的
        Mono<Truck> truckMono = orderMono.flatMap(order -> getByTruckId(order.getTruckId()));

        // 2. 使用Mono.zip组合原始的orderMono和派生出的truckMono
        // Mono.zip会等待两个Mono都发出值后，将它们组合成一个Tuple2
        // 这里需要注意，如果orderMono和truckMono是独立的，zip会并行处理。
        // 但由于truckMono的创建依赖于orderMono，这里的zip实际上会在orderMono发出值后，
        // 再等待truckMono发出值。
        Mono<Tuple2<Order, Truck>> zippedMono = Mono.zip(orderMono, truckMono);

        // 3. 使用flatMap将Tuple2映射为自定义的Result对象
        Mono<Result> resultMono = zippedMono.flatMap(tuple ->
                Mono.just(new Result(tuple.getT1(), tuple.getT2()))
        );

        return resultMono;
    }

    public static void main(String[] args) {
        ReactiveDataAggregation example = new ReactiveDataAggregation();
        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();
        }
    }
}