下面通过Aop自定义注解、Redis + Lua 脚本的方式实现限流，步骤会比较详细 :::info 引入依赖包 ::: pom文件中添加如下依赖包，比较关键的就是spring-boot-starter-data-redis和 spring-boot-starter-aop

    1. <dependencies>
    2.   <dependency>
    3.     <groupId>org.springframework.boot</groupId>
    4.     <artifactId>spring-boot-starter-web</artifactId>
    5.   </dependency>
    6.   <dependency>
    7.     <groupId>org.springframework.boot</groupId>
    8.     <artifactId>spring-boot-starter-data-redis</artifactId>
    9.   </dependency>
    10.   <dependency>
    11.     <groupId>org.springframework.boot</groupId>
    12.     <artifactId>spring-boot-starter-aop</artifactId>
    13.   </dependency>
    14.   <dependency>
    15.     <groupId>com.google.guava</groupId>
    16.     <artifactId>guava</artifactId>
    17.     <version>21.0</version>
    18.   </dependency>
    19.   <dependency>
    20.     <groupId>org.springframework.boot</groupId>
    21.     <artifactId>spring-boot-starter-test</artifactId>
    22.   </dependency>
    23.   <dependency>
    24.     <groupId>org.apache.commons</groupId>
    25.     <artifactId>commons-lang3</artifactId>
    26.   </dependency>
    28.   <dependency>
    29.     <groupId>org.springframework.boot</groupId>
    30.     <artifactId>spring-boot-starter-test</artifactId>
    31.     <scope>test</scope>
    32.     <exclusions>
    33.       <exclusion>
    34.         <groupId>org.junit.vintage</groupId>
    35.         <artifactId>junit-vintage-engine</artifactId>
    36.       </exclusion>
    37.     </exclusions>
    38.   </dependency>
    39. </dependencies>

    :::info 配置信息application.properties ::: 在application.properties文件中配置提前搭建好的redis服务地址和端口。

    1. spring.redis.host=127.0.0.1
    2. spring.redis.port=6379

    :::info 自定义RedisTemplate :::

    1. @Configuration
    2. public class RedisLimiterHelper {
    4.     @Bean
    5.     public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
    6.         RedisTemplate<String, Serializable> template = new RedisTemplate<>();
    7.         template.setKeySerializer(new StringRedisSerializer());
    8.         template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    9.         template.setConnectionFactory(redisConnectionFactory);
    10.         return template;
    11.     }
    12. }

    :::info 限流类型枚举 ::: 枚举类字段能够避免在业务处不小心打错字符串，代码更加的规范整洁

    1. /**
    2.  * @author liuyanntes
    3.  * @description 限流类型
    4.  * @date 2020/4/8 13:47
    5.  */
    6. public enum LimitType {
    8.     /**
    9.      * 自定义key
    10.      */
    11.     CUSTOMER,
    13.     /**
    14.      * 请求者IP
    15.      */
    16.     IP;
    17. }

    :::info 自定义AOP注解 ::: 我们自定义个@Limit注解
    注解类型为ElementType.METHOD即作用于方法上

    1. /**
    2.  * @author liuyanntes
    3.  * @description 自定义限流注解
    4.  * @date 2020/4/8 13:15
    5.  */
    6. @Target({ElementType.METHOD, ElementType.TYPE})
    7. @Retention(RetentionPolicy.RUNTIME)
    8. @Inherited
    9. @Documented
    10. public @interface Limit {
    12.     /**
    13.      * 名字
    14.      */
    15.     String name() default "";
    17.     /**
    18.      * key
    19.      */
    20.     String key() default "";
    22.     /**
    23.      * Key的前缀
    24.      */
    25.     String prefix() default "";
    27.     /**
    28.      * 请求限制时间段 单位(秒)
    29.      */
    30.     int period();
    32.     /**
    33.      * 在period()内最多访问次数
    34.      */
    35.     int count();
    37.     /**
    38.      * 限流的类型，可以根据请求的IP、自定义key
    39.      */
    40.     LimitType limitType()
    41. }

    :::info AOP切面逻辑 :::

    1. /**
    2.  * @author liuyanntes
    3.  * @description 限流切面实现
    4.  * @date 2020/4/8 13:04
    5.  */
    6. @Aspect
    7. @Configuration
    8. public class LimitInterceptor {
    10.     private static final Logger logger = LoggerFactory.getLogger(LimitInterceptor.class);
    12.     private static final String UNKNOWN = "unknown";
    14.     private final RedisTemplate<String, Serializable> limitRedisTemplate;
    16.     @Autowired
    17.     public LimitInterceptor(RedisTemplate<String, Serializable> limitRedisTemplate) {
    18.         this.limitRedisTemplate = limitRedisTemplate;
    19.     }
    21.     /**
    22.      * @param pjp
    23.      * @author liuyanntes
    24.      * @description 切面
    25.      * @date 2020/4/8 13:04
    26.      */
    27.     @Around("execution(public * *(..)) && @annotation(com.xiaofu.limit.api.Limit)")
    28.     public Object interceptor(ProceedingJoinPoint pjp) {
    29.         MethodSignature signature = (MethodSignature) pjp.getSignature();
    30.         Method method = signature.getMethod();
    31.         Limit limitAnnotation = method.getAnnotation(Limit.class);
    32.         LimitType limitType = limitAnnotation.limitType();
    33.         String name = limitAnnotation.name();
    34.         String key;
    35.         int limitPeriod = limitAnnotation.period();
    36.         int limitCount = limitAnnotation.count();
    38.         /**
    39.          * 根据限流类型获取不同的key ,如果不传我们会以方法名作为key
    40.          */
    41.         switch (limitType) {
    42.             case LimitType.IP:
    43.                 key = getIpAddress();
    44.                 break;
    45.             case LimitType.CUSTOMER:
    46.                 key = limitAnnotation.key();
    47.                 break;
    48.             default:
    49.                 key = StringUtils.upperCase(method.getName());
    50.         }
    52.         ImmutableList<String> keys = ImmutableList.of(StringUtils.join(limitAnnotation.prefix(), key));
    53.         try {
    54.             String luaScript = buildLuaScript();
    55.             RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
    56.             Number count = limitRedisTemplate.execute(redisScript, keys, limitCount, limitPeriod);
    57.             logger.info("Access try count is {} for name={} and key = {}", count, name, key);
    58.             if (count != null && count.intValue() <= limitCount) {
    59.                 return pjp.proceed();
    60.             } else {
    61.                 throw new RuntimeException("You have been dragged into the blacklist");
    62.             }
    63.         } catch (Throwable e) {
    64.             if (e instanceof RuntimeException) {
    65.                 throw new RuntimeException(e.getLocalizedMessage());
    66.             }
    67.             throw new RuntimeException("server exception");
    68.         }
    69.     }
    71.     /**
    72.      * @author liuyanntes
    73.      * @description 编写 redis Lua 限流脚本
    74.      * @date 2020/4/8 13:24
    75.      */
    76.     public String buildLuaScript() {
    77.         StringBuilder lua = new StringBuilder();
    78.         lua.append("local c");
    79.         lua.append("\nc = redis.call('get',KEYS[1])");
    80.         // 调用不超过最大值，则直接返回
    81.         lua.append("\nif c and tonumber(c) > tonumber(ARGV[1]) then");
    82.         lua.append("\nreturn c;");
    83.         lua.append("\nend");
    84.         // 执行计算器自加
    85.         lua.append("\nc = redis.call('incr',KEYS[1])");
    86.         lua.append("\nif tonumber(c) == 1 then");
    87.         // 从第一次调用开始限流，设置对应键值的过期
    88.         lua.append("\nredis.call('expire',KEYS[1],ARGV[2])");
    89.         lua.append("\nend");
    90.         lua.append("\nreturn c;");
    91.         return lua.toString();
    92.     }
    95.     /**
    96.      * @author liuyanntes
    97.      * @description 获取id地址
    98.      * @date 2020/4/8 13:24
    99.      */
    100.     public String getIpAddress() {
    101.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    102.         String ip = request.getHeader("x-forwarded-for");
    103.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
    104.             ip = request.getHeader("Proxy-Client-IP");
    105.         }
    106.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
    107.             ip = request.getHeader("WL-Proxy-Client-IP");
    108.         }
    109.         if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
    110.             ip = request.getRemoteAddr();
    111.         }
    112.         return ip;
    113.     }
    114. }

    :::info 控制层实现 ::: 我们将@Limit注解作用在需要进行限流的接口方法上，在10秒内只允许放行3个请求，这里为直观一点用AtomicInteger计数。

    1. /**
    2.  * @Author: liuyanntes
    3.  * @Description:
    4.  */
    5. @RestController
    6. public class LimiterController {
    8.     private static final AtomicInteger ATOMIC_INTEGER_1 = new AtomicInteger();
    9.     private static final AtomicInteger ATOMIC_INTEGER_2 = new AtomicInteger();
    10.     private static final AtomicInteger ATOMIC_INTEGER_3 = new AtomicInteger();
    12.     /**
    13.      * @author liuyanntes
    14.      * @description
    15.      * @date 2020/4/8 13:42
    16.      */
    17.     @Limit(key = "limitTest", period = 10, count = 3)
    18.     @GetMapping("/limitTest1")
    19.     public int testLimiter1() {
    21.         return ATOMIC_INTEGER_1.incrementAndGet();
    22.     }
    24.     /**
    25.      * @author liuyanntes
    26.      * @description
    27.      * @date 2020/4/8 13:42
    28.      */
    29.     @Limit(key = "customer_limit_test", period = 10, count = 3, limitType = LimitType.CUSTOMER)
    30.     @GetMapping("/limitTest2")
    31.     public int testLimiter2() {
    33.         return ATOMIC_INTEGER_2.incrementAndGet();
    34.     }
    36.     /**
    37.      * @author liuyanntes
    38.      * @description 
    39.      * @date 2020/4/8 13:42
    40.      */
    41.     @Limit(key = "ip_limit_test", period = 10, count = 3, limitType = LimitType.IP)
    42.     @GetMapping("/limitTest3")
    43.     public int testLimiter3() {
    45.         return ATOMIC_INTEGER_3.incrementAndGet();
    46.     }
    48. }

    :::info 限流测试 ::: 测试「预期」：10秒内的连续3次请求均可以成功，第4次请求被拒绝。接下来看一下是不是我们预期的效果
    请求地址：http://127.0.0.1:8080/limitTest1
    Lua限流器实现 - 图1
    可以看到第四次请求时，应用直接拒绝了请求，说明我们基于Aop自定义注解、Redis + Lua的限流方案搭建成功。Lua限流器实现 - 图2