Java使用自定义注解限制接口调用频率

青旬

        记录一次在公司遇到的错误：当时对接了高德的周边搜索接口开放给前端调用，但是只是过了3个小时前端就过来找我说接口报错了，我看日志发现问题是高德接口调用次数在当日已经超过了5000次所以高德做限制了，于是决定做接口我调用频率限制的代码。

        限制接口调用频率的方法一般都是通过时间来判断，所以最好的办法就是使用redis来记录接口调用的时间。

        这里我先放上使用 HashMap<String, Long> 代替redis的一种非常简单的写法。

  1. import java.time.LocalDateTime;
  2. import java.util.HashMap;
  3.  
  4. /**
  5.  * @author QingXun123
  6.  * @version 1.0.0
  7.  * @since 2023-08-29
  8.  */
  9. public class SubmitBufferSingleton {
  10.  
  11.     private static HashMap<String, Long> hashMap = new HashMap<>();
  12.  
  13.     private SubmitBufferSingleton() {
  14.     }
  15.  
  16.     public static HashMap<String, Long> getInstance() {
  17.         return hashMap;
  18.     }
  19. }

        SubmitBufferSingleton 用来获取唯一的 HashMap<String, Long>，其中的Value是从 1970-01-01T00:00:00Z（协调世界时，UTC）到当前时间点之间的毫秒数。

  1. import org.springframework.core.Ordered;
  2. import org.springframework.core.annotation.Order;
  3.  
  4. import java.lang.annotation.*;
  5.  
  6. /**
  7.  * @author QingXun123
  8.  * @version 1.0.0
  9.  * @since 2023-08-29
  10.  */
  11. @Retention(RetentionPolicy.RUNTIME)
  12. @Target({ElementType.TYPE, ElementType.METHOD})
  13. @Documented
  14. @Order(Ordered.HIGHEST_PRECEDENCE)
  15. public @interface RequestLimit {
  16.  
  17.     long time() default 5000;
  18. }

         time是调用接口的间隔时间，默认是 5000 毫秒。

  1. import com.qingxun.aspect.annotation.RequestLimit;
  2. import com.qingxun.singleton.SubmitBufferSingleton;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.aspectj.lang.ProceedingJoinPoint;
  5. import org.aspectj.lang.annotation.Around;
  6. import org.aspectj.lang.annotation.Aspect;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.web.context.request.RequestContextHolder;
  9. import org.springframework.web.context.request.ServletRequestAttributes;
  10.  
  11. import javax.servlet.http.HttpServletRequest;
  12. import java.time.Instant;
  13. import java.util.HashMap;
  14.  
  15. /**
  16.  * @author QingXun123
  17.  * @version 1.0.0
  18.  * @since 2023-08-29
  19.  */
  20. @Aspect
  21. @Component
  22. @Slf4j
  23. public class NoRepeatSubmitAop {
  24.  
  25.     @Synchronized // 作用是创建一个互斥锁，保证只有一个线程对 SubmitBufferSingleton.getInstance() 这个变量进行修改。
  26.     @Around("execution(* com.example..client.amap.controller..*.*(..)) && @annotation(nrs)") // 这里要根据自己项目中的controller包路径来配置好
  27.     public Object arround(ProceedingJoinPoint pjp, RequestLimit nrs) throws Throwable {
  28.  
  29.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  30.         HttpServletRequest request = attributes.getRequest();
  31.         Object[] args = pjp.getArgs();
  32.         String key = getIp(request) + " ：" + request.getServletPath();
  33.         Long time = nrs.time();
  34.         Object o = null;
  35.         HashMap<String, Long> hashMap = SubmitBufferSingleton.getInstance();
  36.         long nowTime = Instant.now().toEpochMilli();
  37.         if (!hashMap.containsKey(key)) {
  38.             hashMap.put(key, nowTime + time);
  39.             o = pjp.proceed();
  40.             return o;
  41.         } else {
  42.             if (nowTime > hashMap.get(key)) {
  43.                 hashMap.put(key, nowTime + time);
  44.                 o = pjp.proceed();
  45.                 return o;
  46.             } else {
  47.                 log.error("操作过于频繁 {}", key);
  48.                 return "操作过于频繁";
  49.             }
  50.         }
  51.  
  52.     }
  53.  
  54.  
  55.     // 获取调用者ip
  56.     private static String getIp(HttpServletRequest request){
  57.         String ip = request.getHeader("x-forwarded-for");
  58.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  59.             ip = request.getHeader("Proxy-Client-IP");
  60.         }
  61.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  62.             ip = request.getHeader("WL-Proxy-Client-IP");
  63.         }
  64.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  65.             ip = request.getHeader("HTTP_CLIENT_IP");
  66.         }
  67.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  68.             ip = request.getHeader("HTTP_X_FORWARDED_FOR");
  69.         }
  70.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  71.             ip = request.getRemoteAddr();
  72.         }
  73.         return ip;
  74.     }
  75.  
  76. }

        这里其实可以直接将 HashMap<String, Long> 放到 NoRepeatSubmitAop 中的。将这个分离出来是为了解耦。

  1. import com.qingxun.singleton.SubmitBufferSingleton;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.springframework.scheduling.annotation.Scheduled;
  4. import org.springframework.stereotype.Component;
  5.  
  6. import java.time.Instant;
  7. import java.time.LocalDateTime;
  8. import java.util.HashMap;
  9. import java.util.Iterator;
  10. import java.util.Map;
  11.  
  12. /**
  13.  * @author QingXun123
  14.  * @version 1.0.0
  15.  * @since 2023-08-29
  16.  */
  17. @Component
  18. @Slf4j
  19. public class NoRepeatSubmitTask {
  20.  
  21.     @Scheduled(cron = "0 0 1 * * ?")
  22.     public void start() {
  23.         HashMap<String, Long> hashMap = SubmitBufferSingleton.getInstance();
  24.         Iterator<Map.Entry<String, Long>> iterator = hashMap.entrySet().iterator();
  25.         while (iterator.hasNext()) {
  26.             Map.Entry<String, Long> next = iterator.next();
  27.             String key = next.getKey();
  28.             Long value = next.getValue();
  29.             if (value > Instant.now().toEpochMilli()) {
  30.                 hashMap.remove(key);
  31.             }
  32.         }
  33.         // 如果对时间没有特别严格的要求就直接clear
  34. //        hashMap.clear();
  35.     }
  36. }

        这里设置一个定时器在每天的凌晨1点清理一下HashMap数据，防止 HashMap<String, Long> 越来越大。将 HashMap<String, Long> 从 NoRepeatSubmitAop 中抽出来的优点在这里也体现出来了。

        如果使用了redis就不需要用到定时器，直接设置好过期时间让redis自己删除就可以了。

  1. import com.qingxun.aspect.annotation.RequestLimit;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.stereotype.Component;
  8. import org.springframework.web.context.request.RequestContextHolder;
  9. import org.springframework.web.context.request.ServletRequestAttributes;
  10.  
  11. import javax.annotation.Resource;
  12. import javax.servlet.http.HttpServletRequest;
  13. import java.util.concurrent.TimeUnit;
  14.  
  15. /**
  16.  * @author QingXun123
  17.  * @version 1.0.0
  18.  * @since 2023-08-29
  19.  */
  20. @Aspect
  21. @Component
  22. @Slf4j
  23. public class NoRepeatSubmitAop {
  24.  
  25.     @Resource
  26.     public RedisTemplate redisTemplate;
  27.  
  28.     //@Synchronized // 根据情况使用
  29.     @Around("execution(* com.example.controller..*.*(..)) && @annotation(nrs)") // 这里要根据自己项目中的controller包路径来配置好
  30.     public Object arround(ProceedingJoinPoint pjp, RequestLimit nrs) throws Throwable {
  31.  
  32.         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  33.         HttpServletRequest request = attributes.getRequest();
  34.         Object[] args = pjp.getArgs();
  35.         String key = getIp(request) + " ：" + request.getServletPath();
  36.         Object o = null;
  37.         Long time = nrs.time();
  38.  
  39.         if (!redisTemplate.hasKey(key)) {
  40.             redisTemplate.opsForValue().set(key, 0, time.intValue(), TimeUnit.MILLISECONDS);
  41.             o = pjp.proceed();
  42.             return o;
  43.         } else {
  44.             log.error("操作过于频繁 {}", key);
  45.             return "操作过于频繁";
  46.         }
  47.  
  48.     }
  49.  
  50.     // 获取调用者ip
  51.     private static String getIp(HttpServletRequest request){
  52.         String ip = request.getHeader("x-forwarded-for");
  53.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  54.             ip = request.getHeader("Proxy-Client-IP");
  55.         }
  56.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  57.             ip = request.getHeader("WL-Proxy-Client-IP");
  58.         }
  59.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  60.             ip = request.getHeader("HTTP_CLIENT_IP");
  61.         }
  62.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  63.             ip = request.getHeader("HTTP_X_FORWARDED_FOR");
  64.         }
  65.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  66.             ip = request.getRemoteAddr();
  67.         }
  68.         return ip;
  69.     }
  70.  
  71. }

        这里直接判断redis中是否有这个key，没有就说明没有调用过这个接口或者已经超过了限制时间，所以后端就可以返回数据给前端。

        测试一下是否有用。

         这里我们简单写了一个测试接口，然后在 swagger 中调用成功。

         再点一下就失败了。

        测试通过。

        事实证明后端还是不能相信前端，前端调试3个小时调了我5000次的接口😂。