// chain-cloud-ms-oms-service OrderServiceImpl#noticeOrderStatusChange
this.mqFeign.sendMsg(
    Constants.MQ.Exchanges.ORDER_DELAYED,        // cc.exchange.topic.order.delayed
    Constants.MQ.RoutingKeys.ORDER_CREATE,       // CREATE
    orderMsg.toJson(),
    Constants.MQ.LOW_DELAY);                     // 5000ms = 5 秒

维度 1：服务范围   —— 这个快递员的多边形覆盖这个地址吗？（service-scope，type=2）
维度 2：排班       —— 今天这个时段他在班吗？（base 服务的排班表）

// chain-cloud-ms-api CourierFeign
@FeignClient(name = "chain-cloud-ms-courier", contextId = "Courier", path = "/couriers")

@GetMapping("{agencyId}/{longitude}/{latitude}")
List<Long> queryCourierIdListByCondition(
        @PathVariable("agencyId") Long agencyId,
        @PathVariable("longitude") Double longitude,
        @PathVariable("latitude")  Double latitude,
        @RequestParam("estimatedEndTime") Long estimatedEndTime);

// chain-cloud-ms-dispatch-service OrderMQListener#listenOrderMsg
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = Constants.MQ.Queues.DISPATCH_ORDER_TO_PICKUP_DISPATCH_TASK),
        exchange = @Exchange(name = Constants.MQ.Exchanges.ORDER_DELAYED,
                             type = ExchangeTypes.TOPIC, delayed = Constants.MQ.DELAYED),
        key = Constants.MQ.RoutingKeys.ORDER_CREATE))
public void listenOrderMsg(String msg) {
    //{"orderId":123,"agencyId":8001,"taskType":1,"mark":"带包装",
    // "longitude":116.111,"latitude":39.00,"estimatedEndTime":1654224658728}

    // 1. 解析消息
    var orderMsg = JSONUtil.toBean(msg, OrderMsg.class);
    var agencyId     = orderMsg.getAgencyId();
    var longitude    = orderMsg.getLongitude();
    var latitude     = orderMsg.getLatitude();
    var epochMilli   = LocalDateTimeUtil.toEpochMilli(orderMsg.getEstimatedEndTime());

    // 2. 查有排班、符合服务范围的快递员，并选择快递员
    var courierIds = this.courierFeign
            .queryCourierIdListByCondition(agencyId, longitude, latitude, epochMilli);
    Long selectedCourierId = null;
    if (CollUtil.isNotEmpty(courierIds)) {
        selectedCourierId = this.selectCourierByAI(
                courierIds, orderMsg.getTaskType(), longitude, latitude);
    }

    // 3. 决定实时发送还是延迟发送
    //    假设现在 10:30，用户期望上门 13:00~14:00
    var diffMinutes = LocalDateTimeUtil.between(
            LocalDateTimeUtil.now(), orderMsg.getEstimatedEndTime(), ChronoUnit.MINUTES);
    var dispatchConfiguration = this.dispatchConfigurationFeign.findConfiguration();
    var dispatchTime = dispatchConfiguration.getDispatchTime() * 60;   // 小时 → 分钟
    var delay = Constants.MQ.DEFAULT_DELAY;                             // -1 = 立即
    if (ObjectUtil.equals(orderMsg.getTaskType(), PickupDispatchTaskTypeEnum.PICKUP.getCode())
            && diffMinutes > dispatchTime) {
        // 延迟消息：13:00 向前推 dispatchTime 小时，得 11:00
        var date = LocalDateTimeUtil.offset(orderMsg.getEstimatedEndTime(),
                dispatchTime * -1L, ChronoUnit.MINUTES);
        delay = Convert.toInt(LocalDateTimeUtil.between(
                LocalDateTimeUtil.now(), date, ChronoUnit.MILLIS));
    }

    // 4. 发消息通知 work 服务创建取派件任务
    var courierTaskMsg = BeanUtil.toBeanIgnoreError(orderMsg, CourierTaskMsg.class);
    courierTaskMsg.setCourierId(selectedCourierId);
    courierTaskMsg.setCreated(System.currentTimeMillis());

    this.mqFeign.sendMsg(Constants.MQ.Exchanges.PICKUP_DISPATCH_TASK_DELAYED,
            Constants.MQ.RoutingKeys.PICKUP_DISPATCH_TASK_CREATE,
            courierTaskMsg.toJson(), delay);
}

剩余时间（now → 用户期望上门时间）
  ├─ ≤ dispatchTime（默认 2 小时）  →  立刻推（DEFAULT_DELAY = -1）
  └─ >  dispatchTime                →  延迟推，推送时刻 = 期望上门时间 − dispatchTime

// 方案 1：Redis 幂等标记（最轻，防 90% 的重复投递）
String idempotentKey = "DISPATCH_IDEMPOTENT_" + orderMsg.getOrderId() + "_" + taskType;
RLock lock = redissonClient.getFairLock(idempotentKey);
try {
    if (lock.tryLock()) {
        // 二次确认：查 work 服务是否已经为这个订单建过任务
        var exists = pickupDispatchTaskFeign.findByOrderId(
                orderMsg.getOrderId(), taskType);
        if (CollUtil.isNotEmpty(exists)) {
            log.info("订单 {} 的取件任务已存在，跳过", orderMsg.getOrderId());
            return;
        }
        // ... 正常调度
    }
} finally { lock.unlock(); }

// 方案 2：业务表唯一索引（最可靠，治本）
// cc_pickup_dispatch_task 上加唯一索引
//   uk_order_task (order_id, task_type)
// 依赖数据库做最终防线，即使幂等标记失效也不会产生脏数据
// 注意：Seata 场景下唯一索引冲突要能识别为"重复请求"而不是"系统异常"

// 方案 3：消息去重表（通用中间件方案）
// 建一张 cc_msg_consume_log(msg_id 唯一, consumer, created)
// 消费前 INSERT，消费成功后 UPDATE 状态
// 重投时 INSERT 冲突 → 识别为重复消费 → 直接 ack

private Long selectCourierByAI(List<Long> courierIds, Integer taskType,
                               Double longitude, Double latitude)

第一层（规则，绝对硬约束）：有没有排班？覆不覆盖这个地址？   ← courier 服务
        ↓ 候选集
第二层（规则，硬约束）：今天已经接了几单？会不会超时？        ← 应该加在这里
        ↓ 候选集
第三层（AI，软决策）：距离、负载均衡、历史准时率              ← 只能在这一层

// chain-cloud-ms-dispatch-service ml/model/FeatureSnapshot.java
public class FeatureSnapshot {
    private Double usedWeightRatio;             // 已使用重量比例
    private Double usedVolumeRatio;             // 已使用体积比例
    private Integer orderCount;                 // 已分配订单数量
    private Double avgWeight;                   // 平均订单重量
    private Double stdWeight;                   // 订单重量标准差
    private Double maxOrderWeightRatio;         // 最大订单占比
    private Integer skippedOrderCount;          // 被跳过的订单数
    private Long remainingOrderCount;           // 剩余未分配订单数
    private Double remainingHighPriorityRatio;  // 剩余高优订单比例
    private Integer rounds;                     // 调度循环轮数
}

private Long selectCourierByAI(List<Long> courierIds, Integer taskType,
                               Double longitude, Double latitude) {
    if (courierIds.size() == 1) {
        return courierIds.get(0);
    }
    // TODO AI智能选择快递员
    return courierIds.get(1);        // ← 永远取 index 1
}

// 止血：至少要公平轮转，不能永远跳过第一个
private Long selectCourier(List<Long> courierIds) {
    if (CollUtil.isEmpty(courierIds)) return null;
    if (courierIds.size() == 1) return courierIds.get(0);

    // 临时方案：Redis 轮转指针，保证公平
    String key = "DISPATCH_ROUND_ROBIN_" + courierIds.get(0);
    Long idx = stringRedisTemplate.opsForValue().get(key);
    long i = (idx == null ? System.currentTimeMillis() : idx) % courierIds.size();
    stringRedisTemplate.opsForValue().set(key, String.valueOf((i + 1) % courierIds.size()));
    return courierIds.get((int) i);
}

# chain-cloud-ms-aigc-service/src/main/resources/bootstrap.yml
feign:
  client:
    config:
      default:
        connect-timeout: 10000        # 10 秒
        read-timeout: 1000000         # 1000 秒 ≈ 16.7 分钟

// web-manager AuthServiceImpl#login
RiskLoginResponse riskLoginResponse = RiskLoginResponse.builder()
        .needCaptcha(false)                      // 默认不弹验证码
        .build();
if (webManagerRisk) {
    riskLoginResponse = aigcFeign.assessLoginRisk(...);   // ← 没有 try-catch
}

// 把开关和异常处理分开
try {
    if (webManagerRisk) {
        riskLoginResponse = aigcFeign.assessLoginRisk(...);
    }
} catch (Exception e) {
    log.error("AI 风控不可用，降级为直接放行", e);
    riskLoginResponse = RiskLoginResponse.builder()
            .needCaptcha(false)      // ← 降级策略：不弹验证码
            .riskLevel(RiskLevel.UNKNOWN)
            .reason("AI_UNAVAILABLE")
            .build();
}

// AgentServerClient
String DEFAULT_SESSION_ID = "1";
String DEFAULT_USER_TOKEN = "DEFAULT_USER_TOKEN";

// RiskControlServiceImpl
ChatRequestDTO chatRequestDTO = ChatRequestDTO.builder()
        .question(question)
        .sessionId(AgentServerClient.DEFAULT_SESSION_ID)     // 永远是 "1"
        .userToken(AgentServerClient.DEFAULT_USER_TOKEN)     // 永远是默认值
        .agentId(riskLoginAgentId)
        .build();

// sessionId 用业务语义标识，而不是魔法数字
.sessionId("risk-login:" + account + ":" + userType)
// userToken 在 Java 侧自签（复用 JwtUtils 的 RSA 私钥），
// 里面带上 调用方服务名 + userId + 过期时间

无状态契约（推荐）：
POST /aigc/risk/login
  → Java 直接传结构化的 riskContext 对象
  → Python 返回 RiskLoginResponse 的 JSON

而不是：
POST /chat  {question: "...把这段拼成的话传给你...", agentId: 1001}
  → Python 自己解析 question 里的自然语言

// DispatchJob
@XxlJob("transportTask")
public void transportTask() {
    //TODO 待实现
}

// TransportOrderDispatchMQListener
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = Constants.MQ.Queues.DISPATCH_MERGE_TRANSPORT_ORDER),
        exchange = @Exchange(name = Constants.MQ.Exchanges.TRANSPORT_ORDER_DELAYED,
                             type = ExchangeTypes.TOPIC, delayed = Constants.MQ.DELAYED),
        key = Constants.MQ.RoutingKeys.JOIN_DISPATCH))
public void listenDispatchMsg(String msg) {
    log.info("接收到新运单的消息 >>> msg = {}", msg);
    // TODO 待实现
}

/**
 * 调度运输任务
 * 核心能力：
 * 1. 使用 Redis ZSet 实现"优先级调度"
 * 2. 支持跳过大单（避免阻塞）
 * 3. 批量拉取减少 Redis IO
 * 4. 无递归，避免栈溢出
 */

// 1. 消息消费：幂等 → AI 评分 → 写入 ZSet
@RabbitListener(/* JOIN_DISPATCH */)
public void listenDispatchMsg(String msg) {
    var dispatchMsg = JSONUtil.toBean(msg, DispatchMsgDTO.class);

    // 幂等：ZSet 本身是去重的（score 相同 member 相同）
    // 用 dispatchDecisionId 做 member，天然幂等
    String member = dispatchMsg.getTransportOrderId();

    // AI 评分（0~1），不可用时降级为规则分
    double aiScore = aigcFeign.assessPriority(dispatchMsg).getScore();

    // 等待时间归一化：等得越久，等待分越高（防止饿死）
    long waitMinutes = (now - dispatchMsg.getCreated()) / 60000;
    double waitScore = Math.min(1.0, waitMinutes / 120.0);   // 2 小时封顶

    // 加权融合
    double score = aiScore * 0.8 + waitScore * 0.2;

    stringRedisTemplate.opsForZSet()
        .add("DISPATCH_QUEUE_" + currentAgencyId + "_" + nextAgencyId, member, score);
}

// 2. XXL-Job 分片广播：每个执行器处理一部分车辆
@XxlJob("transportTask")
public void transportTask() {
    int shardIndex = Math.max(XxlJobHelper.getShardIndex(), 0);
    int shardTotal = Math.max(XxlJobHelper.getShardTotal(), 1);

    // 分布式锁，防止多执行器同时调度同一批运单
    RLock lock = redissonClient.getFairLock("DISPATCH_LOCK_" + vehicleId);
    if (!lock.tryLock()) return;
    try {
        // 批量拉取，减少 Redis IO
        Set<TypedTuple<String>> top = stringRedisTemplate.opsForZSet()
            .reverseRangeWithScores("DISPATCH_QUEUE_xxx", 0, 99);

        // 贪心装载：按优先级从高到低放，装不下就跳过（不中断）
        for (TypedTuple<String> t : top) {
            var order = loadOrder((String) t.getValue());
            if (!truck.canLoad(order)) {
                skippedCount++;        // 跳过大单，避免阻塞后面的小单
                continue;              // ← 关键：不是 break
            }
            truck.load(order);
            recordDecision(truck, order);   // 写 DispatchDecisionRecord
        }
        // 保存决策记录 → 运输完成后回填 label → 喂给 XGBoost
    } finally { lock.unlock(); }
}

过滤：今天有排班 + 覆盖这个地址（硬约束）
排序：当日已接单数少者优先 → 直线距离近者优先

- 派件及时率（最核心）
- 快递员单均里程（选得好不好直接体现在里程上）
- 人均日单量（负载是否均衡）
- 客户投诉率