摘要：自定義注解實現(xiàn)基于接口限流仔細(xì)看會發(fā)現(xiàn)上面的簡單實現(xiàn)會造成我每個接口都要寫一次限流方法代碼很冗余所以采用來使用自定義注解來實現(xiàn)。

令牌桶限流算法

圖片來自網(wǎng)上

令牌桶會以一個恒定的速率向固定容量大小桶中放入令牌，當(dāng)有瀏覽來時取走一個或者多個令牌,當(dāng)發(fā)生高并發(fā)情況下拿到令牌的執(zhí)行業(yè)務(wù)邏輯,沒有獲取到令牌的就會丟棄獲取服務(wù)降級處理,提示一個友好的錯誤信息給用戶。

2. RateLimiter簡單實現(xiàn)
maven依賴

        
        
            com.google.guava
            guava
            18.0
        

本人使用的是SpringBoot 2.0.4.RELEASE,Jdk1.8環(huán)境下編寫,部分代碼貼出:

   /**
     * 以1r/s往桶中放入令牌
     */
    private RateLimiter limiter = RateLimiter.create(1.0);

    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @GetMapping("/indexLimiter")
    public String indexLimiter() {
        // 如果用戶在500毫秒內(nèi)沒有獲取到令牌,就直接放棄獲取進行服務(wù)降級處理
        boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
        if (!tryAcquire) {
            log.info("Error ---時間:{},獲取令牌失敗.", sdf.format(new Date()));
            return "系統(tǒng)繁忙,請稍后再試.";
        }
        log.info("Success ---時間:{},獲取令牌成功.", sdf.format(new Date()));
        return "success";
    }

調(diào)用結(jié)果如下:

使用RateLimiter注意的地方:

允許先消費，后付款，意思就是它可以來一個請求的時候一次性取走幾個或者是剩下所有的令牌甚至多取，但是后面的請求就得為上一次請求買單，它需要等待桶中的令牌補齊之后才能繼續(xù)獲取令牌。

3.自定義注解實現(xiàn)基于接口限流

仔細(xì)看會發(fā)現(xiàn)上面的簡單實現(xiàn)會造成我每個接口都要寫一次限流方法代碼很冗余,所以采用aop來使用自定義注解來實現(xiàn)。

maven依賴

        
        
            org.springframework.boot
            spring-boot-starter-aop
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            com.google.guava
            guava
            18.0
        
        
        
            org.projectlombok
            lombok
            true
        

首先定義一個自定義注解:

package com.limiting.annotation;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface AnRateLimiter {

    //以固定數(shù)值往令牌桶添加令牌
    double permitsPerSecond () ;

    //獲取令牌最大等待時間
    long timeout();

    // 單位(例:分鐘/秒/毫秒) 默認(rèn):毫秒
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;

    // 無法獲取令牌返回提示信息 默認(rèn)值可以自行修改
    String msg() default "系統(tǒng)繁忙,請稍后再試.";
}

然后使用aop的環(huán)繞通知來攔截注解,使用了一個ConcurrentMap來保存每個請求對應(yīng)的令牌桶,key是沒有url請求,防止出現(xiàn)每個請求都會新建一個令牌桶這么會達不到限流效果.

package com.limiting.aspect;

import com.google.common.collect.Maps;
import com.google.common.util.concurrent.RateLimiter;
import com.limiting.annotation.AnRateLimiter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
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.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;

/**
 * 　* 描述:
 *
 * @author 只寫B(tài)UG的攻城獅
 * 　* @date 2018-09-12 12:07
 */
@Slf4j
@Aspect
@Component
public class RateLimiterAspect {
    /**
     * 使用url做為key,存放令牌桶 防止每次重新創(chuàng)建令牌桶
     */
    private Map limitMap = Maps.newConcurrentMap();
    
    @Pointcut("@annotation(com.limiting.annotation.AnRateLimiter)")
    public void anRateLimiter() {
    }

    @Around("anRateLimiter()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取request,response
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        // 或者url(存在map集合的key)
        String url = request.getRequestURI();
        // 獲取自定義注解
        AnRateLimiter rateLimiter = getAnRateLimiter(joinPoint);
        if (rateLimiter != null) {
            RateLimiter limiter = null;
            // 判斷map集合中是否有創(chuàng)建有創(chuàng)建好的令牌桶
            if (!limitMap.containsKey(url)) {
                // 創(chuàng)建令牌桶
                limiter = RateLimiter.create(rateLimiter.permitsPerSecond());
                limitMap.put(url, limiter);
                log.info("<<=================  請求{},創(chuàng)建令牌桶,容量{} 成功!!!", url, rateLimiter.permitsPerSecond());
            }
            limiter = limitMap.get(url);
            // 獲取令牌
            boolean acquire = limiter.tryAcquire(rateLimiter.timeout(), rateLimiter.timeunit());

            if (!acquire) {
                responseResult(response, 500, rateLimiter.msg());
                return null;
            }
        }
        return joinPoint.proceed();
    }

    /**
     * 獲取注解對象
     * @param joinPoint 對象
     * @return ten LogAnnotation
     */
    private AnRateLimiter getAnRateLimiter(final JoinPoint joinPoint) {
        Method[] methods = joinPoint.getTarget().getClass().getDeclaredMethods();
        String name = joinPoint.getSignature().getName();
        if (!StringUtils.isEmpty(name)) {
            for (Method method : methods) {
                AnRateLimiter annotation = method.getAnnotation(AnRateLimiter.class);
                if (!Objects.isNull(annotation) && name.equals(method.getName())) {
                    return annotation;
                }
            }
        }
        return null;
    }

    /**
     * 自定義響應(yīng)結(jié)果
     *
     * @param response 響應(yīng)
     * @param code     響應(yīng)碼
     * @param message  響應(yīng)信息
     */
    private void responseResult(HttpServletResponse response, Integer code, String message) {
        response.resetBuffer();
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setContentType("application/json");
        response.setCharacterEncoding("UTF-8");
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
            writer.println("{"code":" + code + " ,"message" :"" + message + ""}");
            response.flushBuffer();
        } catch (IOException e) {
            log.error(" 輸入響應(yīng)出錯 e = {}", e.getMessage(), e);
        } finally {
            if (writer != null) {
                writer.flush();
                writer.close();
            }
        }
    }
}

最后來試試自己定義的注解是否生效,能否達到限流效果.

    @GetMapping("/index")
    @AnRateLimiter(permitsPerSecond = 1, timeout = 500, timeunit = TimeUnit.MILLISECONDS,msg = "親,現(xiàn)在流量過大,請稍后再試.")
    public String index() {
        return System.currentTimeMillis() + "";
    }

訪問請求(按F5狂刷新瀏覽器)效果如下圖:

總結(jié)
至此已基本上使用注解實現(xiàn)了接口限流,后期可以根據(jù)自己需求自行修改,這個只適于單個應(yīng)用進行接口限流,如果是分布式項目或者微服務(wù)項目可以采用redis來實現(xiàn),后期有時間來一個基于redis自定義注解來實現(xiàn)接口限流。
本人也是剛?cè)隞ava開發(fā)行業(yè)沒多久的小菜鳥,在文章中可能存在一些說的不對,代碼不嚴(yán)謹(jǐn)?shù)牡胤綒g迎各位大神指出,本人表示由衷的感謝和耐心的學(xué)習(xí),希望能在開發(fā)中給大家一些幫助。

參考
https://crossoverjie.top/2017...