AccessLimitIntercept

@Component
@Slf4j
/**
 * 对请求服务的请求进行限流
 */
public class AccessLimitIntercept implements HandlerInterceptor {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 接口调用前检查对方ip是否频繁调用接口
     *
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public  boolean  preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String macParam = request.getParameter("mac");
        String requestURI = request.getRequestURI();
        try {
            if (handler instanceof HandlerMethod) {

                HandlerMethod handlerMethod = (HandlerMethod) handler;
                Method method = handlerMethod.getMethod();
                // 判断方式是否有AccessLimit注解，有的才需要做限流
                if (!method.isAnnotationPresent(MACAccessLimit.class)) {
                    return true;
                }

                // 获取注解上的内容
                MACAccessLimit MACAccessLimit = method.getAnnotation(MACAccessLimit.class);
                if (MACAccessLimit == null) {
                    return true;
                }

                if (StringUtils.isEmpty(macParam)) {
                    return true;
                }
                log.info("mac:[{}],requestURI:[{}]", macParam, requestURI);
                //c0:84:7d:f8:60:b1_/api/get-guideScreen
                String key = macParam + requestURI;

                // 获取方法注解上的请求次数
                int limitCount = MACAccessLimit.maxAccess();
                // 获取方法注解上的请求时间
                Integer timeoutSecond = MACAccessLimit.second();

                synchronized (this) {
                    // 获取redis中存的访问次数
                    Integer maxAccess = null;
                    String value = redisTemplate.opsForValue().get(key);
                    if (StringUtils.isNotEmpty(value)) {
                        maxAccess = Integer.valueOf(value);
                    }
                    if (maxAccess == null) {
                        // 如果redis中没有该ip对应的时间则表示第一次调用，保存key到redis
                        redisTemplate.opsForValue().set(key, "1", timeoutSecond, TimeUnit.SECONDS);
                    } else if (maxAccess < limitCount) {
                        // 如果redis中的时间比注解上的时间小则表示可以允许访问,这是修改redis的value时间
                        redisTemplate.opsForValue().set(key, (++maxAccess) + "", timeoutSecond, TimeUnit.SECONDS);
                    } else {
                        log.info("mac=[{}]请求[{}]太频繁了 被拦截！！！", macParam, requestURI);
                        ResultDTO results = new ResultDTO();
                        results.setCode(ErrorCodeEnum.ACCESS_LIMIT.getCode());
                        results.setMsg(ErrorCodeEnum.ACCESS_LIMIT.getMsg());
                        results.setData("frequently");
                        setResponse(results, response);
                        return false;
                    }
                }
            }
        } catch (Exception e) {
            log.error("API请求限流拦截异常，异常原因：", e);
            return true;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }


    private void setResponse(ResultDTO results, HttpServletResponse response) throws IOException {
        ServletOutputStream outputStream = null;
        try {
            response.setHeader("Content-type", "application/json; charset=utf-8");
            outputStream = response.getOutputStream();
            outputStream.write(JSON.toJSONString(results).getBytes("UTF-8"));
        } catch (Exception e) {
            log.error("setResponse方法报错", e);
        } finally {
            if (outputStream != null) {
                try {
                    outputStream.flush();
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

/**
 * 以mac为唯一标示进行限流
 */
@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MACAccessLimit {
    /**
     * 指定second 时间内，API最多的请求次数
     */
    int maxAccess() default 3;

    /**
     * 指定时间second，redis数据过期时间
     */
    int second() default 60;
}