<dependency>
    <groupId>com.github.vladimir-bukhtoyarov</groupId>
    <artifactId>bucket4j-core</artifactId>
    <version>8.1.1</version>
</dependency>
<dependency>
    <groupId>com.github.vladimir-bukhtoyarov</groupId>
    <artifactId>bucket4j-redis</artifactId>
    <version>8.1.1</version>
</dependency>
<!-- 如果使用Jedis客戶端 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.0</version>
</dependency>
<!-- 如果使用Lettuce客戶端 -->
<!--
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.3.2.RELEASE</version>
</dependency>
-->

import io.bucket4j.Bucket;
import io.bucket4j.ConsumptionProbe;
import io.bucket4j.grid.GridBucket;
import io.bucket4j.grid.GridBucketState;
import io.bucket4j.grid.jcache.JCacheBucketBuilder;
import io.bucket4j.redis.lettuce.Bucket4jLettuce; // 或 Bucket4jJedis
import io.lettuce.core.RedisClient; // 或 JedisPool
import io.lettuce.core.api.StatefulRedisConnection; // 或 Jedis

import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.MutableConfiguration;
import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;
import javax.cache.spi.CachingProvider;
import java.util.concurrent.TimeUnit;

public class RedisRateLimiter {

    private final Bucket bucket;
    private static final String BUCKET_KEY_PREFIX = "rate-limiter:";

    public RedisRateLimiter(String redisUri, String limiterKey, long capacity, long refillTokens, long refillPeriodSeconds) {
        // 使用Lettuce客戶端作為示例
        RedisClient redisClient = RedisClient.create(redisUri);
        StatefulRedisConnection<byte[], byte[]> connection = redisClient.connect(new ByteArrayCodec());

        // Bucket4j的Redis集成需要一個CacheManager，這里我們使用JCache的簡單實現(xiàn)
        CachingProvider cachingProvider = Caching.getCachingProvider();
        CacheManager cacheManager = cachingProvider.getCacheManager();

        MutableConfiguration<String, GridBucketState> configuration = new MutableConfiguration<>();
        configuration.setStoreByValue(false) // 重要：設(shè)置為false以避免序列化問題
                     .setTypes(String.class, GridBucketState.class)
                     .setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ETERNAL)); // 桶狀態(tài)通常不需要過期

        // 創(chuàng)建一個JCache實例，Bucket4j將使用它來管理Redis中的桶狀態(tài)
        Cache<String, GridBucketState> cache = cacheManager.createCache("rate-limiter-cache", configuration);

        // 使用Bucket4jLettuce（或Bucket4jJedis）構(gòu)建ProxyManager
        bucket = Bucket4jLettuce.builder()
                .with == 0 ? connection.sync() : connection.async()) // 使用同步或異步連接
                .build()
                .get ; // 獲取JCacheProxyManager實例

        // 定義限流策略：一個令牌桶，容量為capacity，每refillPeriodSeconds秒補(bǔ)充refillTokens個令牌
        // 這可以模擬滾動窗口的行為，通過調(diào)整容量和補(bǔ)充速率來控制特定時間內(nèi)的請求量
        Bandwidth limit = Bandwidth.simple(capacity, Duration.of(refillTokens, TimeUnit.SECONDS));

        // 根據(jù)limiterKey獲取或創(chuàng)建限流桶
        this.bucket = proxyManager.builder().build(limiterKey, () -> {
            return Bucket.builder().addLimit(limit).build();
        });
    }

    /**
     * 嘗試消耗一個令牌，并返回消耗結(jié)果及退避時間。
     *
     * @param tokensToConsume 嘗試消耗的令牌數(shù)量，通常為1。
     * @return ConsumptionResult 包含是否成功消耗以及重試時間（如果失?。?。
     */
    public ConsumptionResult tryConsume(long tokensToConsume) {
        ConsumptionProbe probe = bucket.tryConsumeAndReturnRemaining(tokensToConsume);

        if (probe.isConsumed()) {
            // 令牌消耗成功
            return new ConsumptionResult(true, probe.getRemainingTokens(), 0);
        } else {
            // 令牌消耗失敗，獲取需要等待的時間
            long nanosToWait = probe.getNanosToWaitForRefill();
            long millisToWait = TimeUnit.NANOSECONDS.toMillis(nanosToWait);
            return new ConsumptionResult(false, probe.getRemainingTokens(), millisToWait);
        }
    }

    // 輔助類用于封裝消耗結(jié)果
    public static class ConsumptionResult {
        private final boolean consumed;
        private final long remainingTokens;
        private final long retryAfterMillis; // 如果未消耗，則為需要等待的毫秒數(shù)

        public ConsumptionResult(boolean consumed, long remainingTokens, long retryAfterMillis) {
            this.consumed = consumed;
            this.remainingTokens = remainingTokens;
            this.retryAfterMillis = retryAfterMillis;
        }

        public boolean isConsumed() {
            return consumed;
        }

        public long getRemainingTokens() {
            return remainingTokens;
        }

        public long getRetryAfterMillis() {
            return retryAfterMillis;
        }

        @Override
        public String toString() {
            return "ConsumptionResult{" +
                   "consumed=" + consumed +
                   ", remainingTokens=" + remainingTokens +
                   ", retryAfterMillis=" + retryAfterMillis +
                   '}';
        }
    }

    // 用于Lettuce連接的字節(jié)數(shù)組編解碼器
    private static class ByteArrayCodec implements io.lettuce.core.codec.RedisCodec<byte[], byte[]> {
        @Override
        public byte[] decodeKey(java.nio.ByteBuffer byteBuffer) {
            byte[] bytes = new byte[byteBuffer.remaining()];
            byteBuffer.get(bytes);
            return bytes;
        }

        @Override
        public byte[] decodeValue(java.nio.ByteBuffer byteBuffer) {
            byte[] bytes = new byte[byteBuffer.remaining()];
            byteBuffer.get(bytes);
            return bytes;
        }

        @Override
        public java.nio.ByteBuffer encodeKey(byte[] bytes) {
            return java.nio.ByteBuffer.wrap(bytes);
        }

        @Override
        public java.nio.ByteBuffer encodeValue(byte[] bytes) {
            return java.nio.ByteBuffer.wrap(bytes);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 示例用法
        // Redis URI: redis://localhost:6379
        RedisRateLimiter limiter = new RedisRateLimiter("redis://localhost:6379", "user:123:api", 10, 10, 60); // 每分鐘10個請求，容量10

        System.out.println("--- 模擬正常請求 ---");
        for (int i = 0; i < 12; i++) {
            ConsumptionResult result = limiter.tryConsume(1);
            System.out.println("請求 " + (i + 1) + ": " + result);
            if (!result.isConsumed()) {
                System.out.println("被限流，請等待 " + result.getRetryAfterMillis() + " 毫秒后重試。");
                // 實際應(yīng)用中，這里可以暫?；蚍祷豀TTP 429并帶上Retry-After頭
                Thread.sleep(result.getRetryAfterMillis() + 10); // 模擬等待
            }
        }
    }
}