Springboot中怎么實現分布式限流

這期內容當中小編將會給大家帶來有關Springboot中怎么實現分布式限流，文章內容豐富且以專業的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

限流算法介紹

a、令牌桶算法

令牌桶算法的原理是系統會以一個恒定的速度往桶里放入令牌，而如果請求需要被處理，則需要先從桶里獲取一個令牌，當桶里沒有令牌可取時，則拒絕服務。 當桶滿時，新添加的令牌被丟棄或拒絕。

b、漏桶算法

其主要目的是控制數據注入到網絡的速率，平滑網絡上的突發流量，數據可以以任意速度流入到漏桶中。漏桶算法提供了一種機制，通過它，突發流量可以被整形以便為網絡提供一個穩定的流量。 漏桶可以看作是一個帶有常量服務時間的單服務器隊列，如果漏桶為空，則不需要流出水滴，如果漏桶（包緩存）溢出，那么水滴會被溢出丟棄

c、計算器限流

計數器限流算法是比較常用一種的限流方案也是最為粗暴直接的，主要用來限制總并發數，比如數據庫連接池大小、線程池大小、接口訪問并發數等都是使用計數器算法

如：使用AomicInteger來進行統計當前正在并發執行的次數，如果超過域值就直接拒絕請求，提示系統繁忙

限流具體代碼實踐

a、導入依賴

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
  </dependency>
  <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>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>21.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
  </dependency>
</dependencies>

b、屬性配置

在application.properites資源文件中添加redis相關的配置項

spring.redis.host=192.168.68.110
spring.redis.port=6379
spring.redis.password=123456

默認情況下spring-boot-data-redis為我們提供了StringRedisTemplate但是滿足不了其它類型的轉換，所以還是得自己去定義其它類型的模板

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;

/**
 * redis配置
 */
@Configuration
public class RedisConfig {

  @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;
  }
}

d、Limit 注解

具體代碼如下

import com.carry.enums.LimitType;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 限流
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Limit {

  /**
   * 資源的名字
   *
   * @return String
   */
  String name() default "";

  /**
   * 資源的key
   *
   * @return String
   */
  String key() default "";

  /**
   * Key的prefix
   *
   * @return String
   */
  String prefix() default "";

  /**
   * 給定的時間段
   * 單位秒
   *
   * @return int
   */
  int period();

  /**
   * 最多的訪問限制次數
   *
   * @return int
   */
  int count();

  /**
   * 類型
   *
   * @return LimitType
   */
  LimitType limitType() default LimitType.CUSTOMER;
}

package com.carry.enums;

public enum LimitType {
  /**
   * 自定義key
   */
  CUSTOMER,
  /**
   * 根據請求者IP
   */
  IP;
}

e、Limit 攔截器（AOP）

我們可以通過編寫 Lua 腳本實現自己的API，核心就是調用execute方法傳入我們的 Lua 腳本內容，然后通過返回值判斷是否超出我們預期的范圍，超出則給出錯誤提示。

import com.carry.annotation.Limit;
import com.carry.enums.LimitType;
import com.google.common.collect.ImmutableList;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
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.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.io.Serializable;
import java.lang.reflect.Method;


@Aspect
@Configuration
public class LimitInterceptor {

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

  private final RedisTemplate<String, Serializable> limitRedisTemplate;

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


  @Around("execution(public * *(..)) && @annotation(com.carry.annotation.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();
    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");
    }
  }

  /**
   * 限流 腳本
   *
   * @return lua腳本
   */
  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();
  }

  private static final String UNKNOWN = "unknown";

  /**
   * 獲取IP地址
   * @return
   */
  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;
  }
}

f、控制層

在接口上添加@Limit()注解，如下代碼會在 Redis 中生成過期時間為 100s 的 key = test 的記錄，特意定義了一個AtomicInteger用作測試

import com.carry.annotation.Limit;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.atomic.AtomicInteger;


@RestController
public class LimiterController {

  private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger();

  @Limit(key = "test", period = 100, count = 10, name="resource", prefix = "limit")
  @GetMapping("/test")
  public int testLimiter() {
    // 意味著100S內最多可以訪問10次
    return ATOMIC_INTEGER.incrementAndGet();
  }
}

注意：上面例子保存在redis中的key值應該為“limittest”，即@Limit中prefix的值+key的值

測試

我們在postman中快速訪問localhost:8080/test，當訪問數超過10時出現以下結果

上述就是小編為大家分享的Springboot中怎么實現分布式限流了，如果剛好有類似的疑惑，不妨參照上述分析進行理解。如果想知道更多相關知識，歡迎關注億速云行業資訊頻道。