004-基于Redis自定义注解实现限流配置

已于 2023-03-08 05:16:30 修改
阅读量327 收藏 1
点赞数 1
分类专栏： # ①-JAVA脚手架 文章标签： redis java 缓存
于 2022-08-25 13:49:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46914264/article/details/126522665
版权

🧑‍🎓 个人主页：Silence Lamb

📖 本章内容：【基于Redis自定义注解实现限流配置】

一、Redis配置

1.1【Maven依赖】

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

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

1.2【Redis信息】

spring:
    redis:
      host: 127.0.0.1
      port: 6379
      database: 0
      timeout: 1800000
      lettuce:
        pool:
          max-active: 20
          max-wait: -1
          max-idle: 5
          min-idle: 0

1.3【Redis配置类】

/**
 * @author Silence Lamb
 * @apiNote Redis配置
 */
@EnableCaching //开启缓存
@Configuration  //配置类
public class RedisConfig extends CachingConfigurerSupport {
  

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    @SuppressWarnings("all")
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

1.4【Redis工具类】

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisUtils {
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return redisTemplate.delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
}

二、限流配置

2.1【限流脚本】

/**
 * @author Silence Lamb
 * @apiNote redis脚本常量
 */
@Component
public class RedisCacheConstant {
    @ApiModelProperty("加锁脚本")
    public static final String LOCK_LUA = "if redis.call('setNx',KEYS[1],ARGV[1]) == 1 then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end";

    @ApiModelProperty("解锁脚本")
    public static final String RELEASE_LOCK_LUA = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    @ApiModelProperty("限流脚本")
    public static final String LIMITER_LUA = "local key = KEYS[1] local count = tonumber(ARGV[1]) local time = tonumber(ARGV[2]) local current = redis.call('get', key); if current and tonumber(current) > count then return tonumber(current); end current = redis.call('incr', key) if tonumber(current) == 1 then redis.call('expire', key, time) end return tonumber(current)";
}

/**
 * @author Silence Lamb
 * @apiNote 脚本配置
 */
public class RedisScript {
    /**
     * 限流脚本
     *
     * @return
     */
    @Bean
    public DefaultRedisScript<Long> limitScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(RedisCacheConstant.LIMITER_LUA);
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 加锁脚本
     *
     * @return
     */
    @Bean
    public DefaultRedisScript<Long> lockScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(RedisCacheConstant.LOCK_LUA);
        redisScript.setResultType(Long.class);
        return redisScript;
    }

    /**
     * 解锁脚本
     */
    @Bean
    public DefaultRedisScript<Long> ReleaseLockScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(RedisCacheConstant.RELEASE_LOCK_LUA);
        redisScript.setResultType(Long.class);
        return redisScript;
    }
}

2.2【缓存常量】

/**
 * @author Silence Lamb
 * @apiNote 缓存常量
 */
public class RedisCacheConstant {
    private static final String RATE_LIMIT_KEY = "rate:limit:key";
}

 /**
  * @author Silence Lamb
  * @Describe: 限流类型
  */
public enum LimitType {

    @ApiModelProperty("默认策略全局限流")
    DEFAULT,

    @ApiModelProperty("根据请求者IP进行限流")
    IP
}

/**
 * @author SilenceLamb
 * @apiNote 自定义业务异常
 */
public final class ServiceException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    @ApiModelProperty("业务名称")
    private String name;

    @ApiModelProperty("错误码")
    private Integer code;

    @ApiModelProperty("错误提示")
    private String msg;

    @ApiModelProperty("错误明细，内部调试错误")
    private String detailMessage;

    public ServiceException() {
    }

    public ServiceException(String name, Throwable e) {
        super(e.getMessage(), e);
        this.name = name;
    }

    public ServiceException(String msg) {
        this.msg = msg;
    }

    public ServiceException(String msg, Integer code) {
        this.msg = msg;
        this.code = code;
    }

    public ServiceException(String name, String msg, Integer code) {
        this.name = name;
        this.msg = msg;
        this.code = code;
    }

    public ServiceException(String name, String msg) {
        this.name = name;
        this.msg = msg;
    }

    public String getDetailMessage() {
        return detailMessage;
    }

    public String getName() {
        return name;
    }

    @Override
    public String getMessage() {
        return msg;
    }

    public Integer getCode() {
        return code;
    }

    public ServiceException setMessage(String msg) {
        this.msg = msg;
        return this;
    }

    public ServiceException setDetailMessage(String detailMessage) {
        this.detailMessage = detailMessage;
        return this;
    }
}

2.3【限流注解】

/**
 * @author Silence Lamb
 * @apiNote 限流注解
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimiter {

    @ApiModelProperty("限流key")
    String key() default RedisCacheConstant.RATE_LIMIT_KEY;

    @ApiModelProperty("限流时间,单位秒")
    int time() default 60;

    @ApiModelProperty("限流次数")
    int count() default 100;

    @ApiModelProperty("限流类型")
    LimitType limitType() default LimitType.DEFAULT;
}

2.4【限流切面类】

/**
 * @Author: 花棉袄
 * @CreateDate: 2022年08月23日
 * @Describe: 限流处理处理 切面类
 */
@Aspect
@Component
public class RateLimiterAspect {
    private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);

    private RedisTemplate<Object, Object> redisTemplate;

    private RedisScript<Long> limitScript;

    @Autowired
    public void setRedisTemplate(RedisTemplate<Object, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Autowired
    public void setLimitScript(RedisScript<Long> limitScript) {
        this.limitScript = limitScript;
    }

    @Before("@annotation(rateLimiter)")
    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
        String key = rateLimiter.key();
        int time = rateLimiter.time();
        int count = rateLimiter.count();

        String combineKey = getCombineKey(rateLimiter, point);
        List<Object> keys = Collections.singletonList(combineKey);
        try {
            /* 判断redis中的缓存key的值是否存在且大于限制的次数 */
            Long number = redisTemplate.execute(limitScript, keys, count, time);
            if (StringUtils.isNull(number) || number.intValue() > count) {
                /* 缓存过于频繁 */
                throw new ServiceException("Redis限流业务","访问过于频繁，请稍候再试");
            }
            log.info("限制请求最大次数'{}',当前请求次数'{}',缓存的key'{}'", count, number.intValue(), key);
        } catch (ServiceException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException("服务器限流异常，请稍候再试");
        }
    }
	
     /**
     * 获取缓存的key
     */
    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {
        StringBuffer stringBuffer = new StringBuffer(rateLimiter.key());
        if (rateLimiter.limitType() == LimitType.IP) {
            stringBuffer.append(IpUtils.getIpAddress(ServletUtils.getRequest())).append("-");
        }
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        stringBuffer.append(targetClass.getName()).append("-").append(method.getName());
        return stringBuffer.toString();
    }
     /**
     * 获取request
     */
    public  HttpServletRequest getRequest() {
        ServletRequestAttributes attributes = 
            (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        return attributes.getRequest();
    }
}

2.5【限流测试】

/**
 * @Author: 花棉袄
 * @CreateDate: 2022年08月28日
 * @Describe: 限流测试
 */
@RestController
@RequestMapping("/test")
public class LimitController {

    @RateLimiter
    @GetMapping("/limit")
    @ApiOperation(value = "", notes = "")
    public AjaxResult list() {
        return AjaxResult.success();
    }
}

限制请求最大次数'100',当前请求次数'1',缓存的key'rate:limit:key'
限制请求最大次数'100',当前请求次数'2',缓存的key'rate:limit:key'
限制请求最大次数'100',当前请求次数'3',缓存的key'rate:limit:key'
限制请求最大次数'100',当前请求次数'4',缓存的key'rate:limit:key'
限制请求最大次数'100',当前请求次数'5',缓存的key'rate:limit:key'
🏅 项目地址：📢💨基于Redis实现限流功能
Silence Lamb
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Boot通过自定义注解和Redis+Lua脚本实现接口限流教程配套源码
06-09
该源码对应个人博客【Spring Boot通过自定义注解和Redis+Lua脚本实现接口限流】教程的相关源码，小伙伴可以自行下载学习！不需要积分！不需要积分！不需要积分！ 如果相关资源对您有所帮助，希望一键三连给博主一...
自定义注解+redis实现简单接口限流
weixin_46666822的博客
04-08 184
/ 在 second 秒内，最大只能请求 maxCount 次 int second() default 1;@Target({ElementType.METHOD,ElementType.TYPE}) 指定这个注解可以用在方法或者类上（或者接口）@Retention(RetentionPolicy.RUNTIME) 指定注解的生命周期是运行时。首先要明确生命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作用的地方后者一定也能作用。
springboot高级教程基于 redis 通过注解实现限流
qq_34874784的博客
06-23 705
2. 编写切面类`RedisLimitAspect`，在方法执行前调用`RedisLimit`组件实现限流。注意：在使用`@RedisLimit`注解时，每个方法对应的key不应该相同，否则会出现相互干扰的情况。1. 自定义注解`@RedisLimit`，并定义注解元素，如限流的时间、限流的次数等。可以通过自定义注解的方式来标注需要限流的方法，在方法执行前进行限流的检查。4. 在需要进行限流的方法上添加`@RedisLimit`注解。
使用redis配合注解实现接口的限流
m0_56915985的博客
07-15 145
使用redis配合注解实现接口的限流（滑动窗口版本）
基于 Redis 实现接口限流
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
05-25 6195
基于 Redis 实现接口限流 文章目录基于 Redis 实现接口限流1. 准备工作2. 限流注解3. 定制 RedisTemplate4. 开发 Lua 脚本5. 注解解析6. 接口测试7. 全局异常处理总结 Redis 除了做缓存，还能干很多很多事情：分布式锁、限流、处理请求接口幂等性。。。太多太多了～ 今天想和小伙伴们聊聊用 Redis 处理接口限流，这也是最近的 TienChin 项目涉及到这个知识点了，我就拎出来和大家聊聊这个话题，后面视频也会讲。 1. 准备工作 首先我们创建一个 Spring
RequestRateLimiter 的配置装配流程分析
本博客纯属个人网络笔记，如对阁下有用，甚喜；否则，关掉即可，不喜勿喷。专心写代码，不做键盘侠！
10-25 1772
这几天分析 `RequestRateLimterGatewayFilter` 的源码，一直对 `RedisRateLimter` 的限流参数是怎么绑定的这个问题困扰。本文来分析每个路由的限流参数绑定的细节，关键在于 `FilterArgsEvent` 事件的触发监听上。
基于Redis+Lua脚本实现分布式限流组件封装的方法
12-14
本篇文章将探讨如何基于Redis和Lua脚本实现一个分布式限流组件的封装，以便在Spring Boot应用中优雅地控制请求速率。 首先，我们需要在`pom.xml`文件中引入必要的依赖。这里引入了`spring-boot-starter-data-redis`...
springboot注解+aop实现接口限流
09-07
springboot框架中使用自定义注解，配合切面实现接口...可以学会自定义注解使用、自定义响应码枚举及使用、自定义异常类及使用、aop的使用、自定义动态配置全局配置项及使用、ip解析工具、自定义redis缓存key枚举及使用
Springboot使用redis进行api防刷限流过程详解
08-25
Spring Boot 结合 Redis 实现 API 防刷限流的过程主要涉及到两个核心概念：限流算法和缓存机制。在本文中，我们将深入探讨如何利用 Redis 的存储特性以及 Spring Boot 的强大框架支持来构建一个高效的 API 限流系统...
aop切面注解-限流与防止重复提交-2.docx
06-30
FrequentlyRepetition 是一个自定义注解，用于防止重复提交和限流。该注解有四个属性：key、cycle、count 和 msg。 * key：限流的 key，用于存储在 Redis 中。 * cycle：周期，单位是秒，用于设置限流的时间间隔。 ...
springbot + redis脚本 自定义注解实现限流
javaxueba的博客
06-09 110
4- redis 相关配置类编写 以及 lua定义。reids配置类 定义序列化json机制，Spring Aop 进行前置拦截，reids lua脚本统计访问的次数。2.properties配置。1.pom.xml 依赖。访问超过三次，返回异常。
自定义注解基于redis实现频控限流、分布式id、分布式锁
最新发布
xx_shawn的博客
04-11 729
该注解主要通过aop切面配合redis实现，接口/方法访问的频率限制，可以根据IP和用户id等信息进行限制。该注解主要通过aop切面配合redis实现在多服务实例下，系统可以共享一套id。该注解主要通过aop切面配合redis实现在多服务实例并发下，可以实现共享资源的安全访问。该分布式实现两种获取锁策略①获取不到直接放弃执行 ②获取不到在指定获取锁超时时间内重复获取，同时支持锁的自动续约，保证在业务执行完毕前，不丢失锁，从而保证资源的安全访问。
redis(lua) Spring(AOP) 自定义注解实现限流
qq_25426583的博客
10-27 729
redis(lua) Spring(AOP) 自定义注解实现限流
SpringBoot-基于注解实现Redis限流
爱笑的boy的博客
05-16 781
SpringBoot-基于注解实现Redis限流 Redis 除了做缓存，还能干很多很多事情：分布式锁、限流、处理请求接口幂等性。。。太多太多了～ 大家好我是llp，今天在午休时看到了一篇关于Redis限流的文章，一时就激起了我的兴趣，于是就有了这篇文章，内容其实大多都是根据博主的来的，只是自己跟着走了一遍而已，留个笔记便于以后回顾吧。 1. 准备工作 首先我们创建一个 Spring Boot 工程，引入 Web 和 Redis 依赖，同时考虑到接口限流一般是通过注解来标记，而注解是通过 AOP 来解析的
springboot：自定义注解+redis实现接口限流
Wanankl的博客
02-02 425
自定义注解+redis实现接口限流
SpringBoot自定义限流注解（redis实现）
luomo0203的博客
11-23 633
***/*** 限流前缀* @return/*** 限流时间窗/*** 时间窗内的限流次数* @return/*** 限流类型* @return}./***/*** 限流前缀* @return/*** 限流时间窗/*** 时间窗内的限流次数* @return/*** 限流类型* @return}./***/*** 限流前缀* @return/*** 限流时间窗/*** 时间窗内的限流次数。
自定义注解 + 拦截器 + Redis 实现限流
weixin_40910372的博客
01-04 863
前言 在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流。 缓存：缓存的目的是提升系统访问速度和增大系统处理容量 降级：降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开 限流：限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理 背景 最近项目生产环...
springboot+redis+lua实现限流
lgq2016的博客
02-22 1013
reids限流
SpringBoot结合redis自定义注解实现限流
z394642048的博客
05-29 1047
1.创建一个注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Limit { // 资源名称，用于描述接口功能 String name() default ""; // 资源 key String key() default ""; ...
springboot注解实现redis限流
04-20
很高兴回答这个问题。SpringBoot注解实现Redis限流可以使用@RedisRateLimiter注解和自定义一个Aspect类实现。@RedisRateLimiter注解可以设置限流的时间单位、阈值以及针对哪个API进行限流。自定义的Aspect类则可以将注解解析出来，并使用Redis进行限流判断。这样可以在高并发的情况下保证接口的可用性和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Silence Lamb

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值