基于Redis有序集合实现滑动窗口限流的步骤

2024-12-31 15:50
文章标签 实现 步骤 redis 有序 窗口 滑动 集合 限流

本文主要是介绍基于Redis有序集合实现滑动窗口限流的步骤，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《基于Redis有序集合实现滑动窗口限流的步骤》滑动窗口算法是一种基于时间窗口的限流算法,通过动态地滑动窗口,可以动态调整限流的速率,Redis有序集合可以用来实现滑动窗口限流,本文介绍基于Redis...

滑动窗口算法是一种基于时间窗口的限流算法，它将时间划分为若干个固定大小的窗口，每个窗口内记录了该时间段内的请求次数。通过动态地滑动窗口，可以动态调整限流的速率，以应对不同的流量变化。

整个限流可以概括为两个主要步骤：

  • 统计窗口内的请求数量
  • 应用限流规则

Redis有序集合每个value有一个score（分数），基于score我们可以定义一个时间窗口，然后每次一个请求进来就设置一个value，这样就可以统计窗口内的请求数量。key可以是资源名，比如一个url，或者ip+url，用户标识+url等。value在这里不那么重要，因为我们只需要统计数量，因此value可以就设置成时间戳，但是如果value相同的话就会被覆盖，所以我们可以把请求的数据做一个hash，将这个hash值当value，或者如果每个请求有流水号的话，可以用请求流水号当value，总之就是要能唯一标识一次请求的。

所以，简化后的命令就变成了：

ZADD  资源标识   时间戳   请求标识

public boolean isAllow(String key) {
    ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
    //  获取当前时间戳
    long currentTime = System.currentTimeMillis();
    //  当前时间 - 窗口大小 = 窗口开始时间
    long Windowstart = currentTime - period;
    //  删除窗口开始时间之前的所有数据
    zSetOperations.removeRangeByScore(key, 0, windowStart);
    //  统计窗口中请求数量
    Long count = zSetOperations.zCard(key);
    //  如果窗口中已经请求的数量超过阈值，则直接拒绝
    if (count >= threshold) {
        return false;
    }
    //  没有超过阈值，则加入集合
    String value = "请求唯一标识（比如：请求流水号、哈希值、MD5值等）";
    zSetOperations.add(key, String.valueOf(currentTime), currentTime);
    //  设置一个过期时间，及时清理冷数据
    stringRedisTemplate.expire(key, period, TimeUnit.MILLISECONDS);
    //  通过
    return true;
}

上面代码中涉及到三条Redis命令，并发请求下可能存在问题，所以我们把它们写成Lua脚本

local key = KEYS[1]
local current_time = tonumber(ARGV[1])
local window_size = tonumber(ARGV[2])
local threshold = tonumber(ARGV[3])
redis.call('ZREMRANGEBYSCORE', key, 0, current_time - window_size)
local count = redis.call('ZCARD', key)
if count >= threshold then
    return tostring(0)
else
    redis.call('ZADD', key, tostring(current_time), current_time)
    return tostring(1)
end

完整的代码如下：

package com.example.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.sjavascriptpringframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
import Java.util.Collections;
import java.util.concurrent.TimeUnit;
/**
 * 基于Redis有序集合实现滑动窗口限流
 * @Author: ChengJianSheng
 * @Date: 2024/12/26
 */
@Service
public class SlidingWindowRatelimiter {
    private long period = 60*1000;  //  1分钟
    private int threshold = 3;      //  3次
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    /**
     * RedisTemplate
     */
    public boolean isAllow(String key) {
        ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
        //  获取当前时间戳
        long currentTime = System.currentTimeMillis();
        //  当前时间 - 窗口大小 = 窗口开始时间
        long windowStart = currentTime - period;
        //  删除窗口开始时间之前的所有数据
        zSetOperations.removeRangeByScore(key, 0, windowStart);
        //  统计窗口中请求数量
        Long count = zSetOperations.zCard(key);
        //  如果窗口中已经请求的数量超过阈值，则直接拒绝
        if (count >= threshold) {
            return false;
        }
        //  没有超过阈值，则加入集合
        String value = "请求唯一标识（比如：请求流水号、哈希值、MD5值等）";
        zSetOperations.add(key, String.valueOf(currentTime), currentTime);
        //  设置一个过期时间，及时清理冷数据
        stringRedisTemplate.expire(key, period, TimeUnit.MILLISECONDS);
        //  通过
        return true;
    }
    /**
     * Lua脚本
     */
    public boolean isAllow2(String key) {
        String luaScript = "local key = KEYS[1]\n" +
                "local current_time = tonumberwww.chinasem.cn(ARGV[1])\n" +
                "local window_size = tonumber(ARGV[2])\n" +
                "local threshold = tonumber(ARGV[3])\n" +
                "redis.call('ZREMRANGEBYSCORE', key, 0, current_time - window_size)\n" +
                "local count = redis.call('ZCARD', key)\n" +
                "if count >= threshold then\n" +
                "    return tostring(0)\n" +
                "else\n" +
                "    redis.call('ZADD', key, tostring(current_time), current_time)\n" +
                "    return tostring(1)\n" +
                "end";
        long currentTime = System.currentTimeMillis();
        DefaultRedisScript<String> redisScript = new DefaultRedisScript<>(luaScript, String.class);
        String result = stringRedisTemplate.execute(redisScrphpipt, Collections.singletonList(key), String.valueOf(currentTime), String.valueOf(period), String.valueOf(threshold));
        //  返回1表示通过，返回0表示拒绝
        return "1".equals(result);
    }
}

这里用StringRedisTemplate执行Lua脚本，先把Lua脚本封装成DefaultRedisScript对象。注意，千万注意，Lua脚本的返回值必须是字符串，参数也最好都是字符串，用整型的话可能类型转换错误。

String requestId = UUID.randomUUID().toString();
DefaultRedisScript<String> redisScript = new DefaultRedisScript<>(luaScript, String.class);
String result = stringRedisTemplate.execute(redisScript,
        Collections.singletonList(key),
        requestId,
        String.valueOf(period),
        String.valueOf(threshold));

好了，上面就是基于Redis有序集合实现的滑动窗口限流。顺带提一句，Redis List类型也可以用来实现滑动窗口。

接下来，我们来完善一下上面的代码，通过AOP来拦截请求达到限流的目的

为此，我们必须自定义注解，然后根据注解参数，来个性化的控制限流。那么，问题来了，如果获取注解参数呢？

举例说明：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnjsotation {
    String value();
}
@ASPect
@Component
public class MyAspect {
    @Before("@annotation(myAnnotation)")
    public void beforeMethod(JoinPoint joinPoint, MyAnnotation myAnnotation) {
        // 获取注解参数
        String value = myAnnotation.value();
        System.out.println("Annotation value: " + value);
        // 其他业务逻辑...
    }
}

注意看，切点是怎么写的 @Before("@annotation(myAnnotation)")

是@Before("@annotation(myAnnotation)")，而不是@Before("@annotation(MyAnnotation)")

myAnnotation，是参数，而MyAnnotation则是注解类

基于Redis有序集合实现滑动窗口限流的步骤

此处参考资料

https://www.cnblogs.com/javaxubo/p/16556924.html

https://blog.csdn.net/qq_40977118/article/details/119488358

https://blog.51cto.com/knifeedge/5529885

言归正传，我们首先定义一个注解

package com.example.demo.controller;
import java.lang.annotation.*;
/**
 * 请求速率限制
 * @Author: ChengJianSheng
 * @Date: 2024/12/26
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    /**
     * 窗口大小（默认：60秒）
     */
    long period() default 60;
    /**
     * 阈值（默认：3次）
     */
    long threshold() default 3;
}

定义切面

package com.example.demo.controller;
import jakarta.servlet.http.HttpServletRejavascriptquest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.support.RequestContextUtils;
import java.util.concurrent.TimeUnit;
/**
 * @Author: ChengJianSheng
 * @Date: 2024/12/26
 */
@Slf4j
@Aspect
@Component
public class RateLimitAspect {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
//    @Autowired
//    private SlidingWindowRatelimiter slidingWindowRatelimiter;
    @Before("@annotation(rateLimit)")
    public void doBefore(JoinPoint joinPoint, RateLimit rateLimit) {
        //  获取注解参数
        long period = rateLimit.period();
        long threshold = rateLimit.threshold();
        //  获取请求信息
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest httpServletRequest = servletRequestAttributes.getRequest();
        String uri = httpServletRequest.getRequestURI();
        Long userId = 123L;     //  模拟获取用户ID
        String key = "limit:" + userId + ":" + uri;
        /*
        if (!slidingWindowRatelimiter.isAllow2(key)) {
            log.warn("请求超过速率限制！userId={}, uri={}", userId, uri);
            throw new RuntimeException("请求过于频繁！");
        }*/
        ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
        //  获取当前时间戳
        long currentTime = System.currentTimeMillis();
        //  当前时间 - 窗口大小 = 窗口开始时间
        long windowStart = currentTime - period * 1000;
        //  删除窗口开始时间之前的所有数据
        zSetOperations.removeRangeByScore(key, 0, windowStart);
        //  统计窗口中请求数量
        Long count = zSetOperations.zCard(key);
        //  如果窗口中已经请求的数量超过阈值，则直接拒绝
        if (count < threshold) {
            //  没有超过阈值，则加入集合
            zSetOperations.add(key, String.valueOf(currentTime), currentTime);
            //  设置一个过期时间，及时清理冷数据
            stringRedisTemplate.expire(key, period, TimeUnit.SECONDS);
        } else {
            throw new RuntimeException("请求过于频繁！");
        }
    }
}

加注解

@RestController
@RequestMapping("/hello")
public class HelloController {
    @RateLimit(period = 30, threshold = 2)
    @GetMapping("/sayHi")
    public void sayHi() {
    }
}

最后，看Redis中的数据结构

基于Redis有序集合实现滑动窗口限流的步骤

最后的最后，流量控制建议看看阿里巴巴 Sentinel

https://sentinelguard.io/zh-cn/

到此这篇关于基于Redis有序集合实现滑动窗口限流的文章就介绍到这了,更多相关基于Redis有序集合实现滑动窗口限流内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！

这篇关于基于Redis有序集合实现滑动窗口限流的步骤的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1152869。

相关文章

C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
vite搭建vue3项目的搭建步骤

vite搭建vue3项目的搭建步骤

《vite搭建vue3项目的搭建步骤》本文主要介绍了vite搭建vue3项目的搭建步骤,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学... 目录1.确保Nodejs环境2.使用vite-cli工具3.进入项目安装依赖1.确保Nodejs环境
阅读更多...
Nginx搭建前端本地预览环境的完整步骤教学

Nginx搭建前端本地预览环境的完整步骤教学

《Nginx搭建前端本地预览环境的完整步骤教学》这篇文章主要为大家详细介绍了Nginx搭建前端本地预览环境的完整步骤教学,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录项目目录结构核心配置文件：nginx.conf脚本化操作：nginx.shnpm 脚本集成总结：对前端的意义很多
阅读更多...
Python实现字典转字符串的五种方法

Python实现字典转字符串的五种方法

《Python实现字典转字符串的五种方法》本文介绍了在Python中如何将字典数据结构转换为字符串格式的多种方法,首先可以通过内置的str()函数进行简单转换;其次利用ison.dumps()函数能够... 目录1、使用json模块的dumps方法：2、使用str方法：3、使用循环和字符串拼接：4、使用字符
阅读更多...
Redis 基本数据类型和使用详解

Redis 基本数据类型和使用详解

《Redis基本数据类型和使用详解》String是Redis最基本的数据类型,一个键对应一个值,它的功能十分强大,可以存储字符串、整数、浮点数等多种数据格式,本文给大家介绍Redis基本数据类型和... 目录一、Redis 入门介绍二、Redis 的五大基本数据类型2.1 String 类型2.2 Hash
阅读更多...
Linux云服务器手动配置DNS的方法步骤

Linux云服务器手动配置DNS的方法步骤

《Linux云服务器手动配置DNS的方法步骤》在Linux云服务器上手动配置DNS（域名系统）是确保服务器能够正常解析域名的重要步骤,以下是详细的配置方法,包括系统文件的修改和常见问题的解决方案,需要... 目录1. 为什么需要手动配置 DNS？2. 手动配置 DNS 的方法方法 1：修改 /etc/res
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2