redis + AOP + 自定义注解实现接口限流

限流介绍

限流（rate limiting）
​       是指在一定时间内，对某些资源的访问次数进行限制，以避免资源被滥用或过度消耗。限流可以防止服务器崩溃、保证用户体验、提高系统可用性。
限流的方法有很多种，常见的有以下几种：

• 漏桶算法：
  ​        漏桶算法通过一个固定大小的漏桶来模拟流量，当流量进入漏桶时，会以恒定的速率从漏桶中流出。如果流量超过漏桶的容量，则会被丢弃。
  
• 令牌桶算法：
  ​        令牌桶算法通过一个固定大小的令牌桶来模拟流量，当流量进入令牌桶时，会从令牌桶中取出一个令牌。如果令牌桶中没有令牌，则会拒绝该流量。
  
• 滑动窗口算法：
  ​        滑动窗口算法通过一个固定大小的滑动窗口来模拟流量，当流量进入滑动窗口时，会统计窗口内流量的数量。如果窗口内流量的数量超过了一定的阈值，则会拒绝该流量。
  

限流可以应用在很多场景，例如：

• 防止服务器崩溃：当服务器的请求量过大时，可以通过限流来防止服务器崩溃。
  
• 保证用户体验：当用户请求某个资源的频率过高时，可以通过限流来降低用户的等待时间。
  
• 提高系统可用性：当系统的某些资源被滥用或过度消耗时，可以通过限流来提高系统的可用性。
  

​
​        限流是一个非常重要的技术，它可以帮助我们提高系统的稳定性和可用性。在实际开发中，我们可以根据不同的场景选择合适的限流算法。
我们定义的注解使用到技术：redis，redisson，AOP，自定义注解等
依赖

用到的部分依赖，这里没有指定版本，可根据市场上的版本进行配置

1.         
2.         <dependency>
3.             <groupId>org.redisson</groupId>
4.             <artifactId>redisson-spring-boot-starter</artifactId>
5.         </dependency>
7.         <dependency>
8.             <groupId>com.baomidou</groupId>
9.             <artifactId>lock4j-redisson-spring-boot-starter</artifactId>
10.         </dependency>
12.       
13.         <dependency>
14.             <groupId>org.springframework</groupId>
15.             <artifactId>spring-context-support</artifactId>
16.         </dependency>
18.         
19.         <dependency>
20.             <groupId>org.springframework</groupId>
21.             <artifactId>spring-web</artifactId>
22.         </dependency>
24.         
25.         <dependency>
26.             <groupId>org.springframework.boot</groupId>
27.             <artifactId>spring-boot-starter-validation</artifactId>
28.         </dependency>
30.         
31.         <dependency>
32.             <groupId>org.springframework.boot</groupId>
33.             <artifactId>spring-boot-starter-aop</artifactId>
34.         </dependency>
36.         
37.         <dependency>
38.             <groupId>org.apache.commons</groupId>
39.             <artifactId>commons-lang3</artifactId>
40.         </dependency>
42.         
43.         <dependency>
44.             <groupId>jakarta.servlet</groupId>
45.             <artifactId>jakarta.servlet-api</artifactId>
46.         </dependency>
48.       
49.         <dependency>
50.             <groupId>cn.hutool</groupId>
51.             <artifactId>hutool-core</artifactId>
52.         </dependency>
54.         <dependency>
55.             <groupId>cn.hutool</groupId>
56.             <artifactId>hutool-http</artifactId>
57.         </dependency>
59.         <dependency>
60.             <groupId>cn.hutool</groupId>
61.             <artifactId>hutool-extra</artifactId>
62.         </dependency>
65.       
66.         <dependency>
67.             <groupId>org.projectlombok</groupId>
68.             <artifactId>lombok</artifactId>
69.         </dependency>
71.         
72.         <dependency>
73.             <groupId>org.springframework.boot</groupId>
74.             <artifactId>spring-boot-configuration-processor</artifactId>
75.         </dependency>
78.         
79.         <dependency>
80.             <groupId>org.springframework.boot</groupId>
81.             <artifactId>spring-boot-properties-migrator</artifactId>
82.             <scope>runtime</scope>
83.         </dependency>
85.         
86.         <dependency>
87.             <groupId>io.github.linpeilie</groupId>
88.             <artifactId>mapstruct-plus-spring-boot-starter</artifactId>
89.         </dependency>
91.         
92.         <dependency>
93.             <groupId>org.lionsoul</groupId>
94.             <artifactId>ip2region</artifactId>
95.         </dependency>

复制代码

1，定义限流类型

这里定义限流枚举类：LimitType

1. public enum LimitType {
2.     /**
3.      * 默认策略全局限流
4.      */
5.     DEFAULT,
7.     /**
8.      * 根据请求者IP进行限流
9.      */
10.     IP,
12.     /**
13.      * 实例限流(集群多后端实例)
14.      */
15.     CLUSTER
16. }

复制代码

2，定义注解  RateLimiter

定义注解，在后续的代码中使用进行限流

1. import java.lang.annotation.*;
3. /**
4. * 限流注解
5. *
6. * @author Lion Li
7. */
8. @Target(ElementType.METHOD)
9. @Retention(RetentionPolicy.RUNTIME)
10. @Documented
11. public @interface RateLimiter {
12.     /**
13.      * 限流key,支持使用Spring el表达式来动态获取方法上的参数值
14.      * 格式类似于  #code.id #{#code}
15.      */
16.     String key() default "";
18.     /**
19.      * 限流时间,单位秒
20.      */
21.     int time() default 60;
23.     /**
24.      * 限流次数
25.      */
26.     int count() default 100;
28.     /**
29.      * 限流类型
30.      */
31.     LimitType limitType() default LimitType.DEFAULT;
33.     /**
34.      * 提示消息 支持国际化 格式为 {code}
35.      */
36.     String message() default "{rate.limiter.message}";
37. }

复制代码

redis 工具类

这里提供一下第 3 步需要的redis 工具类，可以根据自己的需求进行部分方法进行复制。

1. @NoArgsConstructor(access = AccessLevel.PRIVATE)
2. @SuppressWarnings(value = {"unchecked", "rawtypes"})
3. public class RedisUtils {
5.     private static final RedissonClient CLIENT = SpringUtils.getBean(RedissonClient.class);
7.     /**
8.      * 限流
9.      *
10.      * @param key          限流key
11.      * @param rateType     限流类型
12.      * @param rate         速率
13.      * @param rateInterval 速率间隔
14.      * @return -1 表示失败
15.      */
16.     public static long rateLimiter(String key, RateType rateType, int rate, int rateInterval) {
17.         RRateLimiter rateLimiter = CLIENT.getRateLimiter(key);
18.         rateLimiter.trySetRate(rateType, rate, rateInterval, RateIntervalUnit.SECONDS);
19.         if (rateLimiter.tryAcquire()) {
20.             return rateLimiter.availablePermits();
21.         } else {
22.             return -1L;
23.         }
24.     }
26.     /**
27.      * 获取客户端实例
28.      */
29.     public static RedissonClient getClient() {
30.         return CLIENT;
31.     }
33.     /**
34.      * 发布通道消息
35.      *
36.      * @param channelKey 通道key
37.      * @param msg        发送数据
38.      * @param consumer   自定义处理
39.      */
40.     public static <T> void publish(String channelKey, T msg, Consumer<T> consumer) {
41.         RTopic topic = CLIENT.getTopic(channelKey);
42.         topic.publish(msg);
43.         consumer.accept(msg);
44.     }
46.     public static <T> void publish(String channelKey, T msg) {
47.         RTopic topic = CLIENT.getTopic(channelKey);
48.         topic.publish(msg);
49.     }
51.     /**
52.      * 订阅通道接收消息
53.      *
54.      * @param channelKey 通道key
55.      * @param clazz      消息类型
56.      * @param consumer   自定义处理
57.      */
58.     public static <T> void subscribe(String channelKey, Class<T> clazz, Consumer<T> consumer) {
59.         RTopic topic = CLIENT.getTopic(channelKey);
60.         topic.addListener(clazz, (channel, msg) -> consumer.accept(msg));
61.     }
63.     /**
64.      * 缓存基本的对象，Integer、String、实体类等
65.      *
66.      * @param key   缓存的键值
67.      * @param value 缓存的值
68.      */
69.     public static <T> void setCacheObject(final String key, final T value) {
70.         setCacheObject(key, value, false);
71.     }
73.     /**
74.      * 缓存基本的对象，保留当前对象 TTL 有效期
75.      *
76.      * @param key       缓存的键值
77.      * @param value     缓存的值
78.      * @param isSaveTtl 是否保留TTL有效期(例如: set之前ttl剩余90 set之后还是为90)
79.      * @since Redis 6.X 以上使用 setAndKeepTTL 兼容 5.X 方案
80.      */
81.     public static <T> void setCacheObject(final String key, final T value, final boolean isSaveTtl) {
82.         RBucket<T> bucket = CLIENT.getBucket(key);
83.         if (isSaveTtl) {
84.             try {
85.                 bucket.setAndKeepTTL(value);
86.             } catch (Exception e) {
87.                 long timeToLive = bucket.remainTimeToLive();
88.                 setCacheObject(key, value, Duration.ofMillis(timeToLive));
89.             }
90.         } else {
91.             bucket.set(value);
92.         }
93.     }
95.     /**
96.      * 缓存基本的对象，Integer、String、实体类等
97.      *
98.      * @param key      缓存的键值
99.      * @param value    缓存的值
100.      * @param duration 时间
101.      */
102.     public static <T> void setCacheObject(final String key, final T value, final Duration duration) {
103.         RBatch batch = CLIENT.createBatch();
104.         RBucketAsync<T> bucket = batch.getBucket(key);
105.         bucket.setAsync(value);
106.         bucket.expireAsync(duration);
107.         batch.execute();
108.     }
110.     /**
111.      * 如果不存在则设置 并返回 true 如果存在则返回 false
112.      *
113.      * @param key   缓存的键值
114.      * @param value 缓存的值
115.      * @return set成功或失败
116.      */
117.     public static <T> boolean setObjectIfAbsent(final String key, final T value, final Duration duration) {
118.         RBucket<T> bucket = CLIENT.getBucket(key);
119.         return bucket.setIfAbsent(value, duration);
120.     }
122.     /**
123.      * 如果存在则设置 并返回 true 如果存在则返回 false
124.      *
125.      * @param key   缓存的键值
126.      * @param value 缓存的值
127.      * @return set成功或失败
128.      */
129.     public static <T> boolean setObjectIfExists(final String key, final T value, final Duration duration) {
130.         RBucket<T> bucket = CLIENT.getBucket(key);
131.         return bucket.setIfExists(value, duration);
132.     }
134.     /**
135.      * 注册对象监听器
136.      * <p>
137.      * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
138.      *
139.      * @param key      缓存的键值
140.      * @param listener 监听器配置
141.      */
142.     public static <T> void addObjectListener(final String key, final ObjectListener listener) {
143.         RBucket<T> result = CLIENT.getBucket(key);
144.         result.addListener(listener);
145.     }
147.     /**
148.      * 设置有效时间
149.      *
150.      * @param key     Redis键
151.      * @param timeout 超时时间
152.      * @return true=设置成功；false=设置失败
153.      */
154.     public static boolean expire(final String key, final long timeout) {
155.         return expire(key, Duration.ofSeconds(timeout));
156.     }
158.     /**
159.      * 设置有效时间
160.      *
161.      * @param key      Redis键
162.      * @param duration 超时时间
163.      * @return true=设置成功；false=设置失败
164.      */
165.     public static boolean expire(final String key, final Duration duration) {
166.         RBucket rBucket = CLIENT.getBucket(key);
167.         return rBucket.expire(duration);
168.     }
170.     /**
171.      * 获得缓存的基本对象。
172.      *
173.      * @param key 缓存键值
174.      * @return 缓存键值对应的数据
175.      */
176.     public static <T> T getCacheObject(final String key) {
177.         RBucket<T> rBucket = CLIENT.getBucket(key);
178.         return rBucket.get();
179.     }
181.     /**
182.      * 获得key剩余存活时间
183.      *
184.      * @param key 缓存键值
185.      * @return 剩余存活时间
186.      */
187.     public static <T> long getTimeToLive(final String key) {
188.         RBucket<T> rBucket = CLIENT.getBucket(key);
189.         return rBucket.remainTimeToLive();
190.     }
192.     /**
193.      * 删除单个对象
194.      *
195.      * @param key 缓存的键值
196.      */
197.     public static boolean deleteObject(final String key) {
198.         return CLIENT.getBucket(key).delete();
199.     }
201.     /**
202.      * 删除集合对象
203.      *
204.      * @param collection 多个对象
205.      */
206.     public static void deleteObject(final Collection collection) {
207.         RBatch batch = CLIENT.createBatch();
208.         collection.forEach(t -> {
209.             batch.getBucket(t.toString()).deleteAsync();
210.         });
211.         batch.execute();
212.     }
214.     /**
215.      * 检查缓存对象是否存在
216.      *
217.      * @param key 缓存的键值
218.      */
219.     public static boolean isExistsObject(final String key) {
220.         return CLIENT.getBucket(key).isExists();
221.     }
223.     /**
224.      * 缓存List数据
225.      *
226.      * @param key      缓存的键值
227.      * @param dataList 待缓存的List数据
228.      * @return 缓存的对象
229.      */
230.     public static <T> boolean setCacheList(final String key, final List<T> dataList) {
231.         RList<T> rList = CLIENT.getList(key);
232.         return rList.addAll(dataList);
233.     }
235.     /**
236.      * 追加缓存List数据
237.      *
238.      * @param key  缓存的键值
239.      * @param data 待缓存的数据
240.      * @return 缓存的对象
241.      */
242.     public static <T> boolean addCacheList(final String key, final T data) {
243.         RList<T> rList = CLIENT.getList(key);
244.         return rList.add(data);
245.     }
247.     /**
248.      * 注册List监听器
249.      * <p>
250.      * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
251.      *
252.      * @param key      缓存的键值
253.      * @param listener 监听器配置
254.      */
255.     public static <T> void addListListener(final String key, final ObjectListener listener) {
256.         RList<T> rList = CLIENT.getList(key);
257.         rList.addListener(listener);
258.     }
260.     /**
261.      * 获得缓存的list对象
262.      *
263.      * @param key 缓存的键值
264.      * @return 缓存键值对应的数据
265.      */
266.     public static <T> List<T> getCacheList(final String key) {
267.         RList<T> rList = CLIENT.getList(key);
268.         return rList.readAll();
269.     }
271.     /**
272.      * 获得缓存的list对象(范围)
273.      *
274.      * @param key  缓存的键值
275.      * @param form 起始下标
276.      * @param to   截止下标
277.      * @return 缓存键值对应的数据
278.      */
279.     public static <T> List<T> getCacheListRange(final String key, int form, int to) {
280.         RList<T> rList = CLIENT.getList(key);
281.         return rList.range(form, to);
282.     }
284.     /**
285.      * 缓存Set
286.      *
287.      * @param key     缓存键值
288.      * @param dataSet 缓存的数据
289.      * @return 缓存数据的对象
290.      */
291.     public static <T> boolean setCacheSet(final String key, final Set<T> dataSet) {
292.         RSet<T> rSet = CLIENT.getSet(key);
293.         return rSet.addAll(dataSet);
294.     }
296.     /**
297.      * 追加缓存Set数据
298.      *
299.      * @param key  缓存的键值
300.      * @param data 待缓存的数据
301.      * @return 缓存的对象
302.      */
303.     public static <T> boolean addCacheSet(final String key, final T data) {
304.         RSet<T> rSet = CLIENT.getSet(key);
305.         return rSet.add(data);
306.     }
308.     /**
309.      * 注册Set监听器
310.      * <p>
311.      * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
312.      *
313.      * @param key      缓存的键值
314.      * @param listener 监听器配置
315.      */
316.     public static <T> void addSetListener(final String key, final ObjectListener listener) {
317.         RSet<T> rSet = CLIENT.getSet(key);
318.         rSet.addListener(listener);
319.     }
321.     /**
322.      * 获得缓存的set
323.      *
324.      * @param key 缓存的key
325.      * @return set对象
326.      */
327.     public static <T> Set<T> getCacheSet(final String key) {
328.         RSet<T> rSet = CLIENT.getSet(key);
329.         return rSet.readAll();
330.     }
332.     /**
333.      * 缓存Map
334.      *
335.      * @param key     缓存的键值
336.      * @param dataMap 缓存的数据
337.      */
338.     public static <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
339.         if (dataMap != null) {
340.             RMap<String, T> rMap = CLIENT.getMap(key);
341.             rMap.putAll(dataMap);
342.         }
343.     }
345.     /**
346.      * 注册Map监听器
347.      * <p>
348.      * key 监听器需开启 `notify-keyspace-events` 等 redis 相关配置
349.      *
350.      * @param key      缓存的键值
351.      * @param listener 监听器配置
352.      */
353.     public static <T> void addMapListener(final String key, final ObjectListener listener) {
354.         RMap<String, T> rMap = CLIENT.getMap(key);
355.         rMap.addListener(listener);
356.     }
358.     /**
359.      * 获得缓存的Map
360.      *
361.      * @param key 缓存的键值
362.      * @return map对象
363.      */
364.     public static <T> Map<String, T> getCacheMap(final String key) {
365.         RMap<String, T> rMap = CLIENT.getMap(key);
366.         return rMap.getAll(rMap.keySet());
367.     }
369.     /**
370.      * 获得缓存Map的key列表
371.      *
372.      * @param key 缓存的键值
373.      * @return key列表
374.      */
375.     public static <T> Set<String> getCacheMapKeySet(final String key) {
376.         RMap<String, T> rMap = CLIENT.getMap(key);
377.         return rMap.keySet();
378.     }
380.     /**
381.      * 往Hash中存入数据
382.      *
383.      * @param key   Redis键
384.      * @param hKey  Hash键
385.      * @param value 值
386.      */
387.     public static <T> void setCacheMapValue(final String key, final String hKey, final T value) {
388.         RMap<String, T> rMap = CLIENT.getMap(key);
389.         rMap.put(hKey, value);
390.     }
392.     /**
393.      * 获取Hash中的数据
394.      *
395.      * @param key  Redis键
396.      * @param hKey Hash键
397.      * @return Hash中的对象
398.      */
399.     public static <T> T getCacheMapValue(final String key, final String hKey) {
400.         RMap<String, T> rMap = CLIENT.getMap(key);
401.         return rMap.get(hKey);
402.     }
404.     /**
405.      * 删除Hash中的数据
406.      *
407.      * @param key  Redis键
408.      * @param hKey Hash键
409.      * @return Hash中的对象
410.      */
411.     public static <T> T delCacheMapValue(final String key, final String hKey) {
412.         RMap<String, T> rMap = CLIENT.getMap(key);
413.         return rMap.remove(hKey);
414.     }
416.     /**
417.      * 删除Hash中的数据
418.      *
419.      * @param key   Redis键
420.      * @param hKeys Hash键
421.      */
422.     public static <T> void delMultiCacheMapValue(final String key, final Set<String> hKeys) {
423.         RBatch batch = CLIENT.createBatch();
424.         RMapAsync<String, T> rMap = batch.getMap(key);
425.         for (String hKey : hKeys) {
426.             rMap.removeAsync(hKey);
427.         }
428.         batch.execute();
429.     }
431.     /**
432.      * 获取多个Hash中的数据
433.      *
434.      * @param key   Redis键
435.      * @param hKeys Hash键集合
436.      * @return Hash对象集合
437.      */
438.     public static <K, V> Map<K, V> getMultiCacheMapValue(final String key, final Set<K> hKeys) {
439.         RMap<K, V> rMap = CLIENT.getMap(key);
440.         return rMap.getAll(hKeys);
441.     }
443.     /**
444.      * 设置原子值
445.      *
446.      * @param key   Redis键
447.      * @param value 值
448.      */
449.     public static void setAtomicValue(String key, long value) {
450.         RAtomicLong atomic = CLIENT.getAtomicLong(key);
451.         atomic.set(value);
452.     }
454.     /**
455.      * 获取原子值
456.      *
457.      * @param key Redis键
458.      * @return 当前值
459.      */
460.     public static long getAtomicValue(String key) {
461.         RAtomicLong atomic = CLIENT.getAtomicLong(key);
462.         return atomic.get();
463.     }
465.     /**
466.      * 递增原子值
467.      *
468.      * @param key Redis键
469.      * @return 当前值
470.      */
471.     public static long incrAtomicValue(String key) {
472.         RAtomicLong atomic = CLIENT.getAtomicLong(key);
473.         return atomic.incrementAndGet();
474.     }
476.     /**
477.      * 递减原子值
478.      *
479.      * @param key Redis键
480.      * @return 当前值
481.      */
482.     public static long decrAtomicValue(String key) {
483.         RAtomicLong atomic = CLIENT.getAtomicLong(key);
484.         return atomic.decrementAndGet();
485.     }
487.     /**
488.      * 获得缓存的基本对象列表
489.      *
490.      * @param pattern 字符串前缀
491.      * @return 对象列表
492.      */
493.     public static Collection<String> keys(final String pattern) {
494.         Stream<String> stream = CLIENT.getKeys().getKeysStreamByPattern(pattern);
495.         return stream.collect(Collectors.toList());
496.     }
498.     /**
499.      * 删除缓存的基本对象列表
500.      *
501.      * @param pattern 字符串前缀
502.      */
503.     public static void deleteKeys(final String pattern) {
504.         CLIENT.getKeys().deleteByPattern(pattern);
505.     }
507.     /**
508.      * 检查redis中是否存在key
509.      *
510.      * @param key 键
511.      */
512.     public static Boolean hasKey(String key) {
513.         RKeys rKeys = CLIENT.getKeys();
514.         return rKeys.countExists(key) > 0;
515.     }
516. }

复制代码

获取i18n资源文件

提供一下第 3  步需要 获取i18n资源文件 类，可以做国际化进行处理，如果项目没有国际化，这个可以省略

1. @NoArgsConstructor(access = AccessLevel.PRIVATE)
2. public class MessageUtils {
4.     private static final MessageSource MESSAGE_SOURCE = SpringUtils.getBean(MessageSource.class);
6.     /**
7.      * 根据消息键和参数 获取消息 委托给spring messageSource
8.      *
9.      * @param code 消息键
10.      * @param args 参数
11.      * @return 获取国际化翻译值
12.      */
13.     public static String message(String code, Object... args) {
14.         try {
15.             return MESSAGE_SOURCE.getMessage(code, args, LocaleContextHolder.getLocale());
16.         } catch (NoSuchMessageException e) {
17.             return code;
18.         }
19.     }
20. }

复制代码

自定义异常

这个我们再自定义一个业务异常类，用于抛出异常 ，如果自己项目之前有定义，也可以使用自己的异常类
ServiceException

1. @Data
2. @EqualsAndHashCode(callSuper = true)
3. @NoArgsConstructor
4. @AllArgsConstructor
5. public final class ServiceException extends RuntimeException {
7.     @Serial
8.     private static final long serialVersionUID = 1L;
10.     /**
11.      * 错误码
12.      */
13.     private Integer code;
15.     /**
16.      * 错误提示
17.      */
18.     private String message;
20.     /**
21.      * 错误明细，内部调试错误
22.      */
23.     private String detailMessage;
25.     public ServiceException(String message) {
26.         this.message = message;
27.     }
29.     public ServiceException(String message, Integer code) {
30.         this.message = message;
31.         this.code = code;
32.     }
34.     public String getDetailMessage() {
35.         return detailMessage;
36.     }
38.     @Override
39.     public String getMessage() {
40.         return message;
41.     }
43.     public Integer getCode() {
44.         return code;
45.     }
47.     public ServiceException setMessage(String message) {
48.         this.message = message;
49.         return this;
50.     }
52.     public ServiceException setDetailMessage(String detailMessage) {
53.         this.detailMessage = detailMessage;
54.         return this;
55.     }
56. }

复制代码

客户端工具类

如果对 ip  进行限流，在注解处理中会用到参数，ip ，url 等信息
ServletUtils

1. @NoArgsConstructor(access = AccessLevel.PRIVATE)
2. public class ServletUtils extends JakartaServletUtil {
3.      /**
4.      * 获取request
5.      */
6.     public static HttpServletRequest getRequest() {
7.         try {
8.             return getRequestAttributes().getRequest();
9.         } catch (Exception e) {
10.             return null;
11.         }
12.     }
13.    
14.      public static String getClientIP() {
15.         return getClientIP(getRequest());
16.     }
17. }

复制代码

3,处理限流注解

处理限流注解：RateLimiterAspect
对注解处理的核心代码就在这里，

1. @Slf4j
2. @Aspect
3. public class RateLimiterAspect {
5.     /**
6.      * 定义spel表达式解析器
7.      */
8.     private final ExpressionParser parser = new SpelExpressionParser();
9.     /**
10.      * 定义spel解析模版
11.      */
12.     private final ParserContext parserContext = new TemplateParserContext();
13.     /**
14.      * 定义spel上下文对象进行解析
15.      */
16.     private final EvaluationContext context = new StandardEvaluationContext();
17.     /**
18.      * 方法参数解析器
19.      */
20.     private final ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();
23.     /**
24.      * GLOBAL_REDIS_KEY 和  RATE_LIMIT_KEY  最好还是定义在项目的一个统一的常量文件中，这里为了解剖出来的文件少一点
25.      *
26.      * */
28.     /**
29.      * 全局 redis key (业务无关的key)
30.      */
31.     private final String GLOBAL_REDIS_KEY = "global:";
33.     /**
34.      * 限流 redis key
35.      */
36.     private final String RATE_LIMIT_KEY = GLOBAL_REDIS_KEY + "rate_limit:";
38.     @Before("@annotation(rateLimiter)")
39.     public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
40.         // 获取注解传的 时间 次数
41.         int time = rateLimiter.time();
42.         int count = rateLimiter.count();
43.         // 处理 key
44.         String combineKey = getCombineKey(rateLimiter, point);
45.         try {
46.             RateType rateType = RateType.OVERALL;
47.             if (rateLimiter.limitType() == LimitType.CLUSTER) {
48.                 rateType = RateType.PER_CLIENT;
49.             }
50.             long number = RedisUtils.rateLimiter(combineKey, rateType, count, time);
51.             if (number == -1) {
52.                 String message = rateLimiter.message();
53.                 if (StringUtils.startsWith(message, "{") && StringUtils.endsWith(message, "}")) {
54.                     message = MessageUtils.message(StringUtils.substring(message, 1, message.length() - 1));
55.                 }
56.                 throw new ServiceException(message);
57.             }
58.             log.info("限制令牌 => {}, 剩余令牌 => {}, 缓存key => '{}'", count, number, combineKey);
59.         } catch (Exception e) {
60.             if (e instanceof ServiceException) {
61.                 throw e;
62.             } else {
63.                 throw new RuntimeException("服务器限流异常，请稍候再试");
64.             }
65.         }
66.     }
69.     /**
70.      * 返回带有特定前缀的 key
71.      * @param rateLimiter 限流注解
72.      * @param point 切入点
73.      * @return key
74.      */
75.     public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {
76.         String key = rateLimiter.key();
77.         // 获取方法(通过方法签名来获取)
78.         MethodSignature signature = (MethodSignature) point.getSignature();
79.         Method method = signature.getMethod();
80.         Class<?> targetClass = method.getDeclaringClass();
81.         // 判断是否是spel格式
82.         if (StringUtils.containsAny(key, "#")) {
83.             // 获取参数值
84.             Object[] args = point.getArgs();
85.             // 获取方法上参数的名称
86.             String[] parameterNames = pnd.getParameterNames(method);
87.             if (ArrayUtil.isEmpty(parameterNames)) {
88.                 throw new ServiceException("限流key解析异常!请联系管理员!");
89.             }
90.             for (int i = 0; i < parameterNames.length; i++) {
91.                 context.setVariable(parameterNames[i], args[i]);
92.             }
93.             // 解析返回给key
94.             try {
95.                 Expression expression;
96.                 if (StringUtils.startsWith(key, parserContext.getExpressionPrefix())
97.                     && StringUtils.endsWith(key, parserContext.getExpressionSuffix())) {
98.                     expression = parser.parseExpression(key, parserContext);
99.                 } else {
100.                     expression = parser.parseExpression(key);
101.                 }
102.                 key = expression.getValue(context, String.class) + ":";
103.             } catch (Exception e) {
104.                 throw new ServiceException("限流key解析异常!请联系管理员!");
105.             }
106.         }
107.         // 限流前缀key
108.         StringBuilder stringBuffer = new StringBuilder(RATE_LIMIT_KEY);
109.         stringBuffer.append(ServletUtils.getRequest().getRequestURI()).append(":");
110.         // 判断限流类型
111.         if (rateLimiter.limitType() == LimitType.IP) {
112.             // 获取请求ip
113.             stringBuffer.append(ServletUtils.getClientIP()).append(":");
114.         } else if (rateLimiter.limitType() == LimitType.CLUSTER) {
115.             // 获取客户端实例id
116.             stringBuffer.append(RedisUtils.getClient().getId()).append(":");
117.         }
118.         return stringBuffer.append(key).toString();
119.     }
120. }

复制代码

到这里注解就定义好了，接下来就可以进行测试和使用！！！
测试限流

定义一个 Controller 来测试限流，这里返回的 R ，可以根据自己项目统一定义的返回，或者使用 void
RedisRateLimiterController

1. @Slf4j
2. @RestController
3. @RequestMapping("/demo/rateLimiter")
4. public class RedisRateLimiterController {
6.     /**
7.      * 测试全局限流
8.      * 全局影响
9.      */
10.     @RateLimiter(count = 2, time = 10)
11.     @GetMapping("/test")
12.     public R<String> test(String value) {
13.         return R.ok("操作成功", value);
14.     }
16.     /**
17.      * 测试请求IP限流
18.      * 同一IP请求受影响
19.      */
20.     @RateLimiter(count = 2, time = 10, limitType = LimitType.IP)
21.     @GetMapping("/testip")
22.     public R<String> testip(String value) {
23.         return R.ok("操作成功", value);
24.     }
26.     /**
27.      * 测试集群实例限流
28.      * 启动两个后端服务互不影响
29.      */
30.     @RateLimiter(count = 2, time = 10, limitType = LimitType.CLUSTER)
31.     @GetMapping("/testcluster")
32.     public R<String> testcluster(String value) {
33.         return R.ok("操作成功", value);
34.     }
36.     /**
37.      * 测试请求IP限流(key基于参数获取)
38.      * 同一IP请求受影响
39.      *
40.      * 简单变量获取 #变量 复杂表达式 #{#变量 != 1 ? 1 : 0}
41.      */
42.     @RateLimiter(count = 2, time = 10, limitType = LimitType.IP, key = "#value")
43.     @GetMapping("/testObj")
44.     public R<String> testObj(String value) {
45.         return R.ok("操作成功", value);
46.     }
48. }

复制代码

如果代码写的有问题，欢迎大家评论交流，进行指点！！！
也希望大家点个关注哦~~~~~~~~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！