通过注解实现请求频率限制
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大家的观看!