使用缓存减少工具重复调用

public class AgentSessionContext {
    private final String userId;
    private final String sessionId;

    // ① 差旅政策：政策按城市分层（一线/新一线/其他）而不同，必须以【城市】为键；
    //    工具可能并发执行，用 ConcurrentHashMap 保证线程安全
    private final Map<String, String> travelPolicyByCity = new ConcurrentHashMap<>();

    // ② 用户联系/乘机人信息（JSON）：会话内准静态，但一旦被 update 就必须失效
    private volatile String userContactInfo;

    // ③ 用户常驻/办公城市（JSON）：会话内【无写入口】，可安全长缓存
    private volatile String userBaseLocation;

    public String getTravelPolicy(String city) {      // city 为 null 直接返回 null（不走缓存）
        return city != null ? travelPolicyByCity.get(city.trim()) : null;
    }
    public void setTravelPolicy(String city, String travelPolicy) {
        if (city != null && travelPolicy != null) {
            travelPolicyByCity.put(city.trim(), travelPolicy);
        }
    }
    public void invalidateUserContactInfo() {         // 联系信息被更新后失效，下次查询回源 DB
        this.userContactInfo = null;
    }
    // ... getUserBaseLocation / setUserBaseLocation ...
}

@Tool(name = "query_travel_policy", description = "查询指定用户和目的城市的差旅政策标准…")
public String queryTravelPolicy(AgentSessionContext sessionCtx,
                                @ToolParam(name = "city") String city) {
    String cached = sessionCtx.getTravelPolicy(city);
    if (cached != null) {
        logger.info("[TOOL][query_travel_policy] hit cache, city={}", city);
        return cached;                                   // 命中：直接返回，零查库
    }
    // 未命中：回源 → 序列化 → 回填缓存
    TravelPolicy policy = travelPolicyService.getPolicy(sessionCtx.getUserId(), city);
    String result = JSON.toJSONString(policy);
    sessionCtx.setTravelPolicy(city, result);
    return result;
}

// 读：query_user_contact_info —— 命中会话缓存直接返回，否则回源 DB 并回填
String cached = sessionCtx.getUserContactInfo();
if (cached != null) { return cached; }
// ... 查 userProfileRepository、拼 JSON ...
sessionCtx.setUserContactInfo(json);

// 写：update_user_contact_info —— 存库成功后，主动失效会话缓存，防止读到旧值
userProfileRepository.save(profile);
sessionCtx.invalidateUserContactInfo();

@Component
public class ItineraryPlanStore {
    private static final String KEY_PREFIX = "planner:result:";
    private static final Duration RESULT_TTL = Duration.ofHours(24);   // 短期中间数据，超时自动清

    public static String keyOf(String userId) {                        // userId 做安全字符过滤，空则归 default
        String uid = (userId == null || userId.trim().isEmpty()) ? "default"
                : userId.trim().replaceAll("[^a-zA-Z0-9_.-]", "_");
        return KEY_PREFIX + uid;
    }
    public void save(String userId, String resultJson) {
        redisTemplate.opsForValue().set(keyOf(userId), resultJson, RESULT_TTL);
    }
    public String load(String userId) {
        String content = redisTemplate.opsForValue().get(keyOf(userId));
        return (content == null || content.isBlank()) ? null : content;
    }
}

public String get(String userId) {
    try {
        return redisTemplate.opsForValue().get(KEY_PREFIX + userId);
    } catch (Exception e) {
        logger.warn("...读取偏好缓存失败: {}", e.getMessage());
        return null;                          // Redis 故障 → 当作未命中，回源，绝不阻断主流程
    }
}
public void put(String userId, String value) {
    if (userId == null || userId.isBlank() || value == null || value.isBlank()) {
        return;                               // 空内容不缓存，保证「空串==未命中」可靠成立
    }
    redisTemplate.opsForValue().set(KEY_PREFIX + userId, value, ttl);  // 默认 1800s
}

return Mono.fromCallable(() -> {
            String cached = cache.get(userId);
            return cached != null ? cached : "";
        })
        .subscribeOn(Schedulers.boundedElastic())          // 阻塞 Redis 读不占 Reactor 事件线程
        .flatMap(cached -> {
            if (!cached.isEmpty()) { return Mono.just(cached); }   // 命中：不打百炼
            return baiLianMemory.retrieve(msg)
                    .doOnNext(result -> cache.put(userId, result))  // 未命中：回源并回填
                    .onErrorReturn("");
        });