// 消费端配置集群容错策略
@DubboReference(
    cluster = "failfast",    // 写操作——不重试
    retries = 0              // 即使 Failover 模式，也可以设 retries=0 关掉重试
)
private OrderService orderService;

// 需求：创建订单——只能成功一次
@DubboReference(
    cluster = "failover",  // 默认——危险！
    retries = 2            // 默认——更危险！
)
private OrderService orderService;

// 调用 createOrder(10001, "iPhone", 6999)
// 场景：Provider-A 处理成功但 Consumer 超时
//   → Consumer 认为失败 → 重试到 Provider-B
//   → Provider-B 又创建了一次 → 同一个订单创建了两条！

// 非幂等写操作——必须关掉重试
@DubboReference(
    cluster = "failfast",  // 失败立即报错——不重试
    retries = 0
)
private OrderService orderService;

// 数据同步——必须最终一致但不要求实时
// 场景：订单创建后异步同步到数据仓库
@DubboReference(
    cluster = "failback",
    retries = 5,           // 后台重试 5 次
    timeout = 1000          // 每次调用 1s 超时
)
private DataWarehouseSyncService syncService;

# yml 中全局配置
dubbo:
  consumer:
    loadbalance: leastactive  # 全局默认

// 注解中局部覆盖
@DubboReference(loadbalance = "consistenthash")
private OrderService orderService;

# Provider 端——这台机器配置高，权重设大
dubbo:
  provider:
    weight: 200    # 默认 100——这台机器分 2 倍流量

// 场景：订单服务缓存了部分数据——同一个 orderId 永远路由到同一个 Provider
@DubboReference(
    loadbalance = "consistenthash",
    parameters = {"hash.arguments", "long[]"}  // 按 orderId 参数哈希
)
private OrderService orderService;

@DubboReference(loadbalance = "p2c")
private OrderService orderService;  // Dubbo 3.2+

// Provider——南方机房
@DubboService(group = "south")
public class OrderServiceImpl implements OrderService { ... }

// Provider——北方机房
@DubboService(group = "north")
public class OrderServiceImpl implements OrderService { ... }

// Consumer——南方用户
@DubboReference(group = "south")
private OrderService orderService;

// Provider V1——老版本（稳定）
@DubboService(version = "1.0.0")
public class OrderServiceV1Impl implements OrderService {
    // 老方法：只返回订单基本信息
    public Order getOrderById(Long orderId) { ... }
}

// Provider V2——新版本（灰度）
@DubboService(version = "2.0.0")
public class OrderServiceV2Impl implements OrderService {
    // 新方法：返回订单 + 关联物流信息
    public Order getOrderById(Long orderId) {
        Order order = ...;
        order.setLogistics(logisticsService.getByOrderId(orderId)); // 新功能
        return order;
    }
}

// Consumer——灰度用户（逐渐从 V1 切到 V2）
@DubboReference(version = "2.0.0")  // 切到 V2
private OrderService orderService;

// 接口定义——返回 CompletableFuture
public interface OrderService {
    CompletableFuture<Order> getOrderById(Long orderId);
}

// Provider 实现——和同步方法一样写
@DubboService
public class OrderServiceImpl implements OrderService {
    @Override
    public CompletableFuture<Order> getOrderById(Long orderId) {
        // Dubbo 自动把返回值包装成 CompletableFuture
        return CompletableFuture.completedFuture(
                orderDB.get(orderId));
    }
}

// Consumer 调用——组合多个 RPC 调用
@RestController
public class OrderController {

    @DubboReference
    private OrderService orderService;    // 异步接口

    @DubboReference
    private LogisticsService logisticsService;  // 另一个异步接口

    @GetMapping("/order-detail/{orderId}")
    public CompletableFuture<OrderDetail> getOrderDetail(@PathVariable Long orderId) {
        // 同时发起两个 RPC 调用——不阻塞
        CompletableFuture<Order> orderFuture = orderService.getOrderById(orderId);
        CompletableFuture<Logistics> logisticsFuture = logisticsService.getByOrderId(orderId);

        // 组合两个结果——等两个都返回后才处理
        return orderFuture.thenCombine(logisticsFuture, (order, logistics) -> {
            OrderDetail detail = new OrderDetail();
            detail.setOrder(order);
            detail.setLogistics(logistics);
            return detail;
        });
    }
}

// 接口定义——仍然是同步签名
public interface OrderService {
    Order getOrderById(Long orderId);  // 注意：返回类型是 Order，不是 CompletableFuture
}

// Consumer——不改接口，通过 async=true 异步调用
@DubboReference(async = true)
private OrderService orderService;

public void processOrder() {
    // 发起调用——此时不阻塞
    Order order = orderService.getOrderById(10001L);
    // 注意：此时 order 为 null！因为 async=true，调用立即返回

    // 获取真正的结果——阻塞等待
    CompletableFuture<Order> future =
            RpcContext.getServiceContext().getCompletableFuture();
    Order realOrder = future.join();  // 阻塞直到拿到结果
}

// API 模块——在接口上声明约束
public interface OrderService {

    Order getOrderById(
        @NotNull(message = "orderId 不能为空")
        @Min(value = 1, message = "orderId 必须大于 0")
        Long orderId
    );

    Order createOrder(
        @NotNull(message = "userId 不能为空") Long userId,
        @NotBlank(message = "商品名不能为空") String productName,
        @NotNull(message = "金额不能为空")
        @DecimalMin(value = "0.01", message = "金额必须大于 0")
        BigDecimal amount
    );
}

// Provider 实现——不用改任何代码
@DubboService(validation = "true")  // ← 开启参数校验
public class OrderServiceImpl implements OrderService {
    // 实现不变——Dubbo 在方法执行前自动校验参数
}

// 子模块需要加依赖
// <dependency>
//     <groupId>jakarta.validation</groupId>
//     <artifactId>jakarta.validation-api</artifactId>
// </dependency>
// <dependency>
//     <groupId>org.hibernate.validator</groupId>
//     <artifactId>hibernate-validator</artifactId>
// </dependency>

// 场景：Consumer 在 RPC 调用前做一些本地预处理
// 如——记录日志、校验参数、降级兜底

// 本地存根——实现了和远程服务相同的接口
public class OrderServiceStub implements OrderService {

    private final OrderService orderService;  // Dubbo 自动注入远程代理

    public OrderServiceStub(OrderService orderService) {
        this.orderService = orderService;  // 构造器注入——Dubbo 的要求
    }

    @Override
    public Order getOrderById(Long orderId) {
        // RPC 调用前的本地预处理
        if (orderId == null || orderId <= 0) {
            throw new IllegalArgumentException("orderId 不合法: " + orderId);
        }
        System.out.printf("[Stub] 即将远程调用: getOrderById(%d)%n", orderId);

        try {
            return orderService.getOrderById(orderId);  // 真正的 RPC 调用
        } catch (Exception e) {
            // 降级兜底
            System.err.println("[Stub] RPC 调用失败，返回降级数据");
            return new Order(orderId, "UNKNOWN", BigDecimal.ZERO);
        }
    }
}

// Consumer 端——指定本地存根
@DubboReference(stub = "org.example.consumer.OrderServiceStub")
private OrderService orderService;