经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » Redis » 查看文章
redis + AOP + 自定义注解实现接口限流
来源：cnblogs　　作者：古渡蓝按　　时间：2024/1/5 9:12:12　　对本文有异议

限流介绍

限流（rate limiting）

? 是指在一定时间内，对某些资源的访问次数进行限制，以避免资源被滥用或过度消耗。限流可以防止服务器崩溃、保证用户体验、提高系统可用性。

限流的方法有很多种，常见的有以下几种：

  • 漏桶算法：

    ? 漏桶算法通过一个固定大小的漏桶来模拟流量，当流量进入漏桶时，会以恒定的速率从漏桶中流出。如果流量超过漏桶的容量，则会被丢弃。

  • 令牌桶算法：

    ? 令牌桶算法通过一个固定大小的令牌桶来模拟流量，当流量进入令牌桶时，会从令牌桶中取出一个令牌。如果令牌桶中没有令牌，则会拒绝该流量。

  • 滑动窗口算法：

    ? 滑动窗口算法通过一个固定大小的滑动窗口来模拟流量，当流量进入滑动窗口时，会统计窗口内流量的数量。如果窗口内流量的数量超过了一定的阈值，则会拒绝该流量。

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

  • 防止服务器崩溃：当服务器的请求量过大时，可以通过限流来防止服务器崩溃。

  • 保证用户体验：当用户请求某个资源的频率过高时，可以通过限流来降低用户的等待时间。

  • 提高系统可用性：当系统的某些资源被滥用或过度消耗时，可以通过限流来提高系统的可用性。

?

? 限流是一个非常重要的技术，它可以帮助我们提高系统的稳定性和可用性。在实际开发中，我们可以根据不同的场景选择合适的限流算法。

我们定义的注解使用到技术：redis，redisson，AOP，自定义注解等

依赖

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

  1.         <!--redisson-->
  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.        <!-- Spring框架基本的核心工具 -->
  13.         <dependency>
  14.             <groupId>org.springframework</groupId>
  15.             <artifactId>spring-context-support</artifactId>
  16.         </dependency>
  18.         <!-- SpringWeb模块 -->
  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.         <!-- aop -->
  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.         <!-- servlet包 -->
  43.         <dependency>
  44.             <groupId>jakarta.servlet</groupId>
  45.             <artifactId>jakarta.servlet-api</artifactId>
  46.         </dependency>
  48.       <!-- hutool 工具类 -->
  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.        <!-- lombok 工具类 -->
  66.         <dependency>
  67.             <groupId>org.projectlombok</groupId>
  68.             <artifactId>lombok</artifactId>
  69.         </dependency>
  71.         <!--  自动生成YML配置关联JSON文件  -->
  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.         <!-- 离线IP地址定位库 -->
  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. }

如果代码写的有问题，欢迎大家评论交流，进行指点！！！

也希望大家点个关注哦~~~~~~~~

原文链接：https://www.cnblogs.com/blbl-blog/p/17944006

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Redis热门文章

  • Redis-复制
  • Redis
  • 关于SpringBoot整合redis使用Lettuce客户端超时问题
  • RedisTemplate常用方法封装
  • RedisTemplate中opsForValue和opsForList方法的使用详解
  • Redis7.0部署集群的实现步骤
  • Java&nbsp;Redis&nbsp;Redisson配置教程详解
  • Go语言开发redis封装及简单使用详解
  • SpringBoot Redis批量存取数据的操作
  • .NetCore下基于FreeRedis实现的Redis6.0客户端缓存之缓存键条件优雅过滤

    • Redis推荐文章

  • Redis系列：使用Stream实现消息队列 （图文总结+Go案例） - Hello-Brand
  • 记一次 redis 事件注册不当导致的内存泄露
  • Java Redis多限流
  • 【Azure Developer】一个复制Redis Key到另一个Redis服务的工具(redis_copy_net8)
  • Redis 高阶应用
  • 【长文】带你搞明白Redis
  • StackExchange.Redis跑起来，为什么这么溜？
  • 【进阶篇】基于 Redis 实现分布式锁的全过程
  • Higress 基于自定义插件访问 Redis
  • 美团二面：如何保证Redis与Mysql双写一致性？连续两个面试问到了！

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号