@PublicAccess
@RateLimit(timeWindow = 2000, limitCount = 5, description = "限制2秒内最多5个请求")
@GetMapping("/test")
public String test() {
    return "hello world";
}

package com.yeshimin.yeahboot.flowcontrol.ratelimit;

import com.yeshimin.yeahboot.flowcontrol.enums.GroupType;

import java.lang.annotation.*;

/**
 * 限流注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimit {

    /**
     * 是否启用
     */
    boolean enabled() default true;

    /**
     * 名称，默认为方法的全限定名
     */
    String name() default "";

    /**
     * 分组方式：1-无 2-按IP 3-按用户
     */
    GroupType groupType() default GroupType.NONE;

    /**
     * 自定义分组逻辑，配合GroupType.CUSTOM使用；支持spel表达式
     */
    String customGroup() default "";

    /**
     * 限制数量
     */
    int limitCount() default -1;

    /**
     * 限制分组数量
     */
    int limitGroup() default -1;

    /**
     * 限制每个分组内数量
     */
    int limitGroupCount() default -1;

    /**
     * 时间窗口，单位：毫秒
     */
    int timeWindow() default 1000;

    /**
     * 时间窗口内桶大小，单位：毫秒，默认：100
     */
    int bucketSize() default 100;

    /**
     * 是否动态时间窗口模式
     */
    boolean dynamicTimeWindow() default true;

    /**
     * 是否全局限流 TODO
     */
    boolean global() default false;

    /**
     * 描述
     */
    String description() default "";
}

package com.yeshimin.yeahboot.flowcontrol.ratelimit;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * RateLimit 拦截器
 */
@Slf4j
@Component
public class RateLimitInterceptor implements HandlerInterceptor {

    private static final ExpressionParser PARSER = new SpelExpressionParser();
    private static final StandardEvaluationContext CONTEXT = new StandardEvaluationContext();

    // map<res, window>
    private final Map<String, SlidingWindow> plainHolder = new ConcurrentHashMap<>();
    // map<res, map<group, latestReqTime>>
    private final Map<String, ConcurrentHashMap<String, Long>> outerGroupHolder = new ConcurrentHashMap<>();
    // map<res, map<group, window>>
    private final Map<String, ConcurrentHashMap<String, SlidingWindow>> innerGroupHolder = new ConcurrentHashMap<>();

    // 每5分钟执行一次清理任务
    private static final long CLEAN_INTERVAL_MS = 5 * 60 * 1000;
    // 10分钟无请求则清理
    private static final long GROUP_EXPIRE_MS = 10 * 60 * 1000;

    @Autowired(required = false)
    private RateLimitService rateLimitService;

    @PostConstruct
    public void init() {
        log.debug("init [yeah-boot] rate limit interceptor...");
    }

    private static final ScheduledExecutorService CLEANER =
            Executors.newSingleThreadScheduledExecutor(r -> {
                Thread t = new Thread(r, "RateLimitCleaner");
                t.setDaemon(true);
                return t;
            });

    // constructor
    public RateLimitInterceptor() {
        CLEANER.scheduleAtFixedRate(this::cleanExpiredGroups,
                CLEAN_INTERVAL_MS, CLEAN_INTERVAL_MS, TimeUnit.MILLISECONDS);
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            log.debug("Not a method handler, skip");
            return true;
        }

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        RateLimit rateLimit = method.getAnnotation(RateLimit.class);

        // 没有注解或禁用限流
        if (rateLimit == null || !rateLimit.enabled()) {
            log.debug("No rate limit annotation or disabled, skip");
            return true;
        }

        // --------------------------------------------------------------------------------

        // 获取限流配置
        RateLimitConf rlConf = this.getRateLimitConf(rateLimit, method, request);
        log.debug("rlConf: {}", rlConf);
        if (rlConf.isSkip()) {
            log.debug("Skip rate limit, skip");
            return true;
        }

        // --------------------------------------------------------------------------------

        // check limitCount
        SlidingWindow plainWindow = null;
        if (rlConf.getLimitCount() > -1) {
            log.debug("check for [limitCount]");

            plainWindow = plainHolder.computeIfAbsent(rlConf.getResName(), k -> new SlidingWindow(rlConf, "[limitCount]"));
            log.debug("plainWindow: {}", plainWindow);

            boolean allowed = plainWindow.tryAcquire(rlConf.getLimitCount(), rlConf.getReqTime());
            if (!allowed) {
                log.debug("Rate limit exceeded: limitCount");
                response.setStatus(429);
                response.getWriter().write("Rate limit exceeded: limitCount");
                return false;
            }
        }

        // check limitGroup
        ConcurrentHashMap<String, Long> outerGroupMap = null;
        if (rlConf.getLimitGroup() > -1) {
            log.debug("check for [limitGroup]");
            outerGroupMap = outerGroupHolder.computeIfAbsent(rlConf.getResName(), k -> new ConcurrentHashMap<>());

            // 删除过期的分组
            outerGroupMap.entrySet().removeIf(entry -> {
                long reqTime = entry.getValue();
                if (reqTime < rlConf.getWindowFrom()) {
                    log.debug("Remove expired group:{}, windowFrom: {}, reqTime: {}", entry.getKey(), rlConf.getWindowFrom(), reqTime);
                    return true;
                }
                return false;
            });

            // 判断是否超限
            boolean allowed;
            if (outerGroupMap.containsKey(rlConf.getGroupName())) {
                allowed = outerGroupMap.size() <= rlConf.getLimitGroup();
            } else {
                allowed = outerGroupMap.size() + 1 <= rlConf.getLimitGroup();
            }

            if (!allowed) {
                log.debug("Rate limit exceeded: limitGroup");
                response.setStatus(429);
                response.getWriter().write("Rate limit exceeded: limitGroup");
                return false;
            }
        }

        // check limitGroupCount
        SlidingWindow innerGroupWindow = null;
        if (rlConf.getLimitGroupCount() > -1) {
            log.debug("check for [limitGroupCount]");

            ConcurrentHashMap<String, SlidingWindow> map = innerGroupHolder.computeIfAbsent(rlConf.getResName(), k -> new ConcurrentHashMap<>());
            innerGroupWindow = map.computeIfAbsent(rlConf.getGroupName(), k -> new SlidingWindow(rlConf, "[limitGroupCount]"));
            log.debug("innerGroupWindow: {}", innerGroupWindow);

            boolean allowed = innerGroupWindow.tryAcquire(rlConf.getLimitGroupCount(), rlConf.getReqTime());

            if (!allowed) {
                log.debug("Rate limit exceeded: limitGroupCount");
                response.setStatus(429);
                response.getWriter().write("Rate limit exceeded: limitGroupCount");
                return false;
            }
        }

        // 仅当通过所有限流检查，记录请求
        if (rlConf.getLimitCount() > -1) {
            log.debug("Record request for [limitCount]");
            Objects.requireNonNull(plainWindow).increase(rlConf.getReqTime());
        }
        if (rlConf.getLimitGroup() > -1) {
            log.debug("Record request for [limitGroup]");
            Objects.requireNonNull(outerGroupMap).put(rlConf.getGroupName(), rlConf.getReqTime());
        }
        if (rlConf.getLimitGroupCount() > -1) {
            log.debug("Record request for [limitGroupCount]");
            Objects.requireNonNull(innerGroupWindow).increase(rlConf.getReqTime());
        }

        return true;
    }

    /**
     * 获取RateLimitConf配置
     */
    private RateLimitConf getRateLimitConf(RateLimit rl, Method m, HttpServletRequest req) {
        RateLimitConf conf = new RateLimitConf();
        conf.setEnabled(rl.enabled());
        conf.setName(rl.name());
        conf.setGroupType(rl.groupType());
        conf.setCustomGroup(rl.customGroup());
        conf.setLimitCount(rl.limitCount());
        conf.setLimitGroup(rl.limitGroup());
        conf.setLimitGroupCount(rl.limitGroupCount());
        conf.setTimeWindow(rl.timeWindow());
        conf.setBucketSize(rl.bucketSize());
        conf.setDynamicTimeWindow(rl.dynamicTimeWindow());
        conf.setGlobal(rl.global());

        // 修整参数
        if (conf.getLimitCount() < -1) {
            conf.setLimitCount(-1);
        }
        if (conf.getLimitGroup() < -1) {
            conf.setLimitGroup(-1);
        }
        if (conf.getLimitGroupCount() < -1) {
            conf.setLimitGroupCount(-1);
        }

        // 请求时间
        conf.setReqTime(System.currentTimeMillis());

        // 修整参数（最小时间窗口为1000毫秒）
        if (conf.getTimeWindow() < 1000) {
            conf.setTimeWindow(1000);
        }
        // 最小桶大小为100毫秒，且必须能整除时间窗口
        if (conf.getBucketSize() < 100) {
            conf.setBucketSize(100);
        }

        // 计算窗口时间范围
        this.calcWindowTimeRange(conf);

        // 资源名称
        conf.setResName(this.getResName(conf, m));
        // 分组名称
        conf.setGroupName(this.getGroupName(conf, m, req));

        return conf;
    }

    /**
     * 计算时间窗口起始时间
     * 根据是否动态时间窗口选择计算方式
     */
    private void calcWindowTimeRange(RateLimitConf rlConf) {
        if (rlConf.isDynamicTimeWindow()) {
            rlConf.setWindowFrom(rlConf.getReqTime() - rlConf.getTimeWindow());
            rlConf.setWindowTo(rlConf.getReqTime());
        } else {
            rlConf.setWindowFrom(rlConf.getReqTime() / rlConf.getTimeWindow() * rlConf.getTimeWindow());
            rlConf.setWindowTo(rlConf.getWindowFrom() + rlConf.getTimeWindow());
        }
    }

    /**
     * 获取目标资源的名称（一般为接口方法的全限定名称或者自定义名称）
     */
    private String getResName(RateLimitConf rlConf, Method m) {
        return rlConf.getName() == null || rlConf.getName().trim().isEmpty() ?
                m.getDeclaringClass().getName() + "." + m.getName() : rlConf.getName();
    }

    /**
     * 滑动窗口实现（环形桶）
     */
    private static class SlidingWindow {
        private final int windowSizeMs;   // 整体窗口大小
        private final int bucketSizeMs;   // 每个桶的时间长度
        private final int bucketCount;     // 桶数量
        private final AtomicInteger[] buckets; // 每个桶计数
        private volatile long lastUpdateTime;  // 最后更新时间（毫秒）
        private volatile long lastGlobalBucketIndex; // 最后更新全局桶索引

        @Getter
        @Setter
        private volatile long lastReqTime;

        private String logFlag;

        public SlidingWindow(RateLimitConf rlConf, String logFlag) {
            this.windowSizeMs = rlConf.getTimeWindow();
            this.bucketSizeMs = rlConf.getBucketSize();
            // 最好能整除，否则行为未知
            this.bucketCount = this.windowSizeMs / this.bucketSizeMs;
            this.buckets = new AtomicInteger[bucketCount];
            for (int i = 0; i < bucketCount; i++) {
                buckets[i] = new AtomicInteger(0);
            }
            this.lastUpdateTime = System.currentTimeMillis();
            this.lastGlobalBucketIndex = lastUpdateTime / this.bucketSizeMs;

            // 上次请求时间
            this.lastReqTime = System.currentTimeMillis();

            this.logFlag = logFlag;
        }

        public synchronized boolean tryAcquire(int limitCount, long reqTime) {
            this.setLastReqTime(reqTime);
            this.slideWindow(reqTime);

            if (limitCount >= 0 && this.calcTotalCount() >= limitCount) {
                return false;
            }
            return true;
        }

        public void increase(long reqTime) {
            // 当前时间对应的桶++
            int index = (int) ((reqTime / bucketSizeMs) % bucketCount);
            buckets[index].incrementAndGet();
            // print buckets
            log.debug("{} buckets: {}", logFlag, Arrays.toString(buckets));
        }

        /**
         * 滑动窗口更新：清理过期桶
         */
        private void slideWindow(long reqTime) {
            // 计算请求时间的全局桶索引
            long globalBucketIndex = reqTime / bucketSizeMs;
            long globalBucketsPassed = globalBucketIndex - lastGlobalBucketIndex;

            // log
            log.debug("{} slideWindow: reqTime={}, globalBucketIndex={}, globalBucketsPassed={}, lastGlobalBucketIndex={}",
                    logFlag, reqTime, globalBucketIndex, globalBucketsPassed, lastGlobalBucketIndex);

            // 如果时间没有过去一个桶的大小，直接返回
            if (globalBucketsPassed <= 0) {
                log.debug("{}, no need to slide", logFlag);
                return;
            }

            // 如果时间过去超过所有桶，则全部过期
            if (globalBucketsPassed >= bucketCount) {
                log.debug("{} clear all", logFlag);
                for (AtomicInteger b : buckets) {
                    b.set(0);
                }
            } else {
                // 从lastBucketIndex后一个开始正向清除bucketsPassed个桶
                for (int i = 1; i <= globalBucketsPassed; i++) {
                    int index = (int) ((lastGlobalBucketIndex + i) % bucketCount);
                    log.debug("{} clear index: {}", logFlag, index);
                    buckets[index].set(0);
                }
            }

            lastUpdateTime = reqTime;
            lastGlobalBucketIndex = reqTime / bucketSizeMs;
            log.debug("{} slideWindow: lastUpdateTime={}, lastGlobalBucketIndex={}", logFlag, lastUpdateTime, lastGlobalBucketIndex);
        }

        /**
         * 统计所有桶总和
         */
        private int calcTotalCount() {
            int total = 0;
            for (AtomicInteger b : buckets) {
                total += b.get();
            }
            return total;
        }
    }

    /**
     * 清理过期的 group，防止 innerGroupHolder 无限制增长
     */
    private void cleanExpiredGroups() {
        long now = System.currentTimeMillis();

        try {
            log.debug("[RateLimitCleaner] 开始清理过期 group... now={}", now);

            innerGroupHolder.forEach((resName, groupMap) -> {
                // 遍历 groupMap，但删除时使用 CAS，不直接 removeIf
                for (Map.Entry<String, SlidingWindow> entry : groupMap.entrySet()) {
                    String group = entry.getKey();
                    SlidingWindow window = entry.getValue();

                    long lastReq = window.getLastReqTime();
                    boolean expired = (now - lastReq > GROUP_EXPIRE_MS) && (now - lastReq > window.windowSizeMs);
                    log.debug("[RateLimitCleaner] group={} (resName={}) lastReq={}, expiredMs={}, GROUP_EXPIRE_MS={}, windowSizeMs={}",
                            group, resName, lastReq, now - lastReq, GROUP_EXPIRE_MS, window.windowSizeMs);
                    if (expired) {
                        // CAS 删除：确保删除的是当前 value，防止误删
                        boolean removed = groupMap.remove(group, window);
                        if (removed) {
                            log.debug("[RateLimitCleaner] 已清理 group={} (resName={}) lastReq={}, expiredMs={}",
                                    group, resName, lastReq, now - lastReq);
                        }
                    }
                }
            });

        } catch (Exception e) {
            log.error("[RateLimitCleaner] 清理异常", e);
        }
    }

    /**
     * 获取分组名称
     */
    private String getGroupName(RateLimitConf rlConf, Method m, HttpServletRequest request) {
        switch (rlConf.getGroupType()) {
            case IP:
                return request.getRemoteAddr();
            case CUSTOM:
                return this.getCustomGroupName(rlConf.getCustomGroup(), request, m);
            case NONE:
            default:
                return String.valueOf(rlConf.getWindowFrom());
        }
    }

    /**
     * 获取自定义分组名称
     * 支持：
     * 1. 普通字符串（不以 # 开头），直接返回
     * 2. SpEL 表达式（以 # 开头），解析返回
     */
    private String getCustomGroupName(String customGroup, HttpServletRequest request, Method method) {
        if (customGroup == null || customGroup.trim().isEmpty()) {
            log.warn("自定义分组名称不能为空");
            throw new RuntimeException("自定义分组名称不能为空");
        }

        // 1. 普通字符串，直接返回
        if (!customGroup.trim().startsWith("#")) {
            return customGroup;
        }

        // 2. SpEL 表达式 —— 动态解析
        try {
            // 上下文变量，可扩展
            CONTEXT.setVariable("request", request);
            CONTEXT.setVariable("method", method);

            // rls = Rate Limit Service
            CONTEXT.setVariable("rls", rateLimitService);

            Object val = PARSER.parseExpression(customGroup).getValue(CONTEXT);
            if (val == null) {
                log.warn("解析分组名称失败");
                throw new RuntimeException("解析分组名称失败");
            }
            log.debug("SpEL 解析分组名称成功：{}", val);
            return String.valueOf(val);
        } catch (Exception e) {
            log.warn("SpEL 解析分组名称失败");
            throw new RuntimeException("解析分组名称失败");
        }
    }
}

package com.yeshimin.yeahboot.flowcontrol.ratelimit;

import com.yeshimin.yeahboot.flowcontrol.enums.GroupType;
import lombok.Data;

/**
 * RateLimit 配置类
 */
@Data
class RateLimitConf {

    private boolean enabled;

    private String name;

    private GroupType groupType;

    private String customGroup;

    private int limitCount;

    private int limitGroup;

    private int limitGroupCount;

    // 时间窗口，单位：毫秒
    private int timeWindow;

    // 时间窗口内桶大小，单位：毫秒
    private int bucketSize;

    private boolean dynamicTimeWindow;

    private boolean global;

    // --------------------------------------------------------------------------------

    // 计算得出
    private long windowFrom;

    // 计算得出
    private long windowTo;

    // 请求时间
    private long reqTime;

    // 计算得出
    private String resName;

    // 计算得出
    private String groupName;

    public boolean isSkip() {
        return !enabled || (limitCount < 0 && limitGroup < 0 && limitGroupCount < 0);
    }
}

package com.yeshimin.yeahboot.flowcontrol.ratelimit;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;

public interface RateLimitService {

    String getGroupName(HttpServletRequest request, Method method);

    String getUserId(HttpServletRequest request, Method method);

    String getIp(HttpServletRequest request, Method method);
}

package com.yeshimin.yeahboot.flowcontrol.enums;

import lombok.Getter;

/**
 * 分组方式：1-无 2-按IP 3-自定义
 */
@Getter
public enum GroupType {

    NONE(1),
    IP(2),
    CUSTOM(3);

    private final Integer value;

    GroupType(Integer value) {
        this.value = value;
    }
}

package com.yeshimin.yeahboot.flowcontrol;

import com.yeshimin.yeahboot.flowcontrol.ratelimit.RateLimitInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class FlowControlWebMvcConfig implements WebMvcConfigurer {

    private final RateLimitInterceptor rateLimitInterceptor;

    public FlowControlWebMvcConfig(RateLimitInterceptor rateLimitInterceptor) {
        this.rateLimitInterceptor = rateLimitInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(rateLimitInterceptor).addPathPatterns("/**");
    }
}

package com.yeshimin.yeahboot.merchant.service;

import cn.hutool.core.util.StrUtil;
import com.manticoresearch.client.ApiClient;
import com.manticoresearch.client.ApiException;
import com.manticoresearch.client.api.IndexApi;
import com.manticoresearch.client.api.SearchApi;
import com.manticoresearch.client.model.*;
import com.yeshimin.yeahboot.common.common.consts.FulltextTableConsts;
import com.yeshimin.yeahboot.common.common.properties.ManticoreSearchProperties;
import com.yeshimin.yeahboot.data.domain.entity.ProductSpuEntity;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
@RequiredArgsConstructor
public class FullTextSearchService {

    private final ManticoreSearchProperties properties;

    /**
     * 同步商品索引
     */
    public void syncProduct(ProductSpuEntity productSpu, List<String> skuNames, List<String> skuSpecs, boolean update) {
        Map<String, Object> doc = new HashMap<>();
        doc.put("id", productSpu.getId());
        doc.put("product_name", productSpu.getName());
        doc.put("sku_names", StrUtil.join(" ", skuNames));
        doc.put("sku_specs", StrUtil.join(" ", skuSpecs));
        doc.put("sales", productSpu.getSales());
        doc.put("sku_min_price", productSpu.getMinPrice());
        doc.put("sku_max_price", productSpu.getMaxPrice());

        if (update) {
            this.replace(FulltextTableConsts.PRODUCT, doc);
        } else {
            this.insert(FulltextTableConsts.PRODUCT, doc);
        }
    }

    // ================================================================================

    /**
     * search
     */
    public SearchResponse search(String tableName, String queryString) {
        ApiClient client = this.newClient();

        SearchQuery searchQuery = new SearchQuery();
        searchQuery.setQueryString(queryString);

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.table(tableName).query(searchQuery);

        SearchApi searchApi = new SearchApi(client);

        try {
            SearchResponse response = searchApi.search(searchRequest);
            log.debug("Search response: {}", response);
            return response;
        } catch (ApiException e) {
            this.printError(e);
            throw new RuntimeException(e);
        }
    }

    /**
     * insert
     */
    public SuccessResponse insert(String tableName, Map<String, Object> doc) {
        ApiClient client = this.newClient();

        Long id = Long.parseLong(doc.remove("id").toString());

        InsertDocumentRequest request = new InsertDocumentRequest();
        request.table(tableName).id(id).doc(doc);

        IndexApi indexApi = new IndexApi(client);
        try {
            SuccessResponse response = indexApi.insert(request);
            log.debug("Insert response: {}", response);
            return response;
        } catch (ApiException e) {
            this.printError(e);
            throw new RuntimeException(e);
        }
    }

    /**
     * replace
     */
    public SuccessResponse replace(String tableName, Map<String, Object> doc) {
        ApiClient client = this.newClient();

        Long id = Long.parseLong(doc.remove("id").toString());

        InsertDocumentRequest request = new InsertDocumentRequest();
        request.table(tableName).id(id).doc(doc);

        IndexApi indexApi = new IndexApi(client);
        try {
            SuccessResponse response = indexApi.replace(request);
            log.debug("Replace response: {}", response);
            return response;
        } catch (ApiException e) {
            this.printError(e);
            throw new RuntimeException(e);
        }
    }

    /**
     * update
     */
    public UpdateResponse update(String tableName, Map<String, Object> doc) {
        ApiClient client = this.newClient();

        Long id = Long.parseLong(doc.remove("id").toString());

        UpdateDocumentRequest updateRequest = new UpdateDocumentRequest();
        updateRequest.table(tableName).id(id).doc(doc);

        IndexApi indexApi = new IndexApi(client);
        try {
            UpdateResponse response = indexApi.update(updateRequest);
            log.debug("Update response: {}", response);
            return response;
        } catch (ApiException e) {
            this.printError(e);
            throw new RuntimeException(e);
        }
    }

    /**
     * deleteIndex
     */
    public DeleteResponse deleteIndex(String tableName, Long id) {
        ApiClient client = this.newClient();

        DeleteDocumentRequest deleteRequest = new DeleteDocumentRequest();
        deleteRequest.table(tableName).id(id);

        IndexApi indexApi = new IndexApi(client);
        try {
            DeleteResponse response = indexApi.delete(deleteRequest);
            log.debug("Delete response: {}", response);
            return response;
        } catch (ApiException e) {
            this.printError(e);
            throw new RuntimeException(e);
        }
    }

    // ================================================================================

    private ApiClient newClient() {
        ApiClient client = new ApiClient();
        client.setBasePath(properties.getBasePath());
        return client;
    }

    private void printError(ApiException e) {
        log.error("Exception when calling Api function: {}, Status code: {}, Reason: {}, Response headers: {}",
                e.getMessage(), e.getCode(), e.getResponseBody(), e.getResponseHeaders());
    }
}

@Slf4j
@Service
public class WeatherMcpService {

    /**
     * tool: query weather info by city name
     */
    @Tool(description = "query weather info by city name")
    public String queryWeatherInfo(@ToolParam(required = true, description = "city name") String city) {
        String weatherInfo = weatherInfoService.getWeatherInfo(city);
        log.info("queryWeatherInfo result: {}", weatherInfo);
        return weatherInfo;
    }
}

@Configuration
public class McpServerConfiguration {

    @Bean
    public ToolCallbackProvider weatherTools(WeatherMcpService weatherMcpService) {
        return MethodToolCallbackProvider.builder().toolObjects(weatherMcpService).build();
    }
}

/**
 * 终端和token控制服务
 */
@Service
@RequiredArgsConstructor
public class TerminalAndTokenControlService {

    private final TokenService tokenService;
    private final CacheService cacheService;
    private final JwtService jwtService;

    private final AuthTokenProperties authTokenProperties;

    /**
     * 控制终端和token数量
     */
    public String doControl(String userId, String subValue, String termValue) {
        // 检查配置
        AuthTokenProperties.Subject subject = authTokenProperties.getMapSubject().get(subValue);
        if (subject == null) {
            throw new BaseException(ErrorCodeEnum.FAIL, "subject[" + subValue + "] 未配置");
        }
        AuthTokenProperties.Terminal terminal = subject.getMapTerminal().get(termValue);
        if (terminal == null) {
            throw new BaseException(ErrorCodeEnum.FAIL, "terminal[" + termValue + "] 不正确");
        }

        // 1.检查配置
        // --------------------------------------------------------------------------------
        // 2.加载缓存数据并做初预处理

        // 添加token及终端信息
        String token = tokenService.generateToken(userId, subValue, termValue);
        JwtPayloadVo jwtPayloadVo = jwtService.decodePayload(token);
        // token创建时间戳（毫秒）
        long timestampMs = jwtPayloadVo.getIatMs();

        // 查询终端信息
        Map<String, String> mapTerminalInfo = tokenService.getSubjectTerminalInfo(subValue, userId);
        Map<String, String> mapTerminalInfoValid = new HashMap<>();
        Map<String, String> mapTerminalInfoExpired = new HashMap<>();
        // 区分是否过期
        mapTerminalInfo.forEach((term, termInfo) -> {
            // termInfo格式为 "iat,expTime"，其中iat为登录时间戳，expTime为过期时间戳
            long expTime = Long.parseLong(termInfo.split(",")[1]);
            if (timestampMs >= expTime) {
                mapTerminalInfoExpired.put(term, termInfo);
            } else {
                mapTerminalInfoValid.put(term, termInfo);
            }
        });
        // 查询终端对应的token信息
        Map<String, Map<String, String>> mapTotalTerminalTokenInfo = new HashMap<>();
        Map<String, Map<String, String>> mapRemainTerminalTokenInfo = new HashMap<>();
        Map<String, String> mapTotalTerminalTokenInfoValid = new HashMap<>();
        Map<String, String> mapTotalTerminalTokenInfoExpired = new HashMap<>();
        for (Map.Entry<String, String> entry : mapTerminalInfo.entrySet()) {
            // 查询对应终端的token信息
            Map<String, String> mapTerminalTokenInfo = tokenService.getTerminalTokenInfo(subValue, userId, entry.getKey());
            mapTotalTerminalTokenInfo.put(entry.getKey(), mapTerminalTokenInfo);
        }
        // 查询当前终端的token信息
        Map<String, String> mapTerminalTokenInfo = mapTotalTerminalTokenInfo.getOrDefault(termValue, new HashMap<>());
        Map<String, String> mapTerminalTokenInfoValid = new HashMap<>();
        Map<String, String> mapTerminalTokenInfoExpired = new HashMap<>();
        mapTerminalTokenInfo.forEach((timestamp, expTime) -> {
            long expTimeInt = Long.parseLong(expTime);
            if (timestampMs >= expTimeInt) {
                mapTerminalTokenInfoExpired.put(timestamp, expTime);
            } else {
                mapTerminalTokenInfoValid.put(timestamp, expTime);
            }
        });

        // 2.加载缓存数据并做初预处理
        // --------------------------------------------------------------------------------
        // 3.检查和控制subject下终端数量

        // 是否清空用户的终端和token信息
        boolean clearAllTerminal = false;
        // 要清除的终端信息
        Set<String> needDeleteTerminal = new HashSet<>();
        // 要清除的token信息，map<terminal, set<timestamp>> ； 【保留终端token信息】中的待清除部分
        Map<String, Set<String>> mapNeedDeleteTokenInfo = new HashMap<>();

        // 检查和控制终端数
        // 大于0，需要检查和控制超限情况
        if (subject.getMaxOnlineTerminalCount() > 0) {
            // 检查当前在线终端数是否达到限制
            int occurTerminalCount = mapTerminalInfoValid.size() + (mapTerminalInfoValid.containsKey(termValue) ? 0 : 1);
            // 超限情况
            if (occurTerminalCount > subject.getMaxOnlineTerminalCount()) {
                // 要清除的终端数
                int needToDeleteTerminalCount = occurTerminalCount - subject.getMaxOnlineTerminalCount();
                // 优先清除旧值
                // mapTerminalInfoValid按value[0]时间戳排序，value[0]越小越旧;
                // value数据格式为iat,expTime，直接按value字符串排序效果与按iat排序一样
                Set<String> eliminatedTerminal = mapTerminalInfoValid.entrySet()
                        .stream().sorted(Map.Entry.comparingByValue()).limit(needToDeleteTerminalCount)
                        .map(Map.Entry::getKey).collect(Collectors.toSet());
                // 记录要清除的终端信息
                needDeleteTerminal.addAll(eliminatedTerminal);
            }
        } else if (subject.getMaxOnlineTerminalCount() == 0) {
            clearAllTerminal = true;
        }
        // 添加过期终端
        needDeleteTerminal.addAll(mapTerminalInfoExpired.keySet());

        // 3.检查和控制subject下终端数量
        // --------------------------------------------------------------------------------
        // 4.检查和控制subject下token数量

        // 检查和控制token信息
        // 大于0，需要检查和控制超限情况
        if (subject.getMaxOnlineTokenCount() > 0) {
            // 计算当前有效token数量（排除掉要清除的终端，即只计算要保留的终端）
            int occurTokenCount = 0;
            mapRemainTerminalTokenInfo = mapTotalTerminalTokenInfo.entrySet().stream()
                    .filter(entry -> !needDeleteTerminal.contains(entry.getKey()))
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
            for (Map.Entry<String, Map<String, String>> entry : mapRemainTerminalTokenInfo.entrySet()) {
                occurTokenCount += entry.getValue().size();
                // 区分是否过期
                entry.getValue().forEach((timestamp, expTime) -> {
                    long expTimeInt = Long.parseLong(expTime);
                    if (timestampMs >= expTimeInt) {
                        mapTotalTerminalTokenInfoExpired.put(timestamp + "," + entry.getKey(), expTime);
                    } else {
                        mapTotalTerminalTokenInfoValid.put(timestamp + "," + entry.getKey(), expTime);
                    }
                });
            }
            // 超限的情况
            if (occurTokenCount >= subject.getMaxOnlineTokenCount()) {
                // 计算需要清除的token数量；+1是为当前登录操作预留的token位置
                int needDeleteCount = occurTokenCount - subject.getMaxOnlineTokenCount() + 1;
                // 优先清除旧值
                Set<String> eliminatedTokenInfo = mapTotalTerminalTokenInfoValid.entrySet()
                        .stream().sorted((e1, e2) -> {
                            String terminal1 = e1.getKey().split(",")[1];
                            int sort = Objects.equals(terminal1, termValue) ? 0 : 1;
                            String key1 = sort + ":" + e1.getKey();

                            String terminal2 = e2.getKey().split(",")[1];
                            sort = Objects.equals(terminal2, termValue) ? 0 : 1;
                            String key2 = sort + ":" + e2.getKey();

                            return key1.compareTo(key2);
                        }).limit(needDeleteCount)
                        .map(Map.Entry::getKey).collect(Collectors.toSet());
                eliminatedTokenInfo.forEach(e -> {
                    // [0]: timestamp; [1]: terminal
                    String[] split = e.split(",");
                    mapNeedDeleteTokenInfo.computeIfAbsent(split[1], k -> new HashSet<>()).add(split[0]);
                });
            }
        } else if (subject.getMaxOnlineTokenCount() == 0) {
            clearAllTerminal = true;
        }
        // 过期token信息的也添加到待清除集合
        mapTotalTerminalTokenInfoExpired.keySet().forEach(e -> {
            // [0]: timestamp; [1]: terminal
            String[] split = e.split(",");
            mapNeedDeleteTokenInfo.computeIfAbsent(split[1], k -> new HashSet<>()).add(split[0]);
        });

        // 4.检查和控制subject下token数量
        // --------------------------------------------------------------------------------
        // 5.检查和控制terminal下token数量

        // 检查和控制当前用户登录终端对应的token信息
        // 仅当当前终端不包含在待删除终端集合内，才进行处理
        if (!needDeleteTerminal.contains(termValue)) {
            // 大于0，需要检查和控制超限情况
            if (terminal.getMaxOnlineTokenCount() > 0) {
                // 超限的情况
                if (mapTerminalTokenInfoValid.size() >= terminal.getMaxOnlineTokenCount()) {
                    // 需要清除的token数量；+1是为当前登录操作预留的token位置
                    int needDeleteCount = mapTerminalTokenInfoValid.size() - terminal.getMaxOnlineTokenCount() + 1;
                    // 优先清除旧值
                    Set<String> eliminatedToken = mapTerminalTokenInfoValid.entrySet()
                            .stream().sorted(Map.Entry.comparingByKey()).limit(needDeleteCount)
                            .map(Map.Entry::getKey).collect(Collectors.toSet());
                    eliminatedToken.forEach(timestamp -> {
                        mapNeedDeleteTokenInfo.computeIfAbsent(termValue, k -> new HashSet<>()).add(timestamp);
                    });
                }
            } else if (terminal.getMaxOnlineTokenCount() == 0) {
                // 清空当前终端和对应token信息
                needDeleteTerminal.add(termValue);
            }
            // 过期的token信息也添加到待清除集合
            mapTerminalTokenInfoExpired.keySet().forEach(timestamp -> {
                mapNeedDeleteTokenInfo.computeIfAbsent(termValue, k -> new HashSet<>()).add(timestamp);
            });
        }

        // 5.检查和控制terminal下token数量
        // --------------------------------------------------------------------------------
        // 6.执行清除操作并按需添加当前登录的终端和token信息

        // 清空用户所有终端和token信息
        if (clearAllTerminal) {
            Set<String> delKeys = new HashSet<>();
            delKeys.add(String.format(CacheKeyConsts.USER_SUBJECT_TERMINAL_INFO, subValue, userId));
            mapTerminalInfo.keySet().forEach(term -> {
                delKeys.add(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN_INFO, subValue, userId, term));
                mapTotalTerminalTokenInfo.getOrDefault(term, new HashMap<>()).forEach((timestamp, expTime) -> {
                    delKeys.add(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN, subValue, userId, term, timestamp));
                });
            });
            cacheService.delete(delKeys.toArray(new String[0]));
            // 禁止登录
            throw new BaseException("禁止登录");
        }
        // （按需）清空部分信息，然后添加当前登录所创建的token及终端信息
        else {
            Set<String> delKeys = new HashSet<>();
            // map<cache key, fields>
            Map<String, Set<String>> delFields = new HashMap<>();

            needDeleteTerminal.forEach(term -> {
                delFields.computeIfAbsent(String.format(CacheKeyConsts.USER_SUBJECT_TERMINAL_INFO, subValue, userId),
                        k -> new HashSet<>()).add(term);

                delKeys.add(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN_INFO, subValue, userId, term));
                Optional.ofNullable(mapTotalTerminalTokenInfo.get(term)).ifPresent(terminalTokenInfo -> {
                    terminalTokenInfo.keySet().forEach(timestamp -> {
                        delFields.computeIfAbsent(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN_INFO, subValue, userId, term),
                                k -> new HashSet<>()).add(timestamp);
                        delKeys.add(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN, subValue, userId, term, timestamp));
                    });
                });
            });
            mapNeedDeleteTokenInfo.forEach((term, timestampSet) -> {
                delFields.computeIfAbsent(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN_INFO, subValue, userId, term),
                        k -> new HashSet<>()).addAll(timestampSet);
                timestampSet.forEach(timestamp -> {
                    delKeys.add(String.format(CacheKeyConsts.USER_TERMINAL_TOKEN, subValue, userId, term, timestamp));
                });
            });
            // 执行清除
            cacheService.delete(delKeys.toArray(new String[0]));
            delFields.forEach((cacheKey, fields) -> {
                cacheService.deleteHashFields(cacheKey, fields.toArray(new Object[0]));
            });

            tokenService.setSubjectTerminalInfo(subValue, userId, termValue, jwtPayloadVo.getIatMs(), jwtPayloadVo.getExpMs());
            tokenService.setTerminalTokenInfo(subValue, userId, termValue, jwtPayloadVo.getIatMs(), jwtPayloadVo.getExpMs());
            tokenService.cacheToken(subValue, userId, termValue, token, timestampMs);
            return token;
        }
    }
}

// subject下所有终端信息 redis hash类型
public static final String USER_SUBJECT_TERMINAL_INFO = "sub:%s:user:%s:token:term";

// 终端下token信息 redis hash类型
public static final String USER_TERMINAL_TOKEN_INFO = "sub:%s:user:%s:token:term:%s";

// token，格式: [subject : user : terminal : token timestamp] redis string类型
public static final String USER_TERMINAL_TOKEN = "sub:%s:user:%s:token:term:%s:%s";

/**
 * Jwt Token认证提供器 for ProviderManager
 */
@Slf4j
public class JwtTokenAuthenticationProvider implements AuthenticationProvider {

    private final AuthService authService;

    // constructor
    public JwtTokenAuthenticationProvider(AuthService authService) {
        this.authService = authService;
    }

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        JwtTokenAuthenticationToken requestToken = (JwtTokenAuthenticationToken) authentication;
        String token = (String) requestToken.getCredentials();

        AuthDto authDto = new AuthDto();
        authDto.setToken(token);
        AuthVo authVo = authService.auth(authDto);
        if (authVo == null || !authVo.getAuthenticated()) {
            log.error("调用auth服务鉴权失败！");
            throw new BaseException(ErrorCodeEnum.FAIL, "调用auth服务鉴权失败！");
        }

        // set web context
        WebContextUtils.setToken(token);
        WebContextUtils.setUserId(authVo.getUserId());
        WebContextUtils.setSubject(authVo.getSubject());
        WebContextUtils.setTerminal(authVo.getTerminal());
        WebContextUtils.setUsername(authVo.getUsername());
        WebContextUtils.setRoles(authVo.getRoles());
        WebContextUtils.setResources(authVo.getResources());

        // role
        Set<String> authoritySet = authVo.getRoles().stream().map(s -> "ROLE_" + s).collect(Collectors.toSet());
        // add resource
        authoritySet.addAll(authVo.getResources());
        String commaSeparatedRoles = String.join(",", authoritySet);

        // set authorities
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList(commaSeparatedRoles);
        // new authentication
        JwtTokenAuthenticationToken resultToken = new JwtTokenAuthenticationToken(authorities);
        resultToken.setAuthenticated(true);

        return resultToken;
    }

    @Override
    public boolean supports(Class<?> authentication) {
        return JwtTokenAuthenticationToken.class.isAssignableFrom(authentication);
    }
}