SpringBoot+Redis+Lua防止IP重复防刷攻击的方法

2024-04-02 19:04:59 573人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

黑客或者一些恶意的用户为了攻击你的网站或者APP。通过肉机并发或者死循环请求你的接口。从而导致系统出现宕机。针对新增数据的接口，会出现大量的重复数据，甚至垃圾数据会将你的

黑客或者一些恶意的用户为了攻击你的网站或者APP。通过肉机并发或者死循环请求你的接口。从而导致系统出现宕机。

针对新增数据的接口，会出现大量的重复数据，甚至垃圾数据会将你的数据库和CPU或者内存磁盘耗尽，直到数据库撑爆为止。
针对查询的接口。黑客一般是重点攻击慢查询，比如一个sql是2S。只要黑客一致攻击，就必然造成系统被拖垮，数据库查询全都被阻塞，连接一直得不到释放造成数据库无法访问。

具体要实现和达到的效果是：
需求：在10秒内，同一IP 127.0.0.1 地址只允许访问30次。
最终达到的效果：


Long execute = this.stringRedisTemplate.execute(defaultRedisScript, keyList, "30", "10");

分析：keylist = 127.0.0.1 expire 30 incr

分析1：用户ip地址127.0.0.1 访问一次 incr
分析2：用户ip地址127.0.0.1 访问一次 incr
分析3：用户ip地址127.0.0.1 访问一次 incr
分析4：用户ip地址127.0.0.1 访问一次 incr
分析10：用户ip地址127.0.0.1 访问一次 incr
判断当前的次数是否以及达到了10次，如果达到了。就时间当前时间是否已经大于30秒。如果没有大于就不允许访问，否则开始设置过期

方法一：根据用户id或者ip来实现

第一步：lua文件

在resource/lua下面创建iplimit.lua文件


-- 为某个接口的请求IP设置计数器，比如：127.0.0.1请求课程接口
-- KEYS[1] = 127.0.0.1 也就是用户的IP
-- ARGV[1] = 过期时间 30m
-- ARGV[2] = 限制的次数
local limitCount = redis.call('incr',KEYS[1]);
if limitCount == 1 then
    redis.call("expire",KEYS[1],ARGV[1]) 
end
-- 如果次数还没有过期，并且还在规定的次数内，说明还在请求同一接口
if limitCount > tonumber(ARGV[2]) then
    return 0
end

return 1

第二步：创建lua对象


@SpringBootConfiguration
public class LuaConfiguration {
    
    @Bean
    public DefaultRedisScript<Long> initluascript() {
        DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>();
        defaultRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/iplimit.lua")));
        defaultRedisScript.setResultType(Long.class);
        return defaultRedisScript;
    }
}

第三步使用


package com.kuangstudy.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.WEB.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;


@RestController
public class IpLuaController {

    private static final Logger log = LoggerFactory.getLogger(IpLuaController.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private DefaultRedisScript<Long> iplimitLua;

    @PostMapping("/ip/limit")
    //@IpList(second=10,limit=20)
    public String luaupdateuser(String ip) {
        String key = "user:" + ip;
        // 1: KEYS对应的值,是一个集合
        List<String> keysList = new ArrayList<>();
        keysList.add(key);
        // 2：具体的值ARGV 他是一个动态参数，起也就是一个数组
        // 10 代表过期时间 2次数，表述：10秒之内最多允许2次访问
        Long execute = stringRedisTemplate.execute(iplimitLua, keysList,"10","2");
        if (execute == 0) {
            log.info("1----->ip:{},请求收到限制", key);
            return "客官，不要太快了服务反应不过来...";
        }
        log.info("2----->ip:{},正常访问，返回课程列表", key);
        return "正常访问，返回课程列表 " + key;
    }
}

其实还可以自己写一个自定义的注解，结合lua来实现限流
比如:@iplimit(time=10,limit=2)

#方法二：注解实现
需求：用户请求在一秒钟之内只允许2个请求。

核心是aop

前面几步是一样的，lua脚本，lua对象，自定义redisltemplate。

1.redis依赖


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<!--这里就是redis的核心jar包-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.lua脚本


-- 为某个接口的请求IP设置计数器，比如：127.0.0.1请求课程接口
-- KEYS[1] = 127.0.0.1 也就是用户的IP
-- ARGV[1] = 过期时间 30m
-- ARGV[2] = 限制的次数
local limitCount = redis.call('incr',KEYS[1]);
if limitCount == 1 then
    redis.call("expire",KEYS[1],ARGV[1])
end
-- 如果次数还没有过期，并且还在规定的次数内，说明还在请求同一接口
if limitCount > tonumber(ARGV[2]) then
    return 0
end
return 1

3.创建lua对象


package com.kuangstudy.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.scripting.support.ResourceScriptSource;

@Configuration
public class LuaConfiguration {

    
    @Bean
    public DefaultRedisScript<Boolean> limitUserAccessLua() {
        // 1： 初始化一个lua脚本的对象DefaultRedisScript
        DefaultRedisScript<Boolean> defaultRedisScript = new DefaultRedisScript<>();
        // 2: 通过这个对象去加载lua脚本的位置 ClassPathResource读取类路径下的lua脚本
        // ClassPathResource 什么是类路径：就是你Maven编译好的target/classes目录
        defaultRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/userlimit.lua")));
        // 3: lua脚本最终的返回值是什么？建议大家都是数字返回。1/0
        defaultRedisScript.setResultType(Boolean.class);
        return defaultRedisScript;
    }
}

4.自定义redistemplate


package com.kuangstudy.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JSONRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfiguration {

    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 1: 开始创建一个redistemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 2:开始redis连接工厂跪安了
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 创建一个json的序列化方式
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置key用string序列化方式
        redisTemplate.seTKEySerializer(new StringRedisSerializer());
        // 设置value用jackjson进行处理
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash也要进行修改
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        // 默认调用
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

5.自定义注解


package com.kuangstudy.limit.annotation;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AccessLimiter {
    // 目标： @AccessLimiter(limit="1",timeout="1",key="user:ip:limit")
    // 解读：一个用户key在timeout时间内，最多访问limit次
    // 缓存的key
    String key();
    // 限制的次数
    int limit() default  1;
    // 过期时间
    int timeout() default  1;
}

6.自定义切面


package com.kuangstudy.limit.aop;

import com.kuangstudy.common.exception.BusinessException;
import com.kuangstudy.limit.annotation.AccessLimiter;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Aspect
@Component
public class AccessLimiterAspect {

    private static final Logger log = LoggerFactory.getLogger(AccessLimiterAspect.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private DefaultRedisScript<Boolean> limitUserAccessLua;

    // 1: 切入点
    @Pointcut("@annotation(com.kuangstudy.limit.annotation.AccessLimiter)")
    public void cut() {
        System.out.println("cut");
    }

    // 2: 通知和连接点
    @Before("cut()")
    public void before(JoinPoint joinPoint) {

        // 1: 获取到执行的方法
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 2:通过方法获取到注解
        AccessLimiter annotation = method.getAnnotation(AccessLimiter.class);
        // 如果 annotation==null，说明方法上没加限流AccessLimiter,说明不需要限流操作
        if (annotation == null) {
            return;
        }
        // 3: 获取到对应的注解参数
        String key = annotation.key();
        Integer limit = annotation.limit();
        Integer timeout = annotation.timeout();

        // 4: 如果你的key是空的
        if (StringUtils.isEmpty(key)) {
            String name = method.getDeclarinGClass().getName();
            // 直接把当前的方法名给与key
            key = name+"#"+method.getName();
            // 获取方法中的参数列表

            //ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();
            //String[] parameterNames = pnd.getParameterNames(method);

            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(parameterType);
            }

            // 如果方法有参数，那么就把key规则 = 方法名“#”参数类型
            if (parameterTypes != null) {
                String paramtypes = Arrays.stream(parameterTypes)
                        .map(Class::getName)
                        .collect(Collectors.joining(","));
                key = key +"#" + paramtypes;
            }
        }

        // 1: 定义key是的列表
        List<String> keysList = new ArrayList<>();
        keysList.add(key);
        // 2:执行执行lua脚本限流
        Boolean accessFlag = stringRedisTemplate.execute(limitUserAccessLua, keysList, limit.toString(), timeout.toString());
        // 3: 判断当前执行的结果，如果是0，被限制，1代表正常
        if (!accessFlag) {
            throw new BusinessException(500, "server is busy!!!");
        }
    }
}

7.在需要限流的方法上进行限流测试


package com.kuangstudy.controller;
import com.kuangstudy.common.exception.BusinessException;
import com.kuangstudy.limit.annotation.AccessLimiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
public class RateLimiterController {


    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private DefaultRedisScript<Boolean> limitUserAccessLua;


    
    @GetMapping("/limit/user")
    public String limitUser(String userid) {
        // 1: 定义key是的列表
        List<String> keysList = new ArrayList<>();
        keysList.add("user:"+userid);
        // 2:执行执行lua脚本限流
        Boolean accessFlag = stringRedisTemplate.execute(limitUserAccessLua, keysList, "1","1");
        // 3: 判断当前执行的结果，如果是0，被限制，1代表正常
        if (!accessFlag) {
           throw  new BusinessException(500,"server is busy!!!");
        }
        return "scucess";
    }


    
    @GetMapping("/limit/aop/user")
    @AccessLimiter(limit = 1,timeout = 1)
    public String limitAopUser(String userid) {
        return "scucess";
    }


    @GetMapping("/limit/aop/user3")
    @AccessLimiter(limit = 10,timeout = 1)
    public String limitAopUse3(String userid) {
        return "scucess";
    }

    
    @GetMapping("/limit/aop/user2")
    public String limitAopUser2(String userid) {
        return "scucess";
    }
}

到此这篇关于SpringBoot+Redis+Lua防止IP重复防刷攻击的方法的文章就介绍到这了,更多相关SpringBoot防止IP重复防刷内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: SpringBoot+Redis+Lua防止IP重复防刷攻击的方法

本文链接: https://www.lsjlt.com/news/160787.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

SpringBoot+Redis+Lua防止IP重复防刷攻击的方法

黑客或者一些恶意的用户为了攻击你的网站或者APP。通过肉机并发或者死循环请求你的接口。从而导致系统出现宕机。针对新增数据的接口，会出现大量的重复数据，甚至垃圾数据会将你的...

99+

2024-04-02
SpringBoot+Redis+Lua怎么防止IP重复防刷攻击

本篇内容介绍了“SpringBoot+Redis+Lua怎么防止IP重复防刷攻击”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！黑客或者一些恶...

99+

2023-06-22
springboot防止重复请求防止重复点击的操作

利用 springboot + redis 实现过滤重复提交的请求，业务流程如下所示，首先定义一个拦截器，拦截需要进行过滤的URL，然后用 session +...

99+

2023-01-30

springboot 重复请求 springboot 重复点击
SpringBoot防止XSS注入攻击的方法

这篇文章将为大家详细讲解有关SpringBoot防止XSS注入攻击的方法，小编觉得挺实用的，因此分享给大家做个参考，希望大家阅读完这篇文章后可以有所收获。什么是 XSS 攻击在跨站脚本（XSS）攻击中，攻击者可以在受害者的浏览器中执行恶意脚...

99+

2023-06-15
防止SQL注入攻击的方法

小编给大家分享一下防止SQL注入攻击的方法，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ SQL注入是一种注入攻击，可...

99+

2024-04-02
SpringBoot 使用AOP + Redis 防止表单重复提交的方法

目录配置Redis1. 添加Redis依赖2. 添加redis配置信息配置AOP1. 自定义注解2. AOP切面注意事项总结Spring Boot是一个用于构建Web应用程序的框架，...

99+

2023-05-16

SpringBoot防止表单重复提交 SpringBoot AOP防止表单重复提交 SpringBoot redis防止重复提交
手动防止Ping攻击方法(无需防火墙)

ping命令是大家用的较多的DOS命令。大家知道，ping命令不仅可以查询自己的IP地址，还可以查网站的响应速度。它可是一个好用的网络诊断工具。ping的工作原理是端对端的查询，您可以在本地ping别人的电脑，别人也可以...

99+

2023-05-31

防火墙 Ping攻击 Ping 攻击方法
防止网络DDoS攻击的三种方法

1. 流量过滤：通过使用防火墙或其他网络安全设备，对进入网络的流量进行过滤和检测，识别并丢弃可能是DDoS攻击的流量。这种方法可以通...

99+

2023-09-22

DDoS攻击
Java中的10种方法防止XSS攻击

目录 1. 输入验证和过滤2. 使用安全的HTML编码3. 使用安全的URL编码4. 使用HTTP头部中的Content Security Policy (CSP)5. 使用安全的模板引擎6....

99+

2023-09-07

java xss 开发语言
SpringBoot防止大量请求攻击的实现

我们使用Jmeter测试同学的网站时，就会出现网站无法访问，403等错误。 An error occurred. Sorry, the page you are looking f...

99+

2024-04-02
JAVA -- sm3加密签名，以及防止重复攻击

背景：后端开发基本都遇到过使用签名校验的情况，签名的作用是为了防止请求数据被别人截取篡改重新请求。为什么签名验证可以防止请求数据被篡改，因为一般签名的规则就是，你的所有请求参数，按照约定好的格式进行拼接，...

99+

2023-09-08

java
防御ddos攻击的方法

这篇文章主要讲解了“防御ddos攻击的方法”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“防御ddos攻击的方法”吧！对于ddos防护的了解：抵挡ddos是一个体系工程，想仅仅依托某种体系或商...

99+

2023-06-07
浅谈Springboot2.0防止XSS攻击的几种方式

目录防止XSS攻击，一般有两种做法:转义做法的三种实现：转义方法一：注册自定义转换器转义方法二：BaseController转义方法三：Converter在平时做项目代码开发的时候...

99+

2022-11-13

Springboot防止XSS攻击 Springboot防止XSS
JavaScript防止表单重复提交的方法

目录背景小白级别：简单粗暴的禁用提交按钮进阶级别：使用标志变量大神级别：优雅地处理 AJAX 请求总结背景假设我们正在开发一个应用，该应用允许用户上报突发事件。用户需要填写一系列信...

99+

2023-05-17

JS 表单 JS表单重复提交
高防服务器防御DDOS攻击和CC攻击的方法是怎样的

高防服务器防御DDOS攻击：1.确保服务器系统的安全，关闭不必要的服务，正确设置防火墙，仔细查看网络设备和主机的日志/服务器system。2.隐藏服务器的真实IP地址。高防服务器防御CC攻击：通过禁止网站代理访问、尽可能使网站成为静态页面、...

99+

2024-04-02
防止网站被入侵攻击的五个办法

网站安全一直以来都是各大网站运营者们比较关注的难题，一个网站平台，要是没有一种安全防护的系统环境，做得再强，也没什么价值，如果遇到被黑客攻击，损失就会非常大。因此，学好如何防范不被黑客攻击，维护好自个儿的网站，是必需的条件。那么，网站运营者...

99+

2023-06-03
Vue如何防止按钮重复点击方案详解

目录前言目的文件结构实现请求拦截响应拦截取消重复发送请求调用前言 Axios 是一个基于 promise 的 HTTP 库，可以用在浏览器和 node.js 中。 axios 是目前...

99+

2022-12-09

Vue按钮重复点击 Vue防止按钮重复点击 Vue避免重复点击
高防服务器防御攻击的方法是什么

高防服务器防御攻击的方法主要包括以下几点：通过搭建强大的防火墙系统，对网络流量进行实时监控和分析，及时发现并阻止恶意攻击流量； ...

99+

2024-04-09

高防服务器
jwt防止重复登录的方法是什么

JWT（JSON Web Token）是一种通过对 JSON 对象进行加密签名来实现认证和授权的方式。它本身并没有提供防止重复登录的...

99+

2023-09-29

jwt
spring防止重复请求的方法是什么

在Spring中可以通过以下几种方式来防止重复请求： Token-based防重复提交：在表单中添加一个Token（令牌），每次...

99+

2024-04-02