springboot + aop + Lua分佈式限流原理解析

時間  2020-04-13
標籤 springboot aop lua 分佈式 限流 原理 解析 欄目 Spring 简体版
原文   原文鏈接

1、什麼是限流？爲何要限流？
不知道你們有沒有作過帝都的地鐵，就是進地鐵站都要排隊的那種，爲何要這樣擺長龍轉圈圈？答案就是爲了 限流 ！由於一趟地鐵的運力是有限的，一下擠進去太多人會形成站臺的擁擠、列車的超載，存在必定的安全隱患。同理，咱們的程序也是同樣，它處理請求的能力也是有限的，一旦請求多到超出它的處理極限就會崩潰。爲了避免出現最壞的崩潰狀況，只能耽誤一下你們進站的時間。
springboot + aop + Lua分佈式限流原理解析web

限流是保證系統高可用的重要手段！！！面試

因爲互聯網公司的流量巨大，系統上線會作一個流量峯值的評估，尤爲是像各類秒殺促銷活動，爲了保證系統不被巨大的流量壓垮，會在系統流量到達必定閾值時，拒絕掉一部分流量。redis

限流會致使用戶在短期內（這個時間段是毫秒級的）系統不可用，通常咱們衡量系統處理能力的指標是每秒的 QPS 或者 TPS ，假設系統每秒的流量閾值是1000，理論上一秒內有第1001個請求進來時，那麼這個請求就會被限流。算法

2、限流方案
一、計數器
Java內部也能夠經過原子類計數器 AtomicInteger 、 Semaphore 信號量來作簡單的限流。spring

// 限流的個數
        private int maxCount = 10;
        // 指定的時間內
        private long interval = 60;
        // 原子類計數器
        private AtomicInteger atomicInteger = new AtomicInteger(0);
        // 起始時間
        private long startTime = System.currentTimeMillis();

        public boolean limit(int maxCount, int interval) {
                atomicInteger.addAndGet(1);
                if (atomicInteger.get() == 1) {
                        startTime = System.currentTimeMillis();
                        atomicInteger.addAndGet(1);
                        return true;
                }
                // 超過了間隔時間，直接從新開始計數
                if (System.currentTimeMillis() - startTime > interval * 1000) {
                        startTime = System.currentTimeMillis();
                        atomicInteger.set(1);
                        return true;
                }
                // 還在間隔時間內,check有沒有超過限流的個數
                if (atomicInteger.get() > maxCount) {
                        return false;
                }
                return true;
        }

二、漏桶算法
漏桶算法思路很簡單，咱們把水比做是 請求 ，漏桶比做是 系統處理能力極限 ，水先進入到漏桶裏，漏桶裏的水按必定速率流出，當流出的速率小於流入的速率時，因爲漏桶容量有限，後續進入的水直接溢出（拒絕請求），以此實現限流。
springboot + aop + Lua分佈式限流原理解析數據庫

三、令牌桶算法
令牌桶算法的原理也比較簡單，咱們能夠理解成醫院的掛號看病，只有拿到號之後才能夠進行診病。
系統會維護一個令牌（ token ）桶，以一個恆定的速度往桶裏放入令牌（ token ），這時若是有請求進來想要被處理，則須要先從桶裏獲取一個令牌（ token ），當桶裏沒有令牌（ token ）可取時，則該請求將被拒絕服務。令牌桶算法經過控制桶的容量、發放令牌的速率，來達到對請求的限制。
springboot + aop + Lua分佈式限流原理解析apache

四、Redis + Lua
不少同窗不知道 Lua 是啥？我的理解， Lua 腳本和 MySQL 數據庫的存儲過程比較類似，他們執行一組命令，全部命令的執行要麼所有成功或者失敗，以此達到原子性。也能夠把 Lua 腳本理解爲，一段具備業務邏輯的代碼塊。編程

而 Lua 自己就是一種編程語言，雖然 redis 官方沒有直接提供限流相應的 API ，但卻支持了 Lua 腳本的功能，可使用它實現複雜的令牌桶或漏桶算法，也是分佈式系統中實現限流的主要方式之一。api

相比 Redis 事務， Lua腳本 的優勢：瀏覽器

減小網絡開銷： 使用 Lua 腳本，無需向 Redis 發送屢次請求，執行一次便可，減小網絡傳輸
原子操做： Redis 將整個 Lua 腳本做爲一個命令執行，原子，無需擔憂併發
複用： Lua 腳本一旦執行，會永久保存 Redis 中,，其餘客戶端可複用
Lua 腳本大體邏輯以下：

-- 獲取調用腳本時傳入的第一個key值（用做限流的 key）
local key = KEYS[1]
-- 獲取調用腳本時傳入的第一個參數值（限流大小）
local limit = tonumber(ARGV[1])

-- 獲取當前流量大小
local curentLimit = tonumber(redis.call('get', key) or "0")

-- 是否超出限流
    if curentLimit + 1 > limit then
            -- 返回(拒絕)
            return 0
    else
            -- 沒有超出 value + 1
            redis.call("INCRBY", key, 1)
            -- 設置過時時間
            redis.call("EXPIRE", key, 2)
            -- 返回(放行)
            return 1
    end

經過 KEYS[1] 獲取傳入的key參數
經過 ARGV[1] 獲取傳入的 limit 參數
redis.call 方法，從緩存中 get 和 key 相關的值，若是爲 null 那麼就返回0
接着判斷緩存中記錄的數值是否會大於限制大小，若是超出表示該被限流，返回0
若是未超過，那麼該key的緩存值+1，並設置過時時間爲1秒鐘之後，並返回緩存值+1
這種方式是本文推薦的方案，具體實現會在後邊作細說。

五、網關層限流
限流常在網關這一層作，好比 Nginx 、 Openresty 、 kong 、 zuul 、 Spring Cloud Gateway 等，而像 spring cloud - gateway 網關限流底層實現原理，就是基於 Redis + Lua ，經過內置 Lua 限流腳本的方式。
springboot + aop + Lua分佈式限流原理解析

3、Redis + Lua 限流實現
下面咱們經過 自定義註解 、 aop 、 Redis + Lua 實現限流，步驟會比較詳細，爲了小白能讓快速上手這裏囉嗦一點，有經驗的老鳥們多擔待一下。

一、環境準備
springboot 項目建立地址： https://start.spring.io ，很方便實用的一個工具。

springboot + aop + Lua分佈式限流原理解析
二、引入依賴包
pom文件中添加以下依賴包，比較關鍵的就是 spring-boot-starter-data-redis 和 spring-boot-starter-aop 。

<dependencies>
                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-data-redis</artifactId>
                </dependency>
                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-aop</artifactId>
                </dependency>
                <dependency>
                        <groupId>com.google.guava</groupId>
                        <artifactId>guava</artifactId>
                        <version>21.0</version>
                </dependency>
                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-test</artifactId>
                </dependency>
                <dependency>
                        <groupId>org.apache.commons</groupId>
                        <artifactId>commons-lang3</artifactId>
                </dependency>

                <dependency>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-starter-test</artifactId>
                        <scope>test</scope>
                        <exclusions>
                                <exclusion>
                                        <groupId>org.junit.vintage</groupId>
                                        <artifactId>junit-vintage-engine</artifactId>
                                </exclusion>
                        </exclusions>
                </dependency>
        </dependencies>

三、配置application.properties
在 application.properties 文件中配置提早搭建好的 redis 服務地址和端口。

spring.redis.host=127.0.0.1

spring.redis.port=6379
四、配置RedisTemplate實例
@Configuration
public class RedisLimiterHelper {

@Bean
public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Serializable> template = new RedisTemplate<>();
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

}
限流類型枚舉類

/**
 * @author fu
 * @description 限流類型
 * @date 2020/4/8 13:47
 */
public enum LimitType {

        /**
         * 自定義key
         */
        CUSTOMER,

        /**
         * 請求者IP
         */
        IP;
}

五、自定義註解
咱們自定義個 @Limit 註解，註解類型爲 ElementType.METHOD 即做用於方法上。

period 表示請求限制時間段， count 表示在 period 這個時間段內容許放行請求的次數。 limitType 表明限流的類型，能夠根據 請求的IP 、 自定義key ，若是不傳 limitType 屬性則默認用方法名做爲默認key。

/**
 * @author fu
 * @description 自定義限流注解
 * @date 2020/4/8 13:15
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Limit {

/**
 * 名字
 */
String name() default "";

/**
 * key
 */
String key() default "";

/**
 * Key的前綴
 */
String prefix() default "";

/**
 * 給定的時間範圍 單位(秒)
 */
int period();

/**
 * 必定時間內最多訪問次數
 */
int count();

/**
 * 限流的類型(用戶自定義key 或者 請求ip)
 */
LimitType limitType() default LimitType.CUSTOMER;
}

六、切面代碼實現
/**

  • @author fu
  • @description 限流切面實現

  • @date 2020/4/8 13:04br/>*/
    @Aspect
    @Configuration
    public class LimitInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(LimitInterceptor.class);

    private static final String UNKNOWN = "unknown";

    private final RedisTemplate<String, Serializable> limitRedisTemplate;

    @Autowired
    public LimitInterceptor(RedisTemplate<String, Serializable> limitRedisTemplate) {
    this.limitRedisTemplate = limitRedisTemplate;
    }

    /**
     * @param pjp
     * @author fu
     * @description 切面
     * @date 2020/4/8 13:04
     */
    @Around("execution(public * *(..)) && @annotation(com.xiaofu.limit.api.Limit)")
    public Object interceptor(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
Limit limitAnnotation = method.getAnnotation(Limit.class);
LimitType limitType = limitAnnotation.limitType();
String name = limitAnnotation.name();
String key;
int limitPeriod = limitAnnotation.period();
int limitCount = limitAnnotation.count();

/**
 * 根據限流類型獲取不一樣的key ,若是不傳咱們會以方法名做爲key
 */
switch (limitType) {
    case IP:
        key = getIpAddress();
        break;
    case CUSTOMER:
        key = limitAnnotation.key();
        break;
    default:
        key = StringUtils.upperCase(method.getName());
}

ImmutableList<String> keys = ImmutableList.of(StringUtils.join(limitAnnotation.prefix(), key));
try {
    String luaScript = buildLuaScript();
    RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
    Number count = limitRedisTemplate.execute(redisScript, keys, limitCount, limitPeriod);
    logger.info("Access try count is {} for name={} and key = {}", count, name, key);
    if (count != null && count.intValue() <= limitCount) {
        return pjp.proceed();
    } else {
        throw new RuntimeException("You have been dragged into the blacklist");
    }
} catch (Throwable e) {
    if (e instanceof RuntimeException) {
        throw new RuntimeException(e.getLocalizedMessage());
    }
    throw new RuntimeException("server exception");
            }

    }
    /**

    • @author fu
    • @description 編寫 redis Lua 限流腳本
    • @date 2020/4/8 13:24
      */
      public String buildLuaScript() {
      StringBuilder lua = new StringBuilder();
      lua.append("local c");
      lua.append("\nc = redis.call('get',KEYS[1])");
      // 調用不超過最大值，則直接返回
      lua.append("\nif c and tonumber(c) > tonumber(ARGV[1]) then");
      lua.append("\nreturn c;");
      lua.append("\nend");
      // 執行計算器自加
      lua.append("\nc = redis.call('incr',KEYS[1])");
      lua.append("\nif tonumber(c) == 1 then");
      // 從第一次調用開始限流，設置對應鍵值的過時
      lua.append("\nredis.call('expire',KEYS[1],ARGV[2])");
      lua.append("\nend");
      lua.append("\nreturn c;");
      return lua.toString();
      }

    /**

    • @author fu
    • @description 獲取id地址

    • @date 2020/4/8 13:24
      */
      public String getIpAddress() {
      HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
      String ip = request.getHeader("x-forwarded-for");
      if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
      ip = request.getHeader("Proxy-Client-IP");
      }
      if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
      ip = request.getHeader("WL-Proxy-Client-IP");
      }
      if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
      ip = request.getRemoteAddr();
      }
      return ip;
      }
      }
      七、控制層實現
      咱們將 @Limit 註解做用在須要進行限流的接口方法上，下邊咱們給方法設置 @Limit 註解，在 10秒 內只容許放行 3個 請求，這裏爲直觀一點用 AtomicInteger 計數。

      /**

    • @Author: fu
    • @Description:br/>*/
      @RestController
      public class LimiterController {

    private static final AtomicInteger ATOMIC_INTEGER_1 = new AtomicInteger();
    private static final AtomicInteger ATOMIC_INTEGER_2 = new AtomicInteger();
    private static final AtomicInteger ATOMIC_INTEGER_3 = new AtomicInteger();

    /**

    • @author fu
    • @description

    • @date 2020/4/8 13:42
      */
      @Limit(key = "limitTest", period = 10, count = 3)br/>@GetMapping("/limitTest1")
      public int testLimiter1() {

      return ATOMIC_INTEGER_1.incrementAndGet();
      }

    /**

    • @author fu
    • @description

    • @date 2020/4/8 13:42
      */
      @Limit(key = "customer_limit_test", period = 10, count = 3, limitType = LimitType.CUSTOMER)br/>@GetMapping("/limitTest2")
      public int testLimiter2() {

      return ATOMIC_INTEGER_2.incrementAndGet();
      }

    /**

    • @author fu
    • @description

    • @date 2020/4/8 13:42
      */
      @Limit(key = "ip_limit_test", period = 10, count = 3, limitType = LimitType.IP)br/>@GetMapping("/limitTest3")
      public int testLimiter3() {

      return ATOMIC_INTEGER_3.incrementAndGet();
      }

}
八、測試
測試 預期 ：連續請求3次都可以成功，第4次請求被拒絕。接下來看一下是否是咱們預期的效果，請求地址： http://127.0.0.1:8080/limitTest1 ，用 postman 進行測試，有沒有 postman url直接貼瀏覽器也是同樣。
springboot + aop + Lua分佈式限流原理解析

能夠看到第四次請求時，應用直接拒絕了請求，說明咱們的 Springboot + aop + lua 限流方案搭建成功。

springboot + aop + Lua分佈式限流原理解析總結以上 springboot + aop + Lua 限流實現是比較簡單的，旨在讓你們認識下什麼是限流？如何作一個簡單的限流功能，面試要知道這是個什麼東西。上面雖說了幾種實現限流的方案，但選哪一種還要結合具體的業務場景，不能爲了用而用。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程