/**
 * 固定窗口時(shí)間算法
 * @return
*/
public class Counter {
  public long timeStamp = System.currentTimeMillis(); // 當(dāng)前時(shí)間
  public int reqCount = 0; // 初始化計(jì)數(shù)器
  public final int limit = 1000; // 時(shí)間窗口內(nèi)最大請求數(shù)
  public final long interval = 1000 * 60; // 時(shí)間窗口ms
?
  public boolean limit() {
    long now = System.currentTimeMillis();
    if (now < timeStamp + interval) {
      // 在時(shí)間窗口內(nèi)
      reqCount++;
      // 判斷當(dāng)前時(shí)間窗口內(nèi)是否超過最大請求控制數(shù)
      return reqCount <= limit;
    } else {
      timeStamp = now;
      // 超時(shí)后重置
      reqCount = 1;
      return true;
    }
  }
}

 /**
     * 單位時(shí)間劃分的小周期（單位時(shí)間是1分鐘，10s一個(gè)小格子窗口，一共6個(gè)格子）
     */
    private int SUB_CYCLE = 10;
    /**
     * 每分鐘限流請求數(shù)
     */
    private int thresholdPerMin = 100;
    /**
     * 計(jì)數(shù)器, k-為當(dāng)前窗口的開始時(shí)間值秒，value為當(dāng)前窗口的計(jì)數(shù)
     */
    private final TreeMap<Long, Integer> counters = new TreeMap<>();
   /**
     * 滑動窗口時(shí)間算法實(shí)現(xiàn)
     */
    boolean slidingWindowsTryAcquire() {
        long currentWindowTime = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC) / SUB_CYCLE * SUB_CYCLE; //獲取當(dāng)前時(shí)間在哪個(gè)小周期窗口
        int currentWindowNum = countCurrentWindow(currentWindowTime); //當(dāng)前窗口總請求數(shù)
        //超過閥值限流
        if (currentWindowNum >= thresholdPerMin) {
            return false;
        }
        //計(jì)數(shù)器+1
        counters.get(currentWindowTime)++;
        return true;
    }
   /**
    * 統(tǒng)計(jì)當(dāng)前窗口的請求數(shù)
    */
    private int countCurrentWindow(long currentWindowTime) {
        //計(jì)算窗口開始位置
        long startTime = currentWindowTime - SUB_CYCLE* (60s/SUB_CYCLE-1);
        int count = 0;
        //遍歷存儲的計(jì)數(shù)器
        Iterator<Map.Entry<Long, Integer>> iterator = counters.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Long, Integer> entry = iterator.next();
            // 刪除無效過期的子窗口計(jì)數(shù)器
            if (entry.getKey() < startTime) {
                iterator.remove();
            } else {
                //累加當(dāng)前窗口的所有計(jì)數(shù)器之和
                count =count + entry.getValue();
            }
        }
        return count;
    }

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

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/9/1 10:38
 */
@Slf4j
@RestController
@RequestMapping("/test")
@ResponseResultBody
public class TestController {
    /**
     * 限流策略 ：1秒鐘2個(gè)請求
     */
    private final RateLimiter limiter = RateLimiter.create(2.0);
    private DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    @GetMapping("/rateLimit")
    public String testLimiter() {
        //500毫秒內(nèi)，沒拿到令牌，就直接進(jìn)入服務(wù)降級
        boolean tryAcquire = limiter.tryAcquire(50, TimeUnit.MILLISECONDS);
        if (!tryAcquire) {
            log.warn("進(jìn)入服務(wù)降級，時(shí)間{}", LocalDateTime.now().format(dtf));
            return "當(dāng)前排隊(duì)人數(shù)較多，請稍后再試！";
        }
?
        log.info("獲取令牌成功，時(shí)間{}", LocalDateTime.now().format(dtf));
        return "請求成功";
    }
?
}

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/10/25 00:06
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Documented
public @interface RateLimit {
    /**
     * 資源的key,唯一
     * 作用：不同的接口，不同的流量控制
     */
    String key() default "";
?
    /**
     * 最多的訪問限制次數(shù)
     */
    double permitsPerSecond () ;
?
    /**
     * 獲取令牌最大等待時(shí)間
     */
    long timeout();
?
    /**
     * 獲取令牌最大等待時(shí)間,單位(例:分鐘/秒/毫秒) 默認(rèn):毫秒
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;
?
    /**
     * 得不到令牌的提示語
     */
    String msg() default "系統(tǒng)繁忙,請稍后再試.";
?
}

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/10/25 00:10
 */
@Slf4j
@Component
@Aspect
public class RateLimitAop {
    /**
     * 不同的接口，不同的流量控制
     * map的key為 Limiter.key
     */
    private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
?
    @Around("@annotation(com.shepherd.mall.seckill.annotation.RateLimit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        //拿limit的注解
        RateLimit limit = method.getAnnotation(RateLimit.class);
        if (limit != null) {
            //key作用：不同的接口，不同的流量控制
            String key=limit.key();
            RateLimiter rateLimiter = null;
            //驗(yàn)證緩存是否有命中key
            if (!limitMap.containsKey(key)) {
                // 創(chuàng)建令牌桶
                rateLimiter = RateLimiter.create(limit.permitsPerSecond());
                limitMap.put(key, rateLimiter);
                log.info("新建了令牌桶={}，容量={}",key,limit.permitsPerSecond());
            }
            rateLimiter = limitMap.get(key);
            // 拿令牌
            boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
            // 拿不到命令，直接返回異常提示
            if (!acquire) {
                log.debug("令牌桶={}，獲取令牌失敗",key);
                this.responseFail(limit.msg());
                return null;
            }
        }
        return joinPoint.proceed();
    }
?
    /**
     * 直接向前端拋出異常
     * @param msg 提示信息
     */
    private void responseFail(String msg)  {
        HttpServletResponse response=((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        ResponseVO<Object> responseVO = ResponseVO.failure(400, msg);
        WebUtil.writeJson(response, responseVO);
    }
}

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/9/1 10:38
 */
@Slf4j
@RestController
@RequestMapping("/test")
@ResponseResultBody
public class TestController {
    @GetMapping("/limit2")
    @RateLimit(key = "limit2", permitsPerSecond = 1, timeout = 50, timeunit = TimeUnit.MILLISECONDS, msg = "當(dāng)前排隊(duì)人數(shù)較多，請稍后再試！")
    public String limit2() {
        log.info("令牌桶l(fā)imit2獲取令牌成功");
        return "ok";
    }
}

local key = "rate.limit:" .. KEYS[1]
local limit = tonumber(ARGV[1])
local expire_time = ARGV[2]
?
local is_exists = redis.call("EXISTS", key)
if is_exists == 1 then
    if redis.call("INCR", key) > limit then
        return 0
    else
        return 1
    end
else
    redis.call("SET", key, 1)
    redis.call("EXPIRE", key, expire_time)
    return 1
end

local locks = require "resty.lock"
?
local function acquire()
    local lock =locks:new("locks")
    local elapsed, err =lock:lock("limit_key") --互斥鎖 保證原子特性
    local limit_counter =ngx.shared.limit_counter --計(jì)數(shù)器
?
    local key = "ip:" ..os.time()
    local limit = 5 --限流大小
    local current =limit_counter:get(key)
?
    if current ~= nil and current + 1> limit then --如果超出限流大小
       lock:unlock()
       return 0
    end
    if current == nil then
       limit_counter:set(key, 1, 1) --第一次需要設(shè)置過期時(shí)間，設(shè)置key的值為1，
--過期時(shí)間為1秒
    else
        limit_counter:incr(key, 1) --第二次開始加1即可
    end
    lock:unlock()
    return 1
end
ngx.print(acquire())

http {
    include       mime.types;
    default_type  application/octet-stream;
?
    #cache
    lua_shared_dict dis_cache 128m;
?
    #限流設(shè)置
    limit_req_zone $binary_remote_addr zone=contentRateLimit:10m rate=2r/s;
?
    #根據(jù)IP地址來限制，存儲內(nèi)存大小10M
    limit_conn_zone $binary_remote_addr zone=addr:1m;
?
    sendfile        on;
    #tcp_nopush     on;
?
    #keepalive_timeout  0;
    keepalive_timeout  65;
?
    #gzip  on;
?
    server {
        listen       80;
        server_name  localhost;
        location /brand {
            limit_conn addr 2;
            proxy_pass http://192.168.211.1:18081;
        }
?
        location /update_content {
            content_by_lua_file /root/lua/update_content.lua;
        }
?
        location /read_content {
            limit_req zone=contentRateLimit burst=4 nodelay;
            content_by_lua_file /root/lua/read_content.lua;
        }
    }
}

user  root root;
worker_processes  1;
?
events {
    worker_connections  1024;
}
?
http {
    include       mime.types;
    default_type  application/octet-stream;
?
    #cache
    lua_shared_dict dis_cache 128m;
?
    #限流設(shè)置
    limit_req_zone $binary_remote_addr zone=contentRateLimit:10m rate=2r/s;
?
    sendfile        on;
    #tcp_nopush     on;
?
    #keepalive_timeout  0;
    keepalive_timeout  65;
?
    #gzip  on;
?
    server {
        listen       80;
        server_name  localhost;
?
        location /update_content {
            content_by_lua_file /root/lua/update_content.lua;
        }
?
        location /read_content {
            limit_req zone=contentRateLimit burst=4 nodelay;
            content_by_lua_file /root/lua/read_content.lua;
        }
    }
}