coding++：高并发解决方案限流技术-使用RateLimiter实现令牌桶限流-Demo

<dependency>
     <groupId>com.google.guava</groupId>
     <artifactId>guava</artifactId>
     <version>25.1-jre</version>
 </dependency>

package com.aiyuesheng.controller;

import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.aiyuesheng.hystrix.OrderHystrixCommand;
import com.aiyuesheng.service.OrderService;
import com.aiyuesheng.utils.LimitService;
import com.alibaba.fastjson.JSONObject;
import com.google.common.util.concurrent.RateLimiter;

@RestController
public class Index {// 令牌桶：1.0 表示 每秒中生成1个令牌存放在桶中
    RateLimiter rateLimiter = RateLimiter.create(1.0);

    @Autowired
    private OrderService orderService;
//令牌桶限流
    @RequestMapping("/searchCustomerInfoByRateLimiter")
    public Object searchCustomerInfoByRateLimiter() {
        // 1.限流判断
        // 如果在0.5秒内 没有获取不到令牌的话，则会一直等待
        System.out.println("生成令牌等待时间:" + rateLimiter.acquire());
        boolean acquire = rateLimiter.tryAcquire(500, TimeUnit.MILLISECONDS); // 每次发送请求，愿意等待0.5秒，如果设为1秒，每次都能查询成功，因为没秒中都会放入一个令牌到桶中
        if (!acquire) {
            System.out.println("稍后再试！");
            return "稍后再试！";
        }
        // 2.如果没有达到限流的要求,直接调用接口查询
        System.out.println(orderService.searchCustomerInfo());
        return orderService.searchCustomerInfo();
    }

}

package com.tree.ztree_demo.currentlimiting;

import java.lang.annotation.*;

/**
 * @version V1.0
 * @Title: RateLimit.java
 * @Package mlq.pic.picback.currentlimiting
 * @Description: 限流注解
 * @author: MLQ
 * @date: 2019/11/14 14:52
 */
@Inherited
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    /**
     * 默认每秒支持2个
     *
     * @return
     */
    int limintNum() default 2;


}

package com.tree.ztree_demo.currentlimiting;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.util.concurrent.RateLimiter;
import groovy.util.logging.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * @version V1.0
 * @Title: RateLimitAspect.java
 * @Package mlq.pic.picback.currentlimiting
 * @Description: 增强限流拦截
 * @author: MLQ
 * @date: 2019/11/14 14:54
 */
@Component
@Scope
@Aspect
@Slf4j
public class RateLimitAspect {

    private static final Logger LOGGER = LoggerFactory.getLogger(RateLimitAspect.class);

    /**
     * 用来存放不同接口的RateLimiter(key为接口名称，value为RateLimiter)
     */
    private ConcurrentHashMap<String, RateLimiter> map = new ConcurrentHashMap<>();

    private static final String POINT = "execution (* com.tree.ztree_demo..*.abc*(..))";

    private static ObjectMapper objectMapper = new ObjectMapper();

    private RateLimiter rateLimiter;

    @Autowired
    private HttpServletResponse response;

    @Pointcut(POINT)
    public void serviceLimit() {
    }

    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        Object obj = null;
        //获取拦截的方法名
        Signature sig = joinPoint.getSignature();
        //获取拦截的方法名
        MethodSignature msig = (MethodSignature) sig;
        //返回被织入增加处理目标对象
        Object target = joinPoint.getTarget();
        //为了获取注解信息
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        //获取注解信息
        RateLimit annotation = currentMethod.getAnnotation(RateLimit.class);
        if (!ObjectUtils.isEmpty(annotation)) {
            //获取注解每秒加入桶中的token
            int limitNum = annotation.limintNum();

            // 注解所在方法名区分不同的限流策略
            String functionName = msig.getName();

            //获取rateLimiter
            if (map.containsKey(functionName)) {
                rateLimiter = map.get(functionName);
            } else {
                map.put(functionName, RateLimiter.create(limitNum));
                rateLimiter = map.get(functionName);
            }
            // 如果在0.5秒内 没有获取不到令牌的话，则会一直等待
            System.out.println("生成令牌等待时间:" + rateLimiter.acquire());
            try {
                // 每次发送请求，愿意等待0.5秒，如果设为1秒，每次都能查询成功，因为没秒中都会放入一个令牌到桶中
                if (rateLimiter.tryAcquire(500, TimeUnit.MILLISECONDS)) {
                    //执行方法
                    obj = joinPoint.proceed();
                } else {
                    Map<String, Object> map = new HashMap<>();
                    map.put("code", 100001);
                    map.put("message", "系统繁忙，请稍后再试！");
                    //拒绝了请求（服务降级）
                    String result = objectMapper.writeValueAsString(map);
                    LOGGER.info("拒绝了请求：" + result);
                    outErrorResult(result);
                }
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        } else {
            Map<String, Object> map = new HashMap<>();
            map.put("code", 403);
            map.put("message", "签名问题");
            //拒绝了请求（服务降级）
            String result = null;
            try {
                result = objectMapper.writeValueAsString(map);
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
            LOGGER.info("拒绝了请求：" + result);
            outErrorResult(result);
        }
        return obj;
    }

    //将结果返回
    public void outErrorResult(String result) {
        response.setContentType("application/json;charset=UTF-8");
        try (ServletOutputStream outputStream = response.getOutputStream()) {
            outputStream.write(result.getBytes("utf-8"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static {
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    }

}

@RateLimit(limintNum = 100)
@RequestMapping("abc")
public Object abc() {
    Map<String, Object> map = new HashMap<>();
    map.put("code", "200");
    map.put("message", "OK");
    return JSON.toJSONString(map);
}