通过注解实现请求频率限制

1.首先创建注解类RequestLimit

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {
    /**
     * 两次请求的最小间隔时间(ms)
     * @return
     */
    int interval() default -1;
}

2.创建切面类RepeatRequestAspect

import com.alibaba.fastjson.JSON;
import com.atguigu.cache.annotations.RequestLimit;
import com.atguigu.cache.enums.BusinessExceptionEnum;
import com.atguigu.cache.exception.BusinessException;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Aspect
@Component
public class RepeatRequestAspect {

    @Autowired
    RedisTemplate redisTemplate;

    @Autowired
    HttpServletRequest request;

    private String REQUEST_PRFIX = "api:request:REQUEST_%s_%d";

    private Long OFFSET = 1577808000000L;

    @Around("@annotation(limit)")
    public Object around(ProceedingJoinPoint pjp, RequestLimit limit) throws Throwable {
        if (limit.interval() == -1) {
            return pjp.proceed();
        }
        Long userId = getUserId();
        String path = String.format(REQUEST_PRFIX, request.getServletPath(), userId);
        limitInterval(limit, path);
        return pjp.proceed();
    }

    private void limitInterval(RequestLimit limit, String path) throws BusinessException {
        path = path.replaceAll("/", "");
        Boolean hasKey = redisTemplate.hasKey(path);
        if (hasKey) {
            String timeJson = (String) redisTemplate.boundValueOps(path).get();
            Long beforeTime = Long.valueOf(timeJson);
            Long compareTime = System.currentTimeMillis() - OFFSET - beforeTime;
            int count = limit.interval();
            if (compareTime < Long.valueOf(count)) {
                throw new BusinessException(BusinessExceptionEnum.TOO_MANY_REQUESTS);
            }

        }
        String s = JSON.toJSONString(System.currentTimeMillis() - OFFSET);
        redisTemplate.boundValueOps(path).set(s,1000*20,TimeUnit.MILLISECONDS);
    }

    public Long getUserId() {
        //简写token校验用户。。。
        String userId = request.getHeader("userId");
        return Long.valueOf(userId);
    }
}

@Around("@annotation(limit)")
public Object around(ProceedingJoinPoint pjp, RequestLimit limit)

注意这里的写法：

@annotation(limit) 这里的limit，是spring提供的根据上下文解析到的参数里的RequestLimit limit ，表示切面表达式是以加了该注解为切面进行方法增强。并且在around方法中可以获取RequestLimit limit里面设置的参数（interval ）。ProceedingJoinPoint pjp这个参数：环绕通知 ProceedingJoinPoint 执行proceed方法的作用是让目标方法执行，这也是环绕通知和前置、后置通知方法的一个最大区别。简单理解，环绕通知=前置+目标方法执行+后置通知，proceed方法就是用于启动目标方法执行的.

本次只写了限制两次请求间隔时间：

实现原理：将上一次的请求url+用户id作为key存入redis，使用时间戳-固定时间戳作为value（这样做是为了‘压缩’存入redis的数据值）；下次请求来的时候判断间隔时间就行了。

3.使用该注解进行访问限制

    @GetMapping("/limit")
    @RequestLimit(interval = 5000)
    public String limit() {
        return "normal";
    }

注意：

需要添加的依赖有：

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
		</dependency>

关于次数限制和次数加频率限制，相信大家看了这篇博客之后稍加思考就能搞定，3q大家的观看！