自定义限流注解

先介绍一下 @Retention 和 @Target 这两个元注解
@Retention： 指定注解的生命周期（源码、class文件、运行时），其参考值见类的定义：java.lang.annotation.RetentionPolicy

• RetentionPolicy.SOURCE :在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override、@SuppressWarnings都属于这类注解。

• RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式。

• RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。
  @Target：指定注解使用的目标范围（类、方法、字段等），其参考值见类的定义：java.lang.annotation.ElementType

• ElementType.CONSTRUCTOR ：用于描述构造器。

• ElementType.FIELD ：成员变量、对象、属性（包括enum实例）。

• ElementType.LOCAL_VARIABLE: 用于描述局部变量。

• ElementType.METHOD ： 用于描述方法。

• ElementType.PACKAGE ：用于描述包。

• ElementType.PARAMETER ：用于描述参数。

• ElementType.ANNOTATION_TYPE：用于描述参数

• ElementType.TYPE ：用于描述类、接口(包括注解类型) 或enum声明。

自定义注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义限流注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AccessLimit {
    // 限流的时间范围，默认值5
    int second() default 5;
    // 最大访问次数，默认值5
    int maxCount() default 5;
}

根据上面@Retention 和 @Target的介绍，
我们可以知道我们自定义的@AccessLimit注解的生命周期是运行时，注解使用的目标范围是加在方法上

使用该注解

在接口方法上添加该注解

@RestController
public class TestController {

    @AccessLimit(second = 6, maxCount = 6)
    @GetMapping("/accessLimit")
    public String accessLimitTest() {
        return "hello hello";
    }
}

拦截器拦截添加该注解的接口

计数器限流算法

计数器算法是限流算法里最简单也是最容易实现的一种算法。比如我们规定，对于A接口来说，我们1分钟的访问次数不能超过100个。那么我们可以这么做：在一开 始的时候，我们可以设置一个计数器counter，每当一个请求过来的时候，counter就加1，如果counter的值大于100并且该请求与第一个 请求的间隔时间还在1分钟之内，那么说明请求数过多；如果该请求与第一个请求的间隔时间大于1分钟，且counter的值还在限流范围内，那么就重置 counter，具体算法的示意图如下：

自定义拦截器

import com.hkd.seckill.config.AccessLimit;
import com.hkd.seckill.pojo.User;
import com.hkd.seckill.service.UserService;
import com.hkd.seckill.util.CookieUtil;
import com.hkd.seckill.vo.RespBean;
import com.hkd.seckill.vo.RespBeanEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.concurrent.TimeUnit;

/**
 * 自定义拦截器 拦截 @AccessLimit 注解
 */
@Component
public class AccessLimitInterceptor implements HandlerInterceptor {

    @Autowired
    private UserService userService;
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 拦截 HandlerMethod 注解
     * @param request
     * @param response
     * @param handler
     * @return 该方法若返回 true 表示放行  返回false表示丢弃该请求
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod hm = (HandlerMethod) handler;
            // 拿到AccessLimit这个注解的信息
            AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class);
            // 若没有加 @HandlerMethod 这个注解，则直接放行
            if(accessLimit == null) {
                return true;
            }
            // 获取注解中限流的时间范围
            int second = accessLimit.second();
            // 获取注解中最大访问次数
            int maxCount = accessLimit.maxCount();
            // 获取当前请求的URL
            String key = request.getRequestURI();

            // 从cookie中获取sessionId
            String ticket = CookieUtil.getCookieValue(request, "userTicket");
            if (!StringUtils.hasLength(ticket)) {
                render(response, RespBeanEnum.SESSION_ERROR);
                return false;
            }
            // 从redis中获取用户信息
            User user = userService.getUserByCookie(ticket, request, response);
            if (user == null) {
                render(response, RespBeanEnum.SESSION_ERROR);
                return false;
            }

            key += ":" + user.getId();
            // 限流算法  计数器法 在second秒内 某个用户对于某个地址访问的次数不能超过 maxCount
            Integer count = (Integer)redisTemplate.opsForValue().get(key);
            if(count == null) {
                // 以 url:userId 为key
                // 初始值1为value
                // 过期时间为second秒 存储到Redis中
                redisTemplate.opsForValue().set(key, 1, second, TimeUnit.SECONDS);
            } else if (count < maxCount) {
                // 若未达到最大值 则累加
                redisTemplate.opsForValue().increment(key);
            } else {    // 访问次数过多
                // 若超过最大值 则返回自定义的提示信息 如： {"code":500504,"message":"访问过快，请稍后再试","obj":null}
                render(response, RespBeanEnum.ACCESS_LIMIT_REAHCED);
                return false;
            }
        }

        return true;
    }
    /**
     * 渲染，构建返回对象
     * @param response
     * @param respBeanEnum
     */
    private void render(HttpServletResponse response, RespBeanEnum respBeanEnum) throws IOException {
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");

        PrintWriter out = response.getWriter();
        RespBean respBean = RespBean.error(respBeanEnum);
        // 将数据以json字符串的方式返回
        out.write(new ObjectMapper().writeValueAsString(respBean)); // 返回信息：{"code":500504,"message":"访问过快，请稍后再试","obj":null}
        out.flush();
        out.close();
    }
}

实现步骤：

1. 自定义一个拦截器类 并 实现 HandlerInterceptor 接口
2. 重写preHandle方法， 该方法在被拦截接口方法执行前执行
3. AccessLimit accessLimit = hm.getMethodAnnotation(AccessLimit.class)获取接口方法的AccessLimit 注解，if(accessLimit == null){return true; }若没有添加该注解 则返回true，表示放行（我们只对加了@AccessLimit 的接口方法操作）
4. 紧接着 获取注解中的maxCount、second的值，并获取接口的url地址、用户userId等信息
5. 利用计数算法实现限流（配合Redis设置过期时间，原理简单）
   计数算法：生成一个计数器，每次请求计数器的值加1，若在一定时间范围内计数器的值达到阈值则进行限流操作
   实现代码：

// 获取注解中限流的时间范围
int second = accessLimit.second();
// 获取注解中最大访问次数
int maxCount = accessLimit.maxCount();
// 获取当前请求的URL
String key = request.getRequestURI();

// 从cookie中获取sessionId
// 获取用户信息
.....

key += ":" + user.getId();
// 限流算法  计数器法 在second秒内 某个用户对于某个地址访问的次数不能超过 maxCount
Integer count = (Integer)redisTemplate.opsForValue().get(key);
if(count == null) {
    // 以 url:userId 为key
    // 初始值1为value
    // 过期时间为second秒 存储到Redis中
    redisTemplate.opsForValue().set(key, 1, second, TimeUnit.SECONDS);
} else if (count < maxCount) {
    // 若未达到最大值 则累加
    redisTemplate.opsForValue().increment(key);
} else {    // 访问次数过多
    // 若超过最大值 则返回自定义的提示信息 如： {"code":500504,"message":"访问过快，请稍后再试","obj":null}
    render(response, RespBeanEnum.ACCESS_LIMIT_REAHCED);
    return false;
}

将拦截器加入到MVC配置中

/**
 * MVC配置类
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Autowired
	private AccessLimitInterceptor accessLimitInterceptor;

	/**
	 * 添加拦截器
	 * @param registry
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 拦截 加@HandlerMethod的方法
		registry.addInterceptor(accessLimitInterceptor);
	}
}

用例测试

正常访问：

6秒内请求超过6次：

若有不明白的，可以随时在评论区留言，希望能帮到你。