本篇內容介紹了“SpringBoot+Redis+Lua怎么防止IP重復防刷攻擊”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！
黑客或者一些惡意的用戶為了攻擊你的網站或者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秒。如果沒有大于就不允許訪問，否則開始設置過期
第一步：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 {
/**
* 將lua腳本的內容加載出來放入到DefaultRedisScript
* @return
*/
@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;
/**
* @description:
* @author: xuke
* @time: 2021/7/3 22:25
*/
@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 13.創建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;
/**
* @author 飛哥
* @Title: 學相伴出品
* @Description: 我們有一個學習網站：https://www.kuangstudy.com
* @date 2021/5/21 12:01
*/
@Configuration
public class LuaConfiguration {
/**
* 將lua腳本的內容加載出來放入到DefaultRedisScript
* @return
*/
@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;
/**
* @author 飛哥
* @Title: 學相伴出品
* @Description: 我們有一個學習網站：https://www.kuangstudy.com
* @date 2021/5/20 13:16
*/
@Configuration
public class RedisConfiguration {
/**
* @return org.springframework.data.redis.core.RedisTemplate<java.lang.String, java.lang.Object>
* @Description 改寫redistemplate序列化規則
**/
@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;
/**
* 限流的處理方法
* @param userid
* @return
*/
@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";
}
/**
* 限流的處理方法
* @param userid
* @return
*
* 方案1：如果你的一個方法進行限流：一個方法只允許1秒100請求，key公用
* 方案2：如果你的一個方法進行限流：某個用戶一秒之內允許10個請求，key必須要根據參數的具體值去執行拼接。
*
*/
@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";
}
/**
* 限流的處理方法
* @param userid
* @return
*
* 方案1：如果你的一個方法進行限流：一個方法只允許1秒100請求，key公用
* 方案2：如果你的一個方法進行限流：某個用戶一秒之內允許10個請求，key必須要根據參數的具體值去執行拼接。
*
*/
@GetMapping("/limit/aop/user2")
public String limitAopUser2(String userid) {
return "scucess";
}
}“SpringBoot+Redis+Lua怎么防止IP重復防刷攻擊”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
