背景

最近搞接口服务器，对兄弟团队提供数据接口，由于对接生产数据，担心小伙伴把我的数据库玩死，于是想着搞个请求限制吧，规定时间限制你的访问次数~~

大致设计了下思路就是，同一客户端请求同一资源时在规定时间给你的请求次数做限制，即标识你同一客户端且是同一资源的请求时，就给你个请求次数，当在规定时间里请求次数超过了我的阈值，我就给提示：“等回再来拿数据，你来的次数有点多~~~~”，次数清除的机制就是指定的时间过了；怎么用呢？？在每个请求接口上加个注解就能用，这样扩展好，也简单复用

嗯，大致就是这个思路了，看来map是跑不了了，然后有一个点就是过期时间限制，自己写！@！#￥%……&*）,想了一下放弃吧，搜搜总有类似的需求，不要浪费时间自己造车了，对，我就是懒~~~

ExpiringMap

简简单单搜了一下，就是这货了，被封装好的高性能的线程安全的一个轻量级的map组件(A high performance, low-overhead, zero dependency, thread-safe ConcurrentMap implementation that expires entries)，敲黑板~~~

关键字：高性能、低开销、零依赖、线程安全

它包括的功能点：

Expiration policies ：过期策略基于实体的创建时间或是最后一次的访问时间制定

Map<String, Connection> map = ExpiringMap.builder().expirationPolicy(ExpirationPolicy.ACCESSED).build();
//CREATED是每次创建元素时过期时间清0；ACCESSED是指每次访问时清0
map.put("connection", connection, ExpirationPolicy.CREATED);

Variable expiration：多种：也可以针对map中的实体制定它的过期策略

ExpiringMap<String, Connection> map = ExpiringMap.builder().variableExpiration().build();
map.put("connection", connection, ExpirationPolicy.ACCESSED, 5, TimeUnit.MINUTES);
//像这样给Map中的connection设定过期时间和过期策略
map.setExpiration(connection, 5, TimeUnit.MINUTES);
map.setExpirationPolicy(connection, ExpirationPolicy.ACCESSED);

Maximum size: 可以指定大小，当map大小到达指定时，会自己扩展且过期策略会与第一个entry相同

Map<String, Connection> map = ExpiringMap.builder().maxSize(123).build();

Expiration listeners: 可以用事件的监听做为过期策略

//当entry过期时，监听会被通知
Map<String, Connection> map = ExpiringMap.builder().expirationListener((key, connection) -> connection.close()).build();
//entries 过期时同步调用过期监听，map的写操作会被blocked，直到过期监听事件完成后；也可以配置成不阻塞map操作的过期监听
Map<String, Connection> map = ExpiringMap.builder().asyncExpirationListener((key, connection) -> connection.close()).build();
//map在使用的时间也可以增加或移除过期监听
ExpirationListener<String, Connection> connectionCloser = (key, connection) -> connection.close();
map.addExpirationListener(connectionCloser);
map.removeExpirationListener(connectionCloser);

Lazy entry loading：当ExpiringMap.get被调用时，Entries可以通过EntryLoader进行懒加载

Map<String, Connection> connections = ExpiringMap.builder().expiration(10, TimeUnit.MINUTES).entryLoader(address -> new Connection(address)).build();// Loads a new connection into the map via the EntryLoader
connections.get("jodah.net");

Expiration Introspection：过期时间监测（自省检查），可以查看到过期时间，也可以重置过期时间，也可以知道Map中的特定的entries的配置情况

有兴趣深究的可以去下载源码哈：

https://github.com/jhalterman/expiringmap#expiration-policies

限制请求次数应用示例

pom依赖

<dependency><groupId>net.jodah</groupId><artifactId>expiringmap</artifactId><version>0.5.8</version>
</dependency>

注解类定义

上面在思路设计中也说了，想在每个被请求的接口上直接加一个注解类，就可以了，这样可做到简单复用。那我们开始码注解类吧

import java.lang.annotation.*;/*** @Description: 接口注解用，30秒内同一接口只许调1次* @Param:* @return:* @Author: 张璐* @Date: 2021/10/21*/
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LimitRequest {long time() default 1000 * 30;//限制时间，单位msint count() default 1;
}

切面定义

注解类搞定了，利用AOP思想，每个请求来先到我的切面里校验下是不是超限了呢。现在还需要一个切面;自己先定义一个全局的map：book 里面装键是请求的资源信息；值是ExpiringMap,我们用的过期策略是生成新的对象是清0；它的键对象是请求的客户端的地址，值是请求的次数，然后进行判断就可以了。

package com.test.zhanglu.interfaceapi.component;import com.chenergy.positioning.coalmine.positioning.interfaceapi.common.BusinessException;
import com.chenergy.positioning.coalmine.positioning.interfaceapi.common.Constants;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import net.jodah.expiringmap.ExpirationPolicy;
import net.jodah.expiringmap.ExpiringMap;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;/*** @Description: 每个请求不能超过30s/次的切面控制器* @Param:* @return:* @Author: 张璐* @Date: 2021/10/21*/
@Component
@Aspect
@Slf4j
public class LimitRequestAspct {private static ConcurrentHashMap<String, ExpiringMap<String, Integer>> book = new ConcurrentHashMap<>();@Pointcut("@annotation(limitRequest)")public void excute(LimitRequest limitRequest) {}@SneakyThrows@Around("excute(limitRequest)")public Object doAround(ProceedingJoinPoint pjp, LimitRequest limitRequest) {RequestAttributes ra = RequestContextHolder.getRequestAttributes();ServletRequestAttributes sra = (ServletRequestAttributes) ra;HttpServletRequest request = sra.getRequest();log.info("进入切页调试项，uri:{},remoteUrl:{}", request.getRequestURI(), request.getRemoteAddr());ExpiringMap<String, Integer> expiringMap = book.getOrDefault(request.getRequestURI(), ExpiringMap.builder().variableExpiration().build());Integer uCount = expiringMap.getOrDefault(request.getRemoteAddr(), 0);if (uCount >= limitRequest.count()) {throw new BusinessException(Constants.ResultBodyErrorEnum.SIGNATURE_NOT_MATCH.getCode(), Constants.ResultBodyErrorEnum.SIGNATURE_NOT_MATCH.getMessage());} else if (uCount == 0) {expiringMap.put(request.getRemoteAddr(), ++uCount, ExpirationPolicy.CREATED, limitRequest.time(), TimeUnit.MILLISECONDS);} else {expiringMap.put(request.getRemoteAddr(), ++uCount);}book.put(request.getRequestURI(), expiringMap);Object result = pjp.proceed();return result;}}

Controler示例

方法体上加上我们写好的注解就行了

/*** @Description: 报警相关的接口请求类* @Param:* @return:* @Author: 张璐* @Date: 2021/10/21*/
@RestController
@Slf4j
public class AlarmController {@AutowiredIAlarmService alarmService;@LimitRequest@GetMapping(value = "/getTestCount")public ResultBody getAlarmCountByType(@RequestParam("token") String token, @RequestParam(value = "com", required = false) String com, @RequestParam(value = "code", required = false) String code, @RequestParam(value = "type", required = false) String tepe) {Map<String, Integer> map = alarmService.getAlarmCount(corpCode, mienCode, teyp);return ResultBody.success(map);}
}