RRateLimiter的使用

原创 已于 2025-10-29 13:27:53 修改 · 382 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redisson #java #限流

于 2025-09-27 17:49:05 首次发布

Redisson 的 RRateLimiter 是一个分布式限流器，用于在分布式系统中控制访问速率。

基本用法

导入jar

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.24.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

配置类

package com.qfedu.ratelimit.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient getRedisson() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://127.0.0.1:6379")
                .setRetryInterval(5000)
                .setTimeout(10000)
                .setConnectTimeout(10000);
        return Redisson.create(config);
    }
}

通过控制器测试

@RestController
public class TestController {

    @Resource
    private RedissonClient redissonClient;

    @GetMapping("/test")
    public String test() {
        // 根据key获取限流器实例
        RRateLimiter rateLimiter = redissonClient.getRateLimiter("limit:1");
        // 初始化限流器，本例表示5秒内产生3个许可     
        rateLimiter.trySetRate(RateType.OVERALL, 3, 5, RateIntervalUnit.SECONDS);

        // 尝试获取许可，获取到返回true，否则返回false
        boolean ret1 = rateLimiter.tryAcquire(1);
        System.out.println(ret1);
        boolean ret2 = rateLimiter.tryAcquire(1);
        System.out.println(ret2);
        boolean ret3 = rateLimiter.tryAcquire(1);
        System.out.println(ret3);
        // 第四次获取许可，返回false，表示不能访问
        boolean ret4 = rateLimiter.tryAcquire(1);
        System.out.println(ret4);
        return "success";
    }

}

关于trySetRate的说明

其中trySetRaet()的第一个参数表示RateType有两个值：

  • RateType.OVERALL: 全局限流（所有实例共享）

  • RateType.PER_CLIENT: 按客户端限流（需要配置客户端标识）

第二个参数表示限流的最大次数

第三个参数表示限流的时间间隔

第四个参数表示限流的时间间隔的单位

通过查看源码，其内部执行了如下的lua脚本

redis.call('hsetnx', KEYS[1], 'rate', ARGV[1]);
redis.call('hsetnx', KEYS[1], 'interval', ARGV[2]);
return redis.call('hsetnx', KEYS[1], 'type', ARGV[3]);

其内部使用hsetnx，如果对应的key和field存在，则不会创建field

通过自定义注解和AOP进行封装

工具类

package com.qfedu.ratelimit.aspect;

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

public class IpAddressUtil {

    /**
     * 获取客户端真实IP地址
     */
    public static String getClientIpAddress() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String[] headers = {
                "X-Forwarded-For",
                "X-Real-IP",
                "Proxy-Client-IP",
                "WL-Proxy-Client-IP",
                "HTTP_CLIENT_IP",
                "HTTP_X_FORWARDED_FOR"
        };

        // 1. 检查各种代理头信息
        for (String header : headers) {
            String ip = request.getHeader(header);
            if (isValidIp(ip)) {
                return getFirstIp(ip);
            }
        }

        // 2. 直接获取远程地址
        String remoteAddr = request.getRemoteAddr();
        if (isValidIp(remoteAddr)) {
            return remoteAddr;
        }

        throw new RuntimeException("无法获取远程ip地址");
    }

    /**
     * 验证IP地址是否有效
     */
    private static boolean isValidIp(String ip) {
        return ip != null &&
                !ip.isEmpty() &&
                !"unknown".equalsIgnoreCase(ip) &&
                !"0:0:0:0:0:0:0:1".equals(ip) &&
                !"127.0.0.1".equals(ip);
    }

    /**
     * 处理多个IP的情况（如X-Forwarded-For: client, proxy1, proxy2）
     */
    private static String getFirstIp(String ip) {
        if (ip.contains(",")) {
            String[] ips = ip.split(",");
            for (String singleIp : ips) {
                String trimmedIp = singleIp.trim();
                if (isValidIp(trimmedIp)) {
                    return trimmedIp;
                }
            }
        }
        return ip.trim();
    }
}
package com.qfedu.ratelimit.aspect;

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

public class TokenUtils {

    /**
     * 通过token获取用户id
     *
     * @return
     */
    public static Integer getUidFromToken() {
        // 动态获取HttpServletRequest对象
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        String token = request.getHeader("Authorization");
//        if (token == null || token.isEmpty()) {
//            throw new RuntimeException("请重新登录");
//        }
//        Claims claims = JwtUtils.parseJWT(token);
//        Object uid = claims.get("uid");
//        return Integer.valueOf(uid.toString());

        // 本例为了方便测试，写死返回的用户id
        return 123;
    }
}

枚举

package com.qfedu.ratelimit.aspect;


public enum RateLimitTypeEnum {

    TYPE_IP(1, "根据IP限流"),
    TYPE_USER(2, "根据用户限流");

    private int type;
    private String desc;

    RateLimitTypeEnum(int type, String desc) {
        this.type = type;
        this.desc = desc;
    }
}

自定义注解

package com.qfedu.ratelimit.aspect;

import org.redisson.api.RateIntervalUnit;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    RateLimitTypeEnum type() default RateLimitTypeEnum.TYPE_USER;

    // String key() default "";

    long rate() default 10;

    long interval() default 60;

    RateIntervalUnit unit() default RateIntervalUnit.SECONDS;

    String message() default "请求过于频繁，请稍后再试";
}

切面类

package com.qfedu.ratelimit.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class RateLimitAspect {

    @Autowired
    private RedissonClient redissonClient;

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {

        String suffix = null;
        if (rateLimit.type() == RateLimitTypeEnum.TYPE_IP) {
            suffix = IpAddressUtil.getClientIpAddress();
        } else if (rateLimit.type() == RateLimitTypeEnum.TYPE_USER) {
            suffix = TokenUtils.getUidFromToken().toString();
        }

        String key = "rate:limit:" + suffix;

        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        rateLimiter.trySetRate(RateType.OVERALL,
                rateLimit.rate(),
                rateLimit.interval(),
                rateLimit.unit());

        if (!rateLimiter.tryAcquire()) {
            throw new RuntimeException(rateLimit.message());
        }

        return joinPoint.proceed();
    }

}

测试控制层方法

    @RateLimit(type = RateLimitTypeEnum.TYPE_USER, rate = 10, interval = 60)
    @GetMapping("/test2")
    public String test2() {
        return "success";
    }

根据配置，执行到第11次时，报错

RRateLimiter使用的限流算法

RRateLimiter 使用的是令牌桶算法（Token Bucket Algorithm）

令牌桶算法的工作机制：

  1. 令牌生成：系统以固定速率向桶中添加令牌

  2. 令牌消耗：请求需要获取令牌才能被处理

  3. 桶容量：桶有最大容量，防止令牌无限累积

  4. 限流逻辑：当桶中有足够令牌时请求通过，否则被限流

令牌桶 vs 漏桶算法

特性令牌桶算法漏桶算法
突发流量允许一定程度的突发严格限制，平滑输出
灵活性更灵活，可应对突发更严格，输出恒定
实现复杂度相对简单相对复杂
适用场景API限流、流量控制网络流量整形

漏桶算法（Leaky Bucket Algorithm）核心概念：
漏桶算法是一种流量整形算法，它以恒定的速率处理请求，无论输入流量多么不规则。

工作机制：
请求到达，请求以任意速率进入桶中，相当于水流入，水量增加
恒定处理，以固定速率从桶中取出请求处理，相当于水流出，水以恒定速率从底部漏出
溢出拒绝：当桶满时，新请求被丢弃或拒绝，类似水满则溢

redisson之RRateLimiter分布式限流
寻梦友的博客
11-27 1377
底层trySetRate方法同样是Lua脚本来实现。可以通过上面的文章了解自我实现分布式限流的逻辑，RRateLimiter原理就很清晰了。这篇文章有介绍，自己通过Lua脚本来实现分布式限流。如果是集成的Jedis等下，是可以采用这篇文章的方法自我实现。在redisson中，已经有现成的RRateLimiter分布式限流，下面就介绍下这个类怎么使用。
Redisson限流器RRateLimiter使用及源码分析
青鸟飞鱼
07-20 3203
redission分布式限流采用令牌桶思想和固定时间窗口，trySetRate方法设置桶的大小，利用redis key过期机制达到时间窗口目的，控制固定时间窗口内允许通过的请求量。
Redisson 分布式限流器 RRateLimiter 的使用及原理
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
01-16 7630
基本使用、实现原理
Redisson分布式限流RRateLimiter的实现原理
qq_41625866的博客
03-13 4598
Redisson分布式限流RRateLimiter的实现原理
分布式限流 redission RRateLimiter 的使用及原理
MayMatrix 的博客
11-08 5834
redission分布式限流采用令牌桶思想和固定时间窗口，trySetRate方法设置桶的大小，利用redis key过期机制达到时间窗口目的，控制固定时间窗口内允许通过的请求量。
分布式限流redission RRateLimiter使用及原理
热门推荐
promisessh的博客
01-18 1万+
前提： 最近公司在做有需求在做分布式限流，调研的限流框架大概有 1、spring cloud gateway集成redis限流,但属于网关层限流 2、阿里Sentinel,功能强大、带监控平台 3、srping cloud hystrix，属于接口层限流，提供线程池与信号量两种方式 4、其他：redission、手撸代码 实际需求情况属于业务端限流，redission更加方便，使用更加灵活，下面介绍下redission分布式限流如何使用及原理： 一、使用 使用很简单、如下 //.
SpringBoot项目接入redisson实现分布式锁+RRateLimiter限流(JDK21)
qq_32954567的博客
04-26 882
SpringBoot项目接入redission实现分布式锁+RRateLimiter限流
RRateLimiter 如何使用
最新发布
06-28
使用 RRateLimiter 可以有效地防止系统因突发流量而崩溃，并保障服务的稳定性和可用性。 ### 配置与初始化 在 Spring Boot 项目中，首先需要引入 Redisson 的依赖，并配置 RedissonClient 实例。例如，在 `pom.xml...
Redisson 限流器 RRateLimiter的使用
Software As Business
05-07 4293
限流器是什么 当单位时间内，产生并发访问时，在诸如抢购场景下，只有10件库存。而用户如果都进行争夺则会产生所谓的超卖问题。这时候用限流器进行限制，则可以很好的解决。使得单位时间内只有指定线程数的客户可以访问，未访问到的客户则进行其他处理。 redisson提供了封装好的限流器，此次便使用 其中的RRateLimiter限流器作为实验demo Demo public class redissonTest { //手动创建线程池，符合阿里规范 private static fi
【开发经验】java代码中实现限流
叁滴水 的博客
07-08 4062
限流目的 限流的目的是防止恶意请求流量、恶意攻击、或者防止流量超过系统峰值。 流量达到峰值时，会有一个熔断策略，常见的熔断策略： 直接拒绝请求，跳转到一个“服务器出小差”页面 排队等待，比如火车票等待。 服务降级，返回最基本的用户可接受的数值。 到达峰值的时候进行排队。 定位经纬度定位，精确定位到达峰值，返回大概定位，比如百度地图，有时候可以定位到自己的详细位置，有时候显示自己所在的城市。 限流方式 漏桶 ​ 漏桶是有一个进水口，一个出水口。桶本身具有一个恒定的速率往下漏水，而上方时快时慢的会有
基于Redis组件之分布式RateLimiter限流
BugRoot的博客
05-18 9213
上文我们介绍了RateLimiter文章路径针对IP来限流的方式，上文的限流方案，只针对单应用情况，分布式集群下就不能使用上文的方式，分布式下的限流方案有很多种,这边展示的是Redis的封装redission框架。 可以这么讲，jdk中的juc包提供的是单机版的并发业务。那么Redisson基本是基于juc实现的分布式的业务。 一：Redission官网 我们先去Redission官网喵喵 redission官方地址 我们可以看到wiki提供了很多功能介绍， 分布式锁等，我们这篇文章主要讲限流。进入正题
redisson分布式限流[RRateLimiter]源码分析
BASK2311的博客
10-30 1133
接前面和，简单以源码的方式给大家介绍了redisson的：可重入性、阻塞、续约、红锁、联锁、加锁解锁流程和集成spring boot注意点和优雅实现方式。接下来在讲一讲平时用的比较多的限流模块--
深入解析 Redisson 分布式限流器 RRateLimiter 的原理与实现
博客
12-31 1340
在分布式系统中，限流（Rate Limiting）是保障系统稳定性、避免过载的重要机制。Redisson 作为一个功能强大的 Redis 客户端，不仅提供了广泛使用的分布式锁，还包含了许多其他实用的分布式工具。其中，RRateLimiter 是 Redisson 提供的分布式限流器，功能强大。本文将详细解析 RRateLimiter 的原理，深入理解其工作机制。
Redisson分布式限流器RRateLimiter原理解析
MayMatrix 的博客
11-08 1392
因为公司的开放网关的限流模块就是基于Redisson开发的，之前看的版本源码与最新的已经有很大的不同，趁着整理知识点的机会下了最新版的源码看了一遍。限流这个说简单也简单，说复杂也复杂。不知道是不是我看的东西太少，我觉得redisson的限流器设计非常精巧，感觉把redis玩穿了。
Redisson 的 RRateLimiter 限流
ttyy1112的专栏
02-20 881
Redisson 的属于类别，它基于 Redis 实现分布式限流，可归类到前文提到的方案中，但 Redisson 对其进行了更高层次的封装。
Redisson之限流器RRateLimiter应用
qq_34373761的博客
12-03 2167
需求背景： 已知第三方接口限流策略，比如60次/min，那在内部调用第三方接口时，为避免过多无效请求，造成ip被封的风险，故需引入限流器，此处采用Redisson中RRateLimiter限流器；
使用redis限流 -- redisson实现
喜欢分享,善于记录工作中遇到的问题,和自己的思考
11-09 1629
请。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值