【智能排班系统】基于Redis的increment命令和lua脚本实现IP限流

什么是IP限流？

IP限流旨在对来自特定IP地址的网络访问请求进行速率限制或次数控制。每个联网设备在访问互联网时都会有一个独一无二的IP地址，如同在网络世界中的“身份证”。IP限流就像是网络服务的“门卫”，根据预设的规则，对每个IP地址的访问行为进行监控与调节

为什么需要IP限流？

保护服务器资源

想象一下，如果你经营一家在线商店，突然间涌入大量顾客，每个人都争先恐后地抢购商品。短时间内，汹涌的人潮可能会导致货架被扫空、收银台前排起长龙，甚至店铺设施不堪重负

同样，互联网服务也面临着类似的挑战。当大量访问请求集中涌向服务器时，如果不加以控制，可能会导致服务器性能急剧下降，响应速度变慢，甚至崩溃

IP限流就像为服务器安装了一道智能闸门，它可以有条不紊地放行访问请求，避免服务器资源被过度消耗。通过限制单个IP地址的访问速率或次数，既能确保正常用户能够顺畅地使用服务，又能有效防止因短时间内大量请求引发的服务器过载

防范恶意攻击与滥用

并非所有的网络访问都是善意的。有些IP地址可能属于恶意爬虫、自动化攻击工具或是滥用服务的用户。他们可能出于各种目的，如数据抓取、DDoS攻击、刷票、刷赞等，以极高频率发送请求，严重干扰服务的正常运行，甚至对数据安全构成威胁

IP限流能够识别并拦截这类异常访问行为。通过对特定IP地址施加严格的访问限制，可以有效地阻止恶意攻击，保护服务免受侵害，同时也遏制了滥用行为，维护了服务的公平使用环境

提升用户体验

在没有IP限流的情况下，某些IP地址的过度访问可能导致服务器响应速度变慢，影响所有用户的服务体验。尤其是当恶意用户或爬虫占用了大量资源时，普通用户的请求可能会长时间得不到响应，导致网页加载缓慢、应用卡顿等问题

通过实施IP限流，可以确保服务器资源得到合理分配，优先服务于正常用户，从而提升整体的用户体验。当恶意或过度访问被有效抑制时，服务器能够更快地响应大多数用户的请求，使得网页加载更迅速、应用操作更流畅

IP限流方式：

• 速率限制：设置每个IP地址在一定时间周期内（如每分钟、每小时）的最大请求次数或数据传输速率
• 次数限制：规定每个IP地址在指定时间段内（如一天、一周）可以访问特定服务的总次数

本文主要实现速率限制，如限制一秒内，同一ip只能发起50次请求

实现

实现原理

使用Redis的increment自增计数功能，并给相应键设置一个过期时间，如果同一个键的计数在过期时间之前超出了上限，则说明该IP的请求过于频繁，需要对其进行限流

代码结构

lua脚本

-- 获取 Redis 中存储用户访问次数的键名
local accessKey = KEYS[1]
-- 时间窗口，单位：秒
local timeWindow = tonumber(ARGV[1])

-- 原子递增访问次数，并获取递增后的值
local currentAccessCount = redis.call("INCR", accessKey)
-- 设置键的过期时间
redis.call("EXPIRE", accessKey, timeWindow)

-- 返回当前访问次数
return currentAccessCount

为什么要使用lua脚本

在上述lua脚本中，主要做了三件事：

1. 递增访问次数
2. 设置键的过期时间
3. 返回当前访问次数

直接使用stringRedisTemplate.opsForValue().increment()只能递增访问次数，无法设置键的过期时间，因此需要使用lua脚本来保证上述操作的原子性

Ip限流工具类

import com.alibaba.fastjson.JSON;
import com.dam.configuration.IpFlowControlConfiguration;
import com.dam.constant.RedisConstant;
import com.dam.model.enums.ResultCodeEnum;
import com.dam.model.result.R;
import com.google.common.collect.Lists;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.scripting.support.ResourceScriptSource;

import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.List;

/**
 * IP限流工具类，提供基于Redis Lua脚本实现的IP地址访问频率限制功能。
 *
 * @Author dam
 * @create 2024/3/15 20:41
 */
@Slf4j
public class FlowLimitUtil {
    /**
     * 存储IP限流Lua脚本的路径常量。
     */
    private static final String IP_FLOW_CONTROL_LUA_SCRIPT_PATH = "lua/ip_flow_control.lua";

    /**
     * 使用单例模式存储编译后的IP限流Lua脚本实例，避免每次调用时重复加载和编译。
     */
    private static DefaultRedisScript<Long> redisScript;

    /**
     * 获取或初始化IP限流Lua脚本实例。使用synchronized保证只有一个线程初始化实例
     *
     * @return 编译后的IP限流Lua脚本实例
     */
    public static DefaultRedisScript<Long> getRedisScriptInstance() {
        if (redisScript == null) {
            synchronized (FlowLimitUtil.class) {
                redisScript = new DefaultRedisScript<>();
                // 首先获取Redis的lua脚本
                redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource(IP_FLOW_CONTROL_LUA_SCRIPT_PATH)));
                // 设置脚本返回值的类型
                redisScript.setResultType(Long.class);
            }
        }
        return redisScript;
    }


    /**
     * 根据IP地址、HttpServletResponse、StringRedisTemplate、IpFlowControlConfiguration和主题（topic）执行IP限流检查。
     * 如果IP地址的访问频率超过配置的限制，将返回错误响应。
     *
     * @param ipAddr              客户端IP地址
     * @param response            HttpServletResponse对象，用于设置返回给客户端的响应
     * @param stringRedisTemplate Spring Data Redis模板，用于执行Lua脚本
     * @param ipFlowControlConfig IP限流配置对象，包含时间窗口和最大访问次数等参数
     * @param topic               请求的主题，用于区分不同类型的请求限流
     * @return true表示访问频率未超过限制，可以继续处理请求；false表示访问频率超出限制，已返回错误响应
     */
    @SneakyThrows
    public static boolean ipFlowLimit(String ipAddr, HttpServletResponse response, StringRedisTemplate stringRedisTemplate,
                                      IpFlowControlConfiguration ipFlowControlConfig, String topic) {
        // 执行Lua脚本
        Long result = executeIpFlowControlLuaScript(stringRedisTemplate, ipAddr, topic, ipFlowControlConfig.getTimeWindow());

        // 检查返回结果是否为空或超出最大访问次数
        if (result == null || result > ipFlowControlConfig.getMaxAccessCount()) {
            // 返回错误响应，提示访问太频繁
            returnJson(response, JSON.toJSONString(R.error(ResultCodeEnum.FAIL.getCode(), "请求太频繁，请稍后尝试")));
            return false;
        }
        return true;
    }

    /**
     * 根据IP地址、HttpServletResponse、StringRedisTemplate、时间窗口、最大访问次数和主题（topic）执行IP限流检查。
     * 如果IP地址的访问频率超过指定的限制，将返回错误响应并设置HttpServletResponse状态码和内容。
     *
     * @param ipAddr              客户端IP地址
     * @param response            HttpServletResponse对象，用于设置返回给客户端的响应
     * @param stringRedisTemplate Spring Data Redis模板，用于执行Lua脚本
     * @param timeWindow          时间窗口（单位：秒），用于计算IP地址在指定时间内的访问次数
     * @param maxAccessCount      最大访问次数限制
     * @param topic               请求的主题，用于区分不同类型的请求限流
     * @return true表示访问频率未超过限制，可以继续处理请求；false表示访问频率超出限制，已返回错误响应
     */
    @SneakyThrows
    public static boolean ipFlowLimit(String ipAddr, HttpServletResponse response, StringRedisTemplate stringRedisTemplate,
                                      String timeWindow, Long maxAccessCount, String topic) {
        // 执行Lua脚本
        Long result = executeIpFlowControlLuaScript(stringRedisTemplate, ipAddr, topic, timeWindow);

        // 检查返回结果是否为空或超出最大访问次数
        if (result == null || result > maxAccessCount) {
            // 返回错误响应，提示访问太频繁
            returnJson(response, JSON.toJSONString(R.error(ResultCodeEnum.FAIL.getCode(), "请求太频繁，请稍后尝试")));
            return false;
        }
        return true;
    }

    /**
     * 私有方法，封装执行IP限流Lua脚本的逻辑，简化代码重复。
     *
     * @param stringRedisTemplate Spring Data Redis模板
     * @param ipAddr              客户端IP地址
     * @param topic               请求的主题
     * @param timeWindow          时间窗口（单位：秒）
     * @return 执行Lua脚本的返回结果（访问次数）
     */
    private static Long executeIpFlowControlLuaScript(StringRedisTemplate stringRedisTemplate, String ipAddr, String topic, String timeWindow) {
        // 组织Lua脚本参数列表
        List<String> scriptArgs = Lists.newArrayList(
                RedisConstant.IP_FLOW_CONTROL + RedisConstant.SEPARATE + topic + RedisConstant.SEPARATE + ipAddr
        );

        try {
            // 执行Lua脚本，获取返回结果
            return stringRedisTemplate.execute(getRedisScriptInstance(), scriptArgs, timeWindow);
        } catch (Throwable ex) {
            log.error("执行请求流量限制LUA脚本出错", ex);
            // 抛出异常，全局拦截器无法捕获，需要使用returnJson方法返回错误信息
            throw new RuntimeException("执行请求流量限制LUA脚本出错", ex);
        }
    }

    /**
     * 设置HttpServletResponse的响应头，并输出JSON格式的错误信息。
     *
     * @param response HttpServletResponse对象
     * @param json     JSON格式的错误信息字符串
     * @throws Exception 可能抛出的异常
     */
    private static void returnJson(HttpServletResponse response, String json) throws Exception {
        // 设置响应头
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");

        // 输出JSON格式的错误信息
        try (PrintWriter writer = response.getWriter()) {
            writer.print(json);
        }
    }

}

对所有接口进行限流

IP限流请求过滤器

注意这里的topic设置为interface，表示该ip访问所有被拦截的接口是一起计数的

import com.dam.configuration.IpFlowControlConfiguration;
import com.dam.utils.FlowLimitUtil;
import com.dam.utils.ip.IpUtils;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @Author dam
 * @create 2024/3/15 19:29
 */
@Slf4j
@RequiredArgsConstructor
public class IpFlowLimitFilter extends OncePerRequestFilter {
    /**
     * Spring Data Redis模板，用于执行IP限流相关的Redis操作。
     */
    private final StringRedisTemplate stringRedisTemplate;
    /**
     * IP访问频率控制配置，包含时间窗口、最大访问次数等限流规则。
     */
    private final IpFlowControlConfiguration ipFlowControlConfiguration;

    /**
     * 实现父类OncePerRequestFilter的doFilterInternal方法，对请求进行IP限流检查。
     * 如果IP访问频率未超过限制，则放行请求；否则，返回错误响应并终止过滤链。
     *
     * @param request     当前HTTP请求
     * @param response    当前HTTP响应
     * @param filterChain 过滤链对象，用于继续传递请求到后续过滤器或目标处理器
     * @throws ServletException 如果在过滤过程中抛出Servlet相关异常
     * @throws IOException      如果在过滤过程中抛出IO相关异常
     */
    @SneakyThrows
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
//        System.out.println("IP限流过滤");
        // 获取用户ip
        String ipAddr = IpUtils.getIpAddr(request);
        // 执行IP访问频率检查，如果超过限制则直接返回错误响应，否则继续处理请求
        if (!FlowLimitUtil.ipFlowLimit(ipAddr, response, stringRedisTemplate, ipFlowControlConfiguration, "interface")) {
            // IP访问频率已超过限制，已返回错误响应，无需继续过滤链
            return;
        }
        // 如果上面没有报错，放行
        filterChain.doFilter(request, response);
    }

}

SpringSecurity中配置过滤器

本文将限流过滤器置于权限验证过滤器之前，因为限流过滤器的操作更加省时，可以更快地过滤掉不合理请求

对不经过SpringSecurity的过滤器的请求进行限流

对于系统的部分接口，并不需要经过登录验证和权限验证，不会经过SpringSecurity的过滤器，例如登录验证码接口，用户都还没有登录，肯定无法经过登录验证和权限验证

以验证码接口为例

注意这里的topic设置为"loginCode"，自此可见topic的作用便是对不同接口的IP限流进行区分

/**
 * 生成验证码
 *
 * @return
 */
@GetMapping("/generateVerificationCode")
public R generateVerificationCode(HttpServletRequest request, HttpServletResponse response) {
    // 获取用户ip
    String ipAddr = IpUtils.getIpAddr(request);
    // 调用IP限流方法对请求进行限流
    FlowLimitUtil.ipFlowLimit(ipAddr, response, redisTemplate, "1", 5L, "loginCode");
    // 将验证码存储到redis中
    String uuid = UUID.randomUUID().toString().replace("-", "");
    String image = loginService.generateVerificationCode(uuid);
    return R.ok().addData("uuid", uuid).addData("image", image);
}

获取IP工具类

该工具来自若依管理系统

import com.dam.utils.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 获取IP方法
 *
 * @author ruoyi
 */
public class IpUtils {
    /**
     * 获取客户端IP
     *
     * @param request 请求对象
     * @return IP地址
     */
    public static String getIpAddr(HttpServletRequest request) {
        if (request == null) {
            return "unknown";
        }
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : getMultistageReverseProxyIp(ip);
    }

    /**
     * 检查是否为内部IP地址
     *
     * @param ip IP地址
     * @return 结果
     */
    public static boolean internalIp(String ip) {
        byte[] addr = textToNumericFormatV4(ip);
        return internalIp(addr) || "127.0.0.1".equals(ip);
    }

    /**
     * 检查是否为内部IP地址
     *
     * @param addr byte地址
     * @return 结果
     */
    private static boolean internalIp(byte[] addr) {
        if (StringUtils.isNull(addr) || addr.length < 2) {
            return true;
        }
        final byte b0 = addr[0];
        final byte b1 = addr[1];
        // 10.x.x.x/8
        final byte SECTION_1 = 0x0A;
        // 172.16.x.x/12
        final byte SECTION_2 = (byte) 0xAC;
        final byte SECTION_3 = (byte) 0x10;
        final byte SECTION_4 = (byte) 0x1F;
        // 192.168.x.x/16
        final byte SECTION_5 = (byte) 0xC0;
        final byte SECTION_6 = (byte) 0xA8;
        switch (b0) {
            case SECTION_1:
                return true;
            case SECTION_2:
                if (b1 >= SECTION_3 && b1 <= SECTION_4) {
                    return true;
                }
            case SECTION_5:
                switch (b1) {
                    case SECTION_6:
                        return true;
                }
            default:
                return false;
        }
    }

    /**
     * 将IPv4地址转换成字节
     *
     * @param text IPv4地址
     * @return byte 字节
     */
    public static byte[] textToNumericFormatV4(String text) {
        if (text.length() == 0) {
            return null;
        }

        byte[] bytes = new byte[4];
        String[] elements = text.split("\\.", -1);
        try {
            long l;
            int i;
            switch (elements.length) {
                case 1:
                    l = Long.parseLong(elements[0]);
                    if ((l < 0L) || (l > 4294967295L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l >> 24 & 0xFF);
                    bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 2:
                    l = Integer.parseInt(elements[0]);
                    if ((l < 0L) || (l > 255L)) {
                        return null;
                    }
                    bytes[0] = (byte) (int) (l & 0xFF);
                    l = Integer.parseInt(elements[1]);
                    if ((l < 0L) || (l > 16777215L)) {
                        return null;
                    }
                    bytes[1] = (byte) (int) (l >> 16 & 0xFF);
                    bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 3:
                    for (i = 0; i < 2; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    l = Integer.parseInt(elements[2]);
                    if ((l < 0L) || (l > 65535L)) {
                        return null;
                    }
                    bytes[2] = (byte) (int) (l >> 8 & 0xFF);
                    bytes[3] = (byte) (int) (l & 0xFF);
                    break;
                case 4:
                    for (i = 0; i < 4; ++i) {
                        l = Integer.parseInt(elements[i]);
                        if ((l < 0L) || (l > 255L)) {
                            return null;
                        }
                        bytes[i] = (byte) (int) (l & 0xFF);
                    }
                    break;
                default:
                    return null;
            }
        } catch (NumberFormatException e) {
            return null;
        }
        return bytes;
    }

    /**
     * 获取IP地址
     *
     * @return 本地IP地址
     */
    public static String getHostIp() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) {
        }
        return "127.0.0.1";
    }

    /**
     * 获取主机名
     *
     * @return 本地主机名
     */
    public static String getHostName() {
        try {
            return InetAddress.getLocalHost().getHostName();
        } catch (UnknownHostException e) {
        }
        return "未知";
    }

    /**
     * 从多级反向代理中获得第一个非unknown IP地址
     *
     * @param ip 获得的IP地址
     * @return 第一个非unknown IP地址
     */
    public static String getMultistageReverseProxyIp(String ip) {
        // 多级反向代理检测
        if (ip != null && ip.indexOf(",") > 0) {
            final String[] ips = ip.trim().split(",");
            for (String subIp : ips) {
                if (false == isUnknown(subIp)) {
                    ip = subIp;
                    break;
                }
            }
        }
        return ip;
    }

    /**
     * 检测给定字符串是否为未知，多用于检测HTTP请求相关
     *
     * @param checkString 被检测的字符串
     * @return 是否未知
     */
    public static boolean isUnknown(String checkString) {
        return StringUtils.isBlank(checkString) || "unknown".equalsIgnoreCase(checkString);
    }
}