藉助redis實現對IP限流

 https://blog.csdn.net/qq_33762302/article/details/116258617

 1 import java.lang.annotation.*;
 2 
 3 @Target(ElementType.METHOD)
 4 @Retention(RetentionPolicy.RUNTIME)
 5 @Documented
 6 public @interface IpLimiter {
 7     /**
 8      * 放行ip
 9      */
10     String[] ipAdress() default {""};
11     /**
12      * 單位時間限制通過請求數
13      */
14     long limit() default 10;
15     /**
16      * 單位時間，單位秒
17      */
18     long time() default 1;
19     /**
20      * 達到限流提示語
21      */
22     String message();
23 
24     /**
25      * 是否鎖住IP的同時鎖住URI
26      */
27     boolean lockUri() default false;
28 }

IpLimterHandler.java 註解AOP處理。

  1 import com.missionex.common.annotation.IpLimiter;
  2 import com.missionex.common.core.domain.AjaxResult;
  3 import com.missionex.common.utils.DateUtils;
  4 import com.missionex.common.utils.SecurityUtils;
  5 import com.missionex.common.utils.http.IPAddressUtils;
  6 import org.aspectj.lang.ProceedingJoinPoint;
  7 import org.aspectj.lang.Signature;
  8 import org.aspectj.lang.annotation.Around;
  9 import org.aspectj.lang.annotation.Aspect;
 10 import org.aspectj.lang.reflect.MethodSignature;
 11 import org.slf4j.Logger;
 12 import org.slf4j.LoggerFactory;
 13 import org.springframework.beans.factory.annotation.Autowired;
 14 import org.springframework.core.io.ClassPathResource;
 15 import org.springframework.data.redis.core.StringRedisTemplate;
 16 import org.springframework.data.redis.core.script.DefaultRedisScript;
 17 import org.springframework.scripting.support.ResourceScriptSource;
 18 import org.springframework.stereotype.Component;
 19 import org.springframework.web.context.request.RequestContextHolder;
 20 import org.springframework.web.context.request.ServletRequestAttributes;
 21 
 22 import javax.annotation.PostConstruct;
 23 import javax.servlet.http.HttpServletRequest;
 24 import java.util.ArrayList;
 25 import java.util.List;
 26 
 27 @Aspect
 28 @Component
 29 public class IpLimterHandler {
 30 
 31     private static final Logger LOGGER = LoggerFactory.getLogger("request-limit");
 32 
 33     @Autowired
 34     StringRedisTemplate redisTemplate;
 35 
 36 
 37     /**
 38      * getRedisScript 讀取腳本工具類
 39      * 這裡設置為Long,是因為ipLimiter.lua 腳本返回的是數字類型
 40      */
 41     private DefaultRedisScript<Long> getRedisScript;
 42 
 43     @PostConstruct
 44     public void init() {
 45         getRedisScript = new DefaultRedisScript<>();
 46         getRedisScript.setResultType(Long.class);
 47         getRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("ipLimiter.lua")));
 48         LOGGER.info("IpLimterHandler[分散式限流處理器]腳本載入完成");
 49     }
 50 
 51     /**
 52      * 這個切點可以不要，因為下麵的本身就是個註解
 53      */
 54 //    @Pointcut("@annotation(com.jincou.iplimiter.annotation.IpLimiter)")
 55 //    public void rateLimiter() {}
 56 
 57     /**
 58      * 如果保留上面這個切點，那麼這裡可以寫成
 59      * @Around("rateLimiter()&&@annotation(ipLimiter)")
 60      */
 61     @Around("@annotation(ipLimiter)")
 62     public Object around(ProceedingJoinPoint proceedingJoinPoint, IpLimiter ipLimiter) throws Throwable {
 63         if (LOGGER.isDebugEnabled()) {
 64             LOGGER.debug("IpLimterHandler[分散式限流處理器]開始執行限流操作");
 65         }
 66         String userIp = null;
 67         String requestURI = null;
 68         try {
 69             // 獲取請求信息
 70             HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
 71             requestURI = request.getRequestURI();
 72             String requestMethod = request.getMethod();
 73             String remoteAddr = request.getRemoteAddr();
 74             // 獲取請求用戶IP
 75             userIp = IPAddressUtils.getIpAdrress(request);
 76             if (userIp == null) {
 77                 return AjaxResult.error("運行環境存在風險");
 78             }
 79         } catch (Exception e) {
 80             LOGGER.error("獲取request出錯=>" + e.getMessage());
 81             if (userIp == null) {
 82                 return AjaxResult.error("運行環境存在風險");
 83             }
 84         }
 85         Signature signature = proceedingJoinPoint.getSignature();
 86         if (!(signature instanceof MethodSignature)) {
 87             throw new IllegalArgumentException("the Annotation @IpLimter must used on method!");
 88         }
 89         /**
 90          * 獲取註解參數
 91          */
 92         // 放行模塊IP
 93         String[] limitIp = ipLimiter.ipAdress();
 94         int len;
 95         if (limitIp != null && (len = limitIp.length) != 0) {
 96             for (int i = 0; i < len; i++) {
 97                 if (limitIp[i].equals(userIp)) {
 98                     return proceedingJoinPoint.proceed();
 99                 }
100             }
101         }
102         // 限流閾值
103         long limitTimes = ipLimiter.limit();
104         // 限流超時時間
105         long expireTime = ipLimiter.time();
106         boolean lockUri = ipLimiter.lockUri();
107         if (LOGGER.isDebugEnabled()) {
108             LOGGER.debug("IpLimterHandler[分散式限流處理器]參數值為-limitTimes={},limitTimeout={}", limitTimes, expireTime);
109         }
110         // 限流提示語
111         String message = ipLimiter.message();
112         /**
113          * 執行Lua腳本
114          */
115         List<String> ipList = new ArrayList();
116         // 設置key值為註解中的值
117         if (lockUri) {
118             ipList.add(userIp+requestURI);
119         } else {
120             ipList.add(userIp);
121         }
122         /**
123          * 調用腳本並執行
124          */
125         try {
126             Object x = redisTemplate.execute(getRedisScript, ipList, expireTime+"", limitTimes+"");
127             Long result = (Long) x;
128             if (result == 0) {
129                 Long userId = null;
130                 try {
131                     userId = SecurityUtils.getLoginUser().getAppUser().getId();
132                 } catch (Exception e) {
133 
134                 }
135                 LOGGER.info("[分散式限流處理器]限流執行結果-ip={}-介面={}-用戶ID={}-result={}-time={},已被限流", userIp,requestURI == null?"未知":requestURI
136                         ,userId==null?"用戶未登錄":userId,result, DateUtils.getTime());
137                 // 達到限流返回給前端信息
138                 return AjaxResult.error(message);
139             }
140             if (LOGGER.isDebugEnabled()) {
141                 LOGGER.debug("IpLimterHandler[分散式限流處理器]限流執行結果-result={},請求[正常]響應", result);
142             }
143             return proceedingJoinPoint.proceed();
144         } catch (Exception e) {
145             LOGGER.error("限流錯誤",e);
146             return proceedingJoinPoint.proceed();
147         }
148 
149     }
150 }

ipLimiter.lua 腳本，放在resources文件夾中。

 1 -獲取KEY
 2 local key1 = KEYS[1]
 3 
 4 local val = redis.call('incr', key1)
 5 local ttl = redis.call('ttl', key1)
 6 
 7 --獲取ARGV內的參數並列印
 8 local expire = ARGV[1]
 9 local times = ARGV[2]
10 
11 redis.log(redis.LOG_DEBUG,tostring(times))
12 redis.log(redis.LOG_DEBUG,tostring(expire))
13 
14 redis.log(redis.LOG_NOTICE, "incr "..key1.." "..val);
15 if val == 1 then
16     redis.call('expire', key1, tonumber(expire))
17 else
18     if ttl == -1 then
19         redis.call('expire', key1, tonumber(expire))
20     end
21 end
22 
23 if val > tonumber(times) then
24     return 0
25 end
26 return 1

RedisConfig.java redis配置（該配置繼承了CachingConfigurerSupport）中對寫入redis的數據的序列化。

如果使用IP鎖的時候，錯誤出現在了AOP中的使用腳本寫入redis的時候（像什麼Long無法轉String的錯誤），基本是這邊序列化沒配好。

 1 　　 @Bean
 2     @SuppressWarnings(value = { "unchecked", "rawtypes" })
 3     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
 4     {
 5         RedisTemplate<Object, Object> template = new RedisTemplate<>();
 6         template.setConnectionFactory(connectionFactory);
 7         FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
 8         // 使用StringRedisSerializer來序列化和反序列化redis的key值
 9         template.setKeySerializer(new StringRedisSerializer());
10         template.setValueSerializer(serializer);
11         // Hash的key也採用StringRedisSerializer的序列化方式
12         template.setHashKeySerializer(new StringRedisSerializer());
13         template.setHashValueSerializer(serializer);
14         template.afterPropertiesSet();
15         return template;
16     }

使用示範。

1     @PostMapping("/test")
2     @IpLimiter(limit = 2, time = 5, message = "您訪問過於頻繁，請稍候訪問",lockUri = true)
3     public AjaxResult test(@RequestBody Map map){
4         //代碼......
5     }