Redis实现IP限流的两种方式详解

最新推荐文章于 2024-08-09 23:58:44 发布
最新推荐文章于 2024-08-09 23:58:44 发布
阅读量207 收藏 4
点赞数 2
分类专栏： java springboot 分布式 文章标签： redis lua springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45079985/article/details/141061340
版权
java 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
分布式
3 篇文章 0 订阅
订阅专栏
springboot
2 篇文章 0 订阅
订阅专栏

gateway网关ip限流

通过reids实现

  1. 限流的流程图

    image-20240809111850316

  2. 在配置文件配置限流参数

    blackIP:
  # ip 连续请求的次数
  continue-counts: ${counts:3}
  # ip 判断的时间间隔，单位：秒
  time-interval: ${interval:20}
  # 限制的时间，单位：秒
  limit-time: ${time:30}

  3. 编写全局过滤器类

    package com.ajie.gateway.filter;

import com.ajie.common.enums.ResponseStatusEnum;
import com.ajie.common.result.GraceJSONResult;
import com.ajie.common.utils.CollUtils;
import com.ajie.common.utils.IPUtil;
import com.ajie.common.utils.JsonUtils;
import com.ajie.common.utils.RedisUtil;
import io.netty.handler.codec.http.HttpHeaderNames;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.MimeTypeUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author: ajie
 */
@Slf4j
@Component
public class IpLimitFilterJwt implements GlobalFilter, Ordered {

    @Autowired
    private UrlPathProperties urlPathProperties;
    @Value("${blackIP.continue-counts}")
    private Integer continueCounts;
    @Value("${blackIP.time-interval}")
    private Integer timeInterval;
    @Value("${blackIP.limit-time}")
    private Integer limitTime;
    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取当前的请求路径
        String path = exchange.getRequest().getURI().getPath();

        // 2.获得所有的需要限流的url
        List<String> ipLimitUrls = urlPathProperties.getIpLimitUrls();
        // 3.校验并且排除excludeList
        if (CollUtils.isNotEmpty(ipLimitUrls)) {
            for (String url : ipLimitUrls) {
                if (antPathMatcher.matchStart(url, path)) {
                    log.warn("IpLimitFilterJwt--url={}", path);
                    // 进行ip限流
                    return doLimit(exchange, chain);
                }
            }
        }
        // 默认直接放行
        return chain.filter(exchange);
    }

    private Mono<Void> doLimit(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取真实ip
        ServerHttpRequest request = exchange.getRequest();
        String ip = IPUtil.getIP(request);

        /**
         * 需求：
         * 判断ip在20秒内请求的次数是否超过3次
         * 如果超过，则限制访问30秒
         * 等待30秒以后，才能够恢复访问
         */
        // 正常ip
        String ipRedisKey = "gateway_ip:" + ip;
        // 被拦截的黑名单，如果存在，则表示该ip已经被限制访问
        String ipRedisLimitedKey = "gateway_ip:limit:" + ip;
        long limitLeftTime = RedisUtil.KeyOps.getExpire(ipRedisLimitedKey);
        if (limitLeftTime > 0) {
            return renderErrorMsg(exchange, ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP);
        }
        // 在redis中获得ip的累加次数
        long requestTimes = RedisUtil.StringOps.incrBy(ipRedisKey, 1);
        // 如果访问次数为1，则表明是第一次访问，在redis设置倒计时
        if (requestTimes == 1) {
            RedisUtil.KeyOps.expire(ipRedisKey, timeInterval, TimeUnit.SECONDS);
        }

        // 如果访问次数超过限制的次数，直接将该ip存入限制的redis key，并设置限制访问时间
        if (requestTimes > continueCounts) {
            // 设置该ip需要被限流的时间
            RedisUtil.StringOps.setEx(ipRedisLimitedKey, ip, limitTime, TimeUnit.SECONDS);
            return renderErrorMsg(exchange, ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP);
        }
        return chain.filter(exchange);
    }

    public Mono<Void> renderErrorMsg(ServerWebExchange exchange, ResponseStatusEnum statusEnum) {
        // 1.获得response
        ServerHttpResponse response = exchange.getResponse();
        // 2.构建jsonResult
        GraceJSONResult jsonResult = GraceJSONResult.exception(statusEnum);
        // 3.修改response的code为500
        response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
        // 4.设定header类型
        if (!response.getHeaders().containsKey("Content-Type")) {
            response.getHeaders().add(HttpHeaderNames.CONTENT_TYPE.toString(), MimeTypeUtils.APPLICATION_JSON_VALUE);
        }
        // 5.转换json并且向response写入数据
        String jsonStr = JsonUtils.toJsonStr(jsonResult);
        DataBuffer dataBuffer = response.bufferFactory()
                .wrap(jsonStr.getBytes(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(dataBuffer));
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

通过Lua+Redis实现

业务流程还是和上图差不多，只不过gateway网关不用再频繁和redis进行交互。整个限流逻辑放在redis层，通过Lua代码嵌套

  1. Lua实现限流的代码

    --[[
ipRedisLimitedKey：限流的redis key
ipRedisKey：未被限流的redis key，通过此key计算访问次数
timeInterval：访问时间间隔，在此时间内，访问到指定次数进行限流
limitTime：限流的时长
]]
-- 判断当前ip是否已经被限流
if redis.call("ttl", ipRedisLimitedKey) > 0 then
    return 1
end

-- 如果没有被限流，就让当前ip在redis中的值累计1
local requestTimes = redis.call("incrby", ipRedisKey, 1)
-- 判断累加后的值
if requestTimes == 1 then
    -- 如果累加后的值是1，说明是第一次请求，设置一个时间间隔
    redis.call("expire", ipRedisKey, timeInterval)
    return 0
elseif requestTimes > continueCounts then
    --  如果累加后的值超过了设定的阈值，就对当前ip进行限流
    redis.call("setex", ipRedisLimitedKey, limitTime, ip)
    return 1
end

  2. java代码实现Lua和redis的整合

    package com.ajie.gateway.filter;

import com.ajie.common.enums.ResponseStatusEnum;
import com.ajie.common.result.GraceJSONResult;
import com.ajie.common.utils.CollUtils;
import com.ajie.common.utils.IPUtil;
import com.ajie.common.utils.JsonUtils;
import com.ajie.common.utils.RedisUtil;
import com.google.common.collect.Lists;
import io.netty.handler.codec.http.HttpHeaderNames;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.MimeTypeUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.List;

/**
 * @Description:
 * @Author: ajie
 */
@Slf4j
@Component
public class IpLuaLimitFilterJwt implements GlobalFilter, Ordered {

    @Autowired
    private UrlPathProperties urlPathProperties;
    @Value("${blackIP.continue-counts}")
    private Integer continueCounts;
    @Value("${blackIP.time-interval}")
    private Integer timeInterval;
    @Value("${blackIP.limit-time}")
    private Integer limitTime;
    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 1.获取当前的请求路径
        String path = exchange.getRequest().getURI().getPath();

        // 2.获得所有的需要限流的url
        List<String> ipLimitUrls = urlPathProperties.getIpLimitUrls();
        // 3.校验并且排除excludeList
        if (CollUtils.isNotEmpty(ipLimitUrls)) {
            for (String url : ipLimitUrls) {
                if (antPathMatcher.matchStart(url, path)) {
                    log.warn("IpLimitFilterJwt--url={}", path);
                    // 进行ip限流
                    return doLimit(exchange, chain);
                }
            }
        }
        // 默认直接放行
        return chain.filter(exchange);
    }

    private Mono<Void> doLimit(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取真实ip
        ServerHttpRequest request = exchange.getRequest();
        String ip = IPUtil.getIP(request);

        /**
         * 需求：
         * 判断ip在20秒内请求的次数是否超过3次
         * 如果超过，则限制访问30秒
         * 等待30秒以后，才能够恢复访问
         */
        // 正常ip
        String ipRedisKey = "gateway_ip:" + ip;
        // 被拦截的黑名单，如果存在，则表示该ip已经被限制访问
        String ipRedisLimitedKey = "gateway_ip:limit:" + ip;
        // 通过redis执行lua脚本。返回1代表限流了，返回0代表没有限流
        String script = "if tonumber(redis.call('ttl', KEYS[2])) > 0 then return 1 end local" +
                " requestTimes = redis.call('incrby', KEYS[1], 1) if tonumber(requestTimes) == 1 then" +
                " redis.call('expire', KEYS[1], ARGV[2]) return 0 elseif tonumber(requestTimes)" +
                " > tonumber(ARGV[1]) then redis.call('setex', KEYS[2], ARGV[3], ARGV[4])" +
                " return 1 else return 0 end";
        Long result = RedisUtil.Helper.execute(script, Long.class,
                Lists.newArrayList(ipRedisKey, ipRedisLimitedKey),
                continueCounts, timeInterval, limitTime, ip);
        if(result == 1){
            return renderErrorMsg(exchange, ResponseStatusEnum.SYSTEM_ERROR_BLACK_IP);
        }
        return chain.filter(exchange);
    }

    public Mono<Void> renderErrorMsg(ServerWebExchange exchange, ResponseStatusEnum statusEnum) {
        // 1.获得response
        ServerHttpResponse response = exchange.getResponse();
        // 2.构建jsonResult
        GraceJSONResult jsonResult = GraceJSONResult.exception(statusEnum);
        // 3.修改response的code为500
        response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
        // 4.设定header类型
        if (!response.getHeaders().containsKey("Content-Type")) {
            response.getHeaders().add(HttpHeaderNames.CONTENT_TYPE.toString(), MimeTypeUtils.APPLICATION_JSON_VALUE);
        }
        // 5.转换json并且向response写入数据
        String jsonStr = JsonUtils.toJsonStr(jsonResult);
        DataBuffer dataBuffer = response.bufferFactory()
                .wrap(jsonStr.getBytes(StandardCharsets.UTF_8));
        return response.writeWith(Mono.just(dataBuffer));
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

注意事项

  1. 在编写lua脚本的时候最好不要一次性写完去试，因为无法进行调试，最好进行拆解。

  2. 在进行数字比较时建议加上tonumber()。如果是通过方法传参进来的一定要加，因为redisTemplate默认会把参数当做字符串传入

    image-20240809115502533

    如果不转数字就会出现上面的错误

  3. 最后也是最重要的，lua代码逻辑一定要对，否则得不到自己想要的结果需要排查很久

@猿程序
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis详解(持续更新)
Ferao的博客
11-19 3万+
redis
Redis和Lua实现分布式限流器的方法详解
09-09
本文将深入探讨 Redis 和 Lua 如何协同工作，以及两种不同的限流策略：计数器模式和令牌桶模式。 首先，Redis 是一个内存中的数据存储系统，它支持多种数据结构，如字符串、哈希、列表、集合等，这使得 Redis 成为...
基于Redis的分布式限流详解
弹指天下
04-27 5557
本文主要介绍了基于Redis通过Lua脚本实现分布式限流的几种方案。 1、4种典型的限流算法：固定时间窗口，滑动时间窗口，漏桶，令牌牌。 2、通过Lua脚本实现4种典型的分流算法。 3、其他限流实现方案介绍：Guava的RateLimiter、Redisson的RRateLimiter、Redis的redis-cell限流模块、Nginx 限流、 Spring Cloud Gateway网关限流、阿里的sentinel限流、信号量Semaphore单机并发限流、Bucket4j和Resilience4j限流
限流实现详解
郑某某的博客
04-19 813
限流实现详解
【深入学习Redis丨第三篇】深入详解Redis高可用集群模式
热门推荐
陈橘又青的博客
06-11 7万+
主数据库可以进行读写操作，当读写操作导致数据变化时会自动将数据同步给从数据库* 从数据库一般都是只读的，并且接收主数据库同步过来的数据* 一个master可以拥有多个slave，但是一个slave只能对应一个master* slave挂了不影响其他slave的读和master的读和写，重新启动后会将数据从master同步过来* master挂了以后，不影响slave的读，但redis不再提供写服务，master重启后redis将重新对外提供写服务。
SpringCloud Alibaba 2021微服务实战十四 Springcloud alibaba gateway 限流的两种实现方式 redis自带实现及整合sentinel实现网关限流
liuerchong的博客
05-20 2207
微服务架构图： 由上图可知：限流一是在负载均衡转发出限流，一般是nginx, 二是在网关转发时限流 三是在单个服务处限流，前一部分sentinel已经讲解过微服务限流 这一次详解网关限流。 ...
关于限流的几种解决方案详解
白话机器学习
07-02 880
部分内容来源于网络搜集，如有侵权请联系作者删除。
php redis list数据结构,详解php基于redis的list型数据结构实现ip限流操作
weixin_30722591的博客
03-22 77
详解thinkphp5.1/5.0定时任务的实现步骤下面由 thinkphp 教程栏目给大家详解thinkphp5.1/5.0定时任务的实现步骤，希望对需要的朋友有所帮助！ 我主要做的是一个员工生日当天发短信的功能,每天跑一次脚本, 第一步: a.App/模块/ 下创建command文件夹 b.我这边是创建在admin模块里面,在command文件夹中间件：ES组件RestHighLevelCli...
SpringCloud Gateway实现限流功能详解
maizixuetang的博客
07-26 996
通俗的说，限流就是 限制一段时间内，用户访问资源的次数 ，减轻服务器压力，限流大致分为两种：1. IP 限流（5s 内同一个 ip 访问超过 3 次，则限制不让访问，过一段时间才可继续访问）2. 请求量限流（只要在一段时间内(窗口期)，请求次数达到阀值，就直接拒绝后面来的访问了，过一段时间才可以继续访问）（粒度可以细化到一个 api（url），一个服务）
redis7详解
路人甲的博客
04-23 3399
远程字典服务)是完全开源的，使用ANSIC语言编写遵守BSD协议，是一个高性能的Key-Value数据库。提供了丰富的数据结构，例如String、Hash、List、Set、SortedSet等等。数据是存在内存中的，同时Redis支持事务、持久化、LUA脚本、发布/订阅、缓存淘汰、流技术等多种功能特性提供了主从模式、Redis Sentinel和Redis Cluster集群架构方案。
redis与memcached比较
07-27
两种最流行的缓存解决方案——Redis和Memcached，各自拥有独特的特性和应用场景。本文旨在深入探讨这两种技术的异同点，帮助开发者在系统选型时做出明智的选择。 #### 二、Memcached配置详解 Memcached是一款高...
Redis学习总结.doc
07-27
2. **数据持久化**：可以通过RDB（Redis Database Backup）或AOF（Append Only File）两种方式进行数据持久化，确保数据的安全性。 3. **高可用性**：支持主从复制、哨兵机制以及集群部署等多种方式提高系统的可用性...
redis windows版(64位)
03-29
- `redis-check-aof.exe`：用于检查AOF（Append Only File，另一种持久化方式）日志文件的完整性。 7. **配置详解** - `bind`: 指定Redis服务器监听的IP地址，默认为127.0.0.1，仅允许本地连接。 - `port`: 设置...
Nginx防止流量攻击的配置详解
01-10
最近在工作中遇到一个问题，项目中报告查询系统负载均衡集群相关配置已经完成，两种实现方式分别是基于Ehcache和Redis的session管理策略。 大家都知道服务器资源有限的，但是客户端来的请求是无限的(不排除恶意攻击)...
Redis对象
好兄弟起把大狙
08-06 1018
String、List、Hash、Set、ZSet
Redis 为什么读写性能高？
heromps的博客
08-09 232
Redis 作为一种开源的、基于内存的数据结构存储系统，以其卓越的读写性能而闻名。它被广泛应用于缓存、消息队列、实时数据处理等场景。那么，是什么使得 Redis 拥有如此高的读写性能呢？本文将从以下几个方面进行探讨。
springboot3整合redis
最新发布
2301_77138117的博客
08-09 253
来源于。
Redis作为缓存，如何与MySql的数据进行同步？
尚未佩妥剑 转眼便江湖
08-05 266
Redis作为缓存，如何与MySql的数据进行同步
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值