响应式编程：在Mono数据流中进行字段提取、非阻塞链式调用与数据聚合

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

// 订单实体类
class Order {
    private UUID id;
    private String name;
    private UUID truckId; // 包含卡车ID

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

    public UUID getId() { return id; }
    public String getName() { return name; }
    public UUID getTruckId() { return truckId; }

    @Override
    public String toString() {
        return "Order{" + "id=" + id + ", name='" + name + '\'' + ", truckId=" + truckId + '}';
    }
}

// 卡车实体类
class Truck {
    private UUID id;
    private String model;
    private int capacity;

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

    public UUID getId() { return id; }
    public String getModel() { return model; }
    public int getCapacity() { return capacity; }

    @Override
    public String toString() {
        return "Truck{" + "id=" + id + ", model='" + model + '\'' + ", capacity=" + capacity + '}';
    }
}

// 模拟订单服务接口
interface OrderService {
    Mono<Order> getById(UUID id);
}

// 模拟车辆服务接口
interface VehicleService {
    Mono<Truck> getByTruckId(UUID truckId);
}

// 模拟服务实现（为了示例简化，实际中可能是数据库或远程调用）
class MockOrderService implements OrderService {
    @Override
    public Mono<Order> getById(UUID id) {
        // 模拟异步操作
        return Mono.just(new Order(id, "Customer Order " + id.toString().substring(0, 4), UUID.randomUUID()))
                   .delayElement(java.time.Duration.ofMillis(100));
    }
}

class MockVehicleService implements VehicleService {
    @Override
    public Mono<Truck> getByTruckId(UUID truckId) {
        // 模拟异步操作
        return Mono.just(new Truck(truckId, "Volvo FH" + truckId.toString().substring(0, 2), 20000))
                   .delayElement(java.time.Duration.ofMillis(150));
    }
}

public class ReactiveChainingExample {

    private final OrderService orderService = new MockOrderService();
    private final VehicleService vehicleService = new MockVehicleService();

    public Mono<Truck> getTruckForOrder(UUID orderId) {
        Mono<Order> orderMono = orderService.getById(orderId);

        // 使用 flatMap 从 Mono<Order> 中提取 truckId，并用它来获取 Mono<Truck>
        Mono<Truck> truckMono = orderMono.flatMap(order -> {
            System.out.println("从订单中获取到 truckId: " + order.getTruckId());
            return vehicleService.getByTruckId(order.getTruckId());
        });
        return truckMono;
    }

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

        System.out.println("开始获取订单关联的卡车信息...");
        example.getTruckForOrder(testOrderId)
               .subscribe(
                   truck -> System.out.println("成功获取到卡车信息: " + truck),
                   error -> System.err.println("获取卡车信息失败: " + error.getMessage()),
                   () -> System.out.println("获取卡车信息流完成。")
               );

        // 保持主线程活跃，以便观察异步输出
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 聚合结果类
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 + ", truck=" + truck + '}';
    }
}

import reactor.core.publisher.Mono;
import reactor.util.function.Tuple2; // Mono.zip返回Tuple2
import java.util.UUID;

public class ReactiveAggregationExample {

    private final OrderService orderService = new MockOrderService();
    private final VehicleService vehicleService = new MockVehicleService();

    public Mono<OrderTruckResult> getOrderAndTruck(UUID orderId) {
        Mono<Order> orderMono = orderService.getById(orderId);

        // 使用 flatMap 从 orderMono 中提取 truckId，并获取 Mono<Truck>
        // 注意：这里 orderMono 和 truckMono 实际上是依赖关系，
        // 但为了演示 zip 的聚合，我们将 orderMono 保持独立，
        // 并在 zip 之前确保 truckMono 已经依赖 orderMono 建立。
        Mono<Truck> truckMono = orderMono.flatMap(order -> {
            System.out.println("聚合流程：从订单中获取到 truckId: " + order.getTruckId());
            return vehicleService.getByTruckId(order.getTruckId());
        });

        // 使用 Mono.zip 聚合 orderMono 和 truckMono
        // zip 会等待两个 Mono 都发出数据，然后将它们组合成一个 Tuple2
        Mono<OrderTruckResult> resultMono = Mono.zip(orderMono, truckMono)
                .flatMap(tuple -> {
                    Order order = tuple.getT1(); // 获取第一个Mono的结果
                    Truck truck = tuple.getT2(); // 获取第二个Mono的结果
                    return Mono.just(new OrderTruckResult(order, truck));
                });

        return resultMono;
    }

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

        System.out.println("开始聚合订单和卡车信息...");
        example.getOrderAndTruck(testOrderId)
               .subscribe(
                   result -> System.out.println("成功聚合信息: " + result),
                   error -> System.err.println("聚合信息失败: " + error.getMessage()),
                   () -> System.out.println("聚合信息流完成。")
               );

        // 保持主线程活跃
        try {
            Thread.sleep(700); // 确保所有异步操作完成
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}