【Redisson】Redisson--限流器

文章介绍了Redisson的限流器功能,用于限制接口调用频率,防止缓存击穿。通过RateLimiter实现基于Redis的分布式限流,例如每10秒允许一次短信发送。限流器使用令牌桶算法,trySetRate设置令牌生成速率,tryAcquire检查并获取令牌。文章还解析了trySetRate和tryAcquire的底层实现,涉及Redis的HSETNX和GET命令。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Redisson系列文章:

一、限流器作用

基于Redis的分布式限流器RateLimiter可以用来在分布式环境下现在请求方的调用频率。既适用于不同Redisson实例下的多线程限流,也适用于相同Redisson实例下的多线程限流。

RateLimter主要作用就是可以限制调用接口的次数。主要原理就是调用接口之前,需要拥有指定个令牌。限流器每秒会产生X个令牌放入令牌桶,调用接口需要去令牌桶里面拿令牌。如果令牌被其它请求拿完了,那么自然而然,当前请求就调用不到指定的接口。

二、主要使用业务场景

  1. 单机或分布式情况下的缓存击穿
  2. 接口需要限制调用次数

三、代码

RRateLimiter rateLimiter = redisson.getRateLimiter("myRateLimiter");
// 初始化
// 最大流速 = 每10秒钟产生1个令牌
rateLimiter.trySetRate(RateType.OVERALL, 1, 10, RateIntervalUnit.SECONDS);
//需要1个令牌
if(rateLimiter.tryAcquire(1)){
    //TODO:Do something 
}

当前业务就是,向指定手机号发送短信。但是有每10秒只允许发送1次的限制。完全可以使用Redisson限流器来完成。

package com.tyzhou.redisson.service;
 
import com.tyzhou.Constant;
import org.apache.commons.lang3.StringUtils;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 

@Service
public class RateLimiterService {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(RateLimiterService.class);
 
    @Autowired
    private RedissonClient redisson;
 
    public void sendMsg(String phone) {
        if (StringUtils.isNotBlank(phone)) {
            RRateLimiter rateLimiter =
                    redisson.getRateLimiter(Constant.REDISSON_RATE_LIMITER + phone);
            //每10秒产生1个令牌
            rateLimiter.trySetRate(RateType.OVERALL, 1, 10,
                    RateIntervalUnit.SECONDS);
 
            if (rateLimiter.tryAcquire(1)) {
                LOGGER.info("向手机:{}发送短信", phone);
            }
        }
    }
}

调用者:

@PostMapping("/send_msg")
public void sendMsg(@RequestParam String phone) {
    while(true){
        rateLimiterService.sendMsg(phone);
    }
}

用了一个死循环,但是从日志的打印效果上来看,每10秒才请求到一次我们的发送短信接口。

在这里插入图片描述

四、原理

4.1、getRateLimiter

// 声明一个限流器 名称 叫key
redissonClient.getRateLimiter(key)

4.2、trySetRate

trySetRate方法跟进去底层实现如下:

@Override
    public RFuture<Boolean> trySetRateAsync(RateType type, long rate, long rateInterval, RateIntervalUnit unit) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "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]);",
                Collections.<Object>singletonList(getName()), rate, unit.toMillis(rateInterval), type.ordinal());
    }

举个例子,更容易理解:

比如下面这段代码,5秒中产生3个令牌,并且所有实例共享(RateType.OVERALL所有实例共享、RateType.CLIENT单实例端共享)

trySetRate(RateType.OVERALL, 3, 5, RateIntervalUnit.SECONDS);

那么redis中就会设置3个参数:

hsetnx,key,rate,3

hsetnx,key,interval,5

hsetnx,key,type,0

接着看tryAcquire(1)方法:底层源码如下

private <T> RFuture<T> tryAcquireAsync(RedisCommand<T> command, Long value) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
                "local rate = redis.call('hget', KEYS[1], 'rate');"  //1
              + "local interval = redis.call('hget', KEYS[1], 'interval');"  //2
              + "local type = redis.call('hget', KEYS[1], 'type');" //3
              + "assert(rate ~= false and interval ~= false and type ~= false, 'RateLimiter is not initialized')" //4
              
              + "local valueName = KEYS[2];" //5
              + "if type == 1 then "
                  + "valueName = KEYS[3];" //6
              + "end;"
              
              + "local currentValue = redis.call('get', valueName); " //7
              + "if currentValue ~= false then " 
                     + "if tonumber(currentValue) < tonumber(ARGV[1]) then " //8
                         + "return redis.call('pttl', valueName); "
                     + "else "
                         + "redis.call('decrby', valueName, ARGV[1]); " //9
                         + "return nil; "
                     + "end; "
              + "else " //10
                     + "redis.call('set', valueName, rate, 'px', interval); " 
                     + "redis.call('decrby', valueName, ARGV[1]); "
                     + "return nil; "
              + "end;",
                Arrays.<Object>asList(getName(), getValueName(), getClientValueName()), 
                value, commandExecutor.getConnectionManager().getId().toString());
    }
  • 第1、2、3备注行是获取上一步set的3个值:rate、interval、type,如果这3个值没有设置,直接返回rateLimiter没有被初始化。
  • 第5备注行声明一个变量叫valueName 值为KEYS[2],KEYS[2]对应的值是getValueName()方法,getValueName()返回的就是上面第一步getRateLimiter我们设置的key;如果type=1,表示全局共享,那么valueName 的值改为取KEYS[3],KEYS[3]对应的值为getClientValueName(),查看getClientValueName()源码:
String getClientValueName() {
        return suffixName(getValueName(), commandExecutor.getConnectionManager().getId().toString());
   }
ConnectionManager().getId()如下:
public interface ConnectionManager {
    
    UUID getId();
 
    省略...
}

这个getId()是每个客户端初始化的时候生成的UUID,即每个客户端的getId是唯一的,这也就验证了trySetRate方法中RateType.ALL与RateType.PER_CLIENT的作用。

  • 接着看第7标准行,获取valueName对应的值currentValue;首次获取肯定为空,那么看第10标准行else的逻辑
  • set valueName 3 px 5,设置key=valueName value=3 过期时间为5秒
  • decrby valueName 1,将上面valueName的值减1
  • 那么如果第二次访问,第7标注行返回的值存在,将会走第8标注行,紧接着走如下判断
  • 如果当前valueName的值也就是3,小于要获得的令牌数量(tryAcquire方法中的入参),那么说明当前时间内(key的有效期5秒内),令牌的数量已经被用完,返回pttl(key的剩余过期时间);反之说明桶中有足够的令牌,获取之后将会把桶中的令牌数量减1,至此结束。

总结

redission分布式限流采用令牌桶思想和固定时间窗口,trySetRate方法设置桶的大小,利用redis key过期机制达到时间窗口目的,控制固定时间窗口内允许通过的请求量。

<think>嗯,用户之前问过关于Redis Starter的问题,现在又想知道Spring Boot的两个Starter:spring-boot-starter-data-redisredisson-spring-boot-starter之间的关系。我需要先理清楚这两个组件的区别和联系。 首先,用户可能是在使用Spring Boot集成Redis时遇到了选择哪个Starter的问题,或者对两者的功能有疑惑。他们可能已经知道基础的Redis集成,但需要更高级的功能,比如分布式锁或者其他Redis高级特性,所以才会提到Redisson。 接下来,我需要回忆这两个Starter的作用。Spring Boot官方的starter-data-redis是基于Lettuce或Jedis的,提供基本的连接和操作模板,比如RedisTemplate。而Redisson的starter则是基于Redisson客户端,支持更多的分布式服务,比如分布式集合、锁、调度等。两者都是用来集成Redis,但实现的客户端不同,功能侧重点不同。 用户可能想知道它们是否可以一起使用,或者是否有冲突。需要解释它们各自的定位,比如官方starter适合基础操作,Redisson适合需要分布式功能的场景。同时,要指出两者在配置上的差异,比如Redisson可能需要不同的配置方式,使用YAML文件而不是简单的host和port。 另外,用户可能对如何选择这两个Starter感到困惑,需要给出使用场景的建议。比如,如果只需要缓存和简单的数据操作,官方Starter足够;但如果需要分布式锁、分布式对象,就应该选Redisson。还要提到在极端情况下可以混合使用,但需要处理配置冲突的问题。 需要注意之前用户的问题中已经提到了配置示例和自动配置类,这次回答可能需要对比两者的配置方式,比如Redisson使用自己的配置文件格式,而官方Starter用Spring的配置属性。还要提到依赖管理的区别,比如Redisson需要引入自己的starter依赖,而官方的是Spring Boot自带的。 可能用户在实际项目中遇到了依赖冲突,或者配置不生效的情况,所以需要强调版本兼容性和配置隔离的重要性。比如,如果同时使用两个客户端,需要确保它们不互相干扰,可能要通过自定义配置类来明确指定各自的连接工厂。 最后,总结两者的关系是互补和替代并存,根据需求选择合适的工具。同时,提醒用户注意版本匹配,避免因为版本不一致导致的问题。</think>以下是关于 `spring-boot-starter-data-redis` 与 `redisson-spring-boot-starter` 的对比解析,通过三个维度说明它们的关系: --- ### 一、**核心定位对比** | **组件** | **核心能力** | **适用场景** | |------------------------------|----------------------------------------------------------------------------|-----------------------------------| | `spring-boot-starter-data-redis` | Spring 官方提供的 Redis 基础集成:<br>- 基于 Lettuce/Jedis 客户端<br>- 提供 `RedisTemplate` 等基础 API<br>- 支持简单缓存、数据存储 | 需要基本 Redis 操作的常规场景 | | `redisson-spring-boot-starter` | Redisson 客户端的高级封装:<br>- 实现分布式对象(Map、Lock、Queue 等)<br>- 支持哨兵/集群模式<br>- 提供延迟队列、布隆过滤器等高级功能 | 分布式系统开发(如分布式锁、分布式限流、复杂数据结构) | --- ### 二、**技术实现差异** #### 1. **客户端架构** - **官方 Starter** ```java // 默认使用 Lettuce 连接池 LettuceConnectionFactory factory = new LettuceConnectionFactory(); RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); ``` 优势:轻量级,I/O 多路复用,适合高并发简单操作 - **Redisson Starter** ```java // 基于 Netty 的异步非阻塞模型 Config config = new Config(); config.useSingleServer().setAddress("redis://127.0.0.1:6379"); RedissonClient client = Redisson.create(config); ``` 优势:支持 60+ 分布式对象,提供 RPC 式调用接口 #### 2. **配置方式对比** - **官方 Starter** ```yaml spring: redis: host: localhost port: 6379 lettuce: pool: max-active: 8 ``` - **Redisson Starter** ```yaml redisson: config: | singleServerConfig: address: "redis://localhost:6379" connectionMinimumIdleSize: 5 ``` --- ### 三、**协同与互斥关系** #### 1. **依赖冲突** - **不可共存场景** 若同时引入两个 Starter 且未隔离配置,会导致: - `RedisTemplate` 与 `RedissonClient` 使用不同连接池 - 配置参数互相覆盖(如超时时间、连接数) #### 2. **混合使用方案** ```java @Configuration public class DualClientConfig { // 官方 Starter 的 RedisTemplate @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { return new RedisTemplate<>(){/* 基础操作 */}; } // Redisson 客户端(独立配置) @Bean(destroyMethod = "shutdown") public RedissonClient redissonClient() { Config config = new Config(); config.useClusterServers().addNodeAddress("redis://node1:6379"); return Redisson.create(config); } } ``` **注意事项**:需确保两个客户端使用不同的 Redis 数据库或独立配置连接池 --- ### **选择建议** 1. **优先官方 Starter**:若仅需缓存、简单 K-V 存储 2. **必选 Redisson**:若涉及以下场景: ```markdown - 分布式锁(RLock) - 分布式限流(RRateLimiter) - 跨 JVM 的 Topic 消息广播 - 延迟队列(RDelayedQueue) ``` 3. **慎用混合模式**:仅在明确需求分离时使用(如基础操作与高级功能分离) --- ### **版本兼容性** | Spring Boot 版本 | 官方 Starter 推荐版本 | Redisson Starter 推荐版本 | |----------------|---------------------|-------------------------| | 2.7.x | 2.7.18 | 3.23.2 | | 3.1.x | 3.1.5 | 3.25.0 | 建议通过 `mvn dependency:tree` 验证依赖树,避免客户端版本冲突。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值