#分布式限流（Redis + Lua）

@Service
public class MultiDimensionRateLimiter {

    private final RedisTemplate<String, String> redisTemplate;

    // Lua 脚本缓存
    private final Map<String, RedisScript<Long>> scriptCache = new ConcurrentHashMap<>();

    public MultiDimensionRateLimiter(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 多维度限流检查
     */
    public RateLimitResult checkRateLimit(RateLimitRequest request) {
        String[] keys = {
            "limit:user:" + request.getUserId(),           // 用户维度
            "limit:ip:" + request.getIp(),                 // IP 维度
            "limit:api:" + request.getApi(),               // API 维度
            "limit:global"                                 // 全局限流
        };

        int[] limits = {
            100,  // 用户：每秒 100 请求
            200,  // IP：每秒 200 请求
            500,  // API：每秒 500 请求
            10000 // 全局：每秒 10000 请求
        };

        for (int i = 0; i < keys.length; i++) {
            boolean allowed = tryAcquire(keys[i], limits[i], 1);
            if (!allowed) {
                return RateLimitResult.rejected(keys[i], limits[i]);
            }
        }

        return RateLimitResult.allowed();
    }

    private boolean tryAcquire(String key, int limit, int count) {
        String script = loadScript("counter_limit.lua");
        RedisScript<Long> redisScript = scriptCache.computeIfAbsent(script,
            s -> new DefaultRedisScript<>(s, Long.class));

        Long result = redisTemplate.execute(
            redisScript,
            List.of(key),
            1,  // 窗口大小（秒）
            limit
        );

        return result != null && result == 1;
    }
}

public class ClusterRateLimiter {

    private final RedisClusterTemplate clusterTemplate;

    /**
     * 使用哈希槽分片
     * 优点：不同维度的限流可以聚合计算
     * 缺点：实现复杂
     */
    public boolean checkRateLimit(String userId, String api) {
        // 将用户和 API 组合成同一个 key，确保同一用户同一 API 的请求打到同一个 slot
        String combinedKey = userId + ":" + api;

        // 计算 slot
        int slot = slot(combinedKey);

        // 使用 tag 路由到正确的节点
        String keyWithTag = "{" + combinedKey + "}";

        return tryAcquire(keyWithTag, 100, 1);
    }

    private int slot(String key) {
        // CRC16 哈希槽算法
        return Math.abs(CRC16.calculate(key) % 16384);
    }
}

@Service
public class RedissonRateLimiter {

    private final RedissonClient redissonClient;

    private final RRateLimiter userLimiter;
    private final RRateLimiter ipLimiter;
    private final RRateLimiter globalLimiter;

    public RedissonRateLimiter(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;

        // 用户维度：每秒 100 个许可
        this.userLimiter = redissonClient.getRateLimiter("limit:user:");
        this.userLimiter.trySetRate(RateIntervalUnit.SECONDS, 100, 1, RateLimitParameters.Direction.BOTH);

        // IP 维度：每秒 200 个许可
        this.ipLimiter = redissonClient.getRateLimiter("limit:ip:");
        this.ipLimiter.trySetRate(RateIntervalUnit.SECONDS, 200, 1, RateLimitParameters.Direction.BOTH);

        // 全局维度：每秒 10000 个许可
        this.globalLimiter = redissonClient.getRateLimiter("limit:global:");
        this.globalLimiter.trySetRate(RateIntervalUnit.SECONDS, 10000, 1, RateLimitParameters.Direction.BOTH);
    }

    public boolean tryAcquire(String userId, String ip) {
        // 获取所有维度的许可
        boolean userAllowed = userLimiter.tryAcquire(1, userId);
        boolean ipAllowed = ipLimiter.tryAcquire(1, ip);
        boolean globalAllowed = globalLimiter.tryAcquire(1, "global");

        return userAllowed && ipAllowed && globalAllowed;
    }

    public RateLimitResult tryAcquireWithResult(String userId, String ip) {
        boolean userAllowed = userLimiter.tryAcquire(1, userId);
        boolean ipAllowed = ipLimiter.tryAcquire(1, ip);
        boolean globalAllowed = globalLimiter.tryAcquire(1, "global");

        if (userAllowed && ipAllowed && globalAllowed) {
            return RateLimitResult.allowed();
        }

        List<String> rejected = new ArrayList<>();
        if (!userAllowed) rejected.add("user");
        if (!ipAllowed) rejected.add("ip");
        if (!globalAllowed) rejected.add("global");

        return RateLimitResult.rejected(rejected);
    }
}

public class MultiRedisRateLimiter {

    private final List<RedisTemplate<String, String>> redisTemplates;

    /**
     * 使用一致性哈希选择 Redis 实例
     */
    public boolean tryAcquire(String key, int limit) {
        // 一致性哈希选择节点
        int index = consistentHash(key);
        RedisTemplate<String, String> redis = redisTemplates.get(index);

        String script = loadScript("counter_limit.lua");
        Long result = redis.execute(
            new DefaultRedisScript<>(script, Long.class),
            List.of(key),
            1, limit
        );

        return result != null && result == 1;
    }
}