Java Redis多限流

在现代Web应用中，限流（Rate Limiting）是保护系统资源和防止滥用的重要机制。Redis由于其高性能和原子操作特性，成为实现限流的理想选择。本文将详细介绍如何在Java中使用Redis实现多种限流策略，包括固定窗口限流、滑动窗口限流和令牌桶算法。

一、准备工作

1. 安装Redis

确保Redis已经安装并正在运行。可以通过以下命令安装Redis：

sudo apt-get update
sudo apt-get install redis-server
sudo service redis-server start
​

2. 添加依赖

在Java项目中使用Redis，推荐使用Jedis库。以下是Maven依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.0</version>
</dependency>
​

二、固定窗口限流

固定窗口限流是最简单的限流算法。它将时间划分为固定的窗口，每个窗口内限制请求次数。

1. 实现逻辑

每当一个请求到达时，检查当前窗口内的请求数量是否超过限制。如果未超过，则允许请求并增加计数；否则，拒绝请求。

2. 示例代码

import redis.clients.jedis.Jedis;

public class FixedWindowRateLimiter {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final int LIMIT = 10; // 每窗口的最大请求数
    private static final int WINDOW_SIZE = 60; // 窗口大小（秒）

    private Jedis jedis;

    public FixedWindowRateLimiter() {
        this.jedis = new Jedis(REDIS_HOST, REDIS_PORT);
    }

    public boolean isAllowed(String userId) {
        String key = "rate_limit:" + userId;
        long currentWindow = System.currentTimeMillis() / 1000 / WINDOW_SIZE;
        String windowKey = key + ":" + currentWindow;

        if (jedis.exists(windowKey)) {
            if (Integer.parseInt(jedis.get(windowKey)) < LIMIT) {
                jedis.incr(windowKey);
                return true;
            } else {
                return false;
            }
        } else {
            jedis.setex(windowKey, WINDOW_SIZE, "1");
            return true;
        }
    }

    public static void main(String[] args) {
        FixedWindowRateLimiter limiter = new FixedWindowRateLimiter();
        String userId = "user123";

        for (int i = 0; i < 15; i++) {
            System.out.println("Request " + (i + 1) + ": " + limiter.isAllowed(userId));
        }
    }
}
​

三、滑动窗口限流

滑动窗口限流能够更精确地控制请求速率，避免固定窗口算法中临界点的突发流量问题。

1. 实现逻辑

滑动窗口限流记录每个请求的时间戳，并在每次请求时清理过期的记录。

2. 示例代码

import redis.clients.jedis.Jedis;
import java.util.stream.Collectors;
import java.util.List;

public class SlidingWindowRateLimiter {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final int LIMIT = 10; // 每窗口的最大请求数
    private static final int WINDOW_SIZE = 60; // 窗口大小（秒）

    private Jedis jedis;

    public SlidingWindowRateLimiter() {
        this.jedis = new Jedis(REDIS_HOST, REDIS_PORT);
    }

    public boolean isAllowed(String userId) {
        String key = "sliding_rate_limit:" + userId;
        long currentTime = System.currentTimeMillis() / 1000;
        long windowStart = currentTime - WINDOW_SIZE;

        // 清理过期请求
        jedis.zremrangeByScore(key, 0, windowStart);

        // 获取当前窗口内的请求数量
        long count = jedis.zcard(key);
        if (count < LIMIT) {
            jedis.zadd(key, currentTime, String.valueOf(currentTime));
            jedis.expire(key, WINDOW_SIZE);
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        SlidingWindowRateLimiter limiter = new SlidingWindowRateLimiter();
        String userId = "user123";

        for (int i = 0; i < 15; i++) {
            System.out.println("Request " + (i + 1) + ": " + limiter.isAllowed(userId));
        }
    }
}
​

四、令牌桶算法

令牌桶算法是一种常用的流量整形算法，能够控制数据的流入速率。

1. 实现逻辑

令牌桶算法通过定时向桶中添加令牌，每次请求消耗一个令牌，如果桶为空则拒绝请求。

2. 示例代码

import redis.clients.jedis.Jedis;

public class TokenBucketRateLimiter {
    private static final String REDIS_HOST = "localhost";
    private static final int REDIS_PORT = 6379;
    private static final int MAX_TOKENS = 10; // 最大令牌数
    private static final int REFILL_RATE = 1; // 每秒添加令牌数

    private Jedis jedis;

    public TokenBucketRateLimiter() {
        this.jedis = new Jedis(REDIS_HOST, REDIS_PORT);
    }

    public boolean isAllowed(String userId) {
        String key = "token_bucket:" + userId;
        long currentTime = System.currentTimeMillis() / 1000;

        // 获取最后更新时间和当前令牌数
        String[] bucketInfo = jedis.hmget(key, "tokens", "timestamp").toArray(new String[0]);
        int tokens = bucketInfo[0] != null ? Integer.parseInt(bucketInfo[0]) : MAX_TOKENS;
        long lastRefillTime = bucketInfo[1] != null ? Long.parseLong(bucketInfo[1]) : currentTime;

        // 计算需要添加的令牌数
        long timeDiff = currentTime - lastRefillTime;
        int newTokens = (int) Math.min(MAX_TOKENS, tokens + timeDiff * REFILL_RATE);

        if (newTokens > 0) {
            jedis.hmset(key, Map.of("tokens", String.valueOf(newTokens - 1), "timestamp", String.valueOf(currentTime)));
            jedis.expire(key, MAX_TOKENS / REFILL_RATE); // 设置过期时间
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        TokenBucketRateLimiter limiter = new TokenBucketRateLimiter();
        String userId = "user123";

        for (int i = 0; i < 15; i++) {
            System.out.println("Request " + (i + 1) + ": " + limiter.isAllowed(userId));
        }
    }
}
​

五、总结

通过本文的介绍，我们详细讲解了如何在Java中使用Redis实现三种不同的限流策略：固定窗口限流、滑动窗口限流和令牌桶算法。每种限流策略都有其适用的场景和特点，根据具体需求选择合适的限流策略可以有效保护系统资源和提高服务的稳定性。