文章目录
什么是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脚本中，主要做了三件事：
- 递增访问次数
- 设置键的过期时间
- 返回当前访问次数
直接使用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);
}
}