欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

详解Springboot分布式限流实践

程序员文章站 2024-02-20 17:26:28
高并发访问时,缓存、限流、降级往往是系统的利剑,在互联网蓬勃发展的时期,经常会面临因用户暴涨导致的请求不可用的情况,甚至引发连锁反映导致整个系统崩溃。这个时候常见的解决方案...

高并发访问时,缓存、限流、降级往往是系统的利剑,在互联网蓬勃发展的时期,经常会面临因用户暴涨导致的请求不可用的情况,甚至引发连锁反映导致整个系统崩溃。这个时候常见的解决方案之一就是限流了,当请求达到一定的并发数或速率,就进行等待、排队、降级、拒绝服务等...

限流算法介绍

a、令牌桶算法

令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌,而如果请求需要被处理,则需要先从桶里获取一个令牌,当桶里没有令牌可取时,则拒绝服务。 当桶满时,新添加的令牌被丢弃或拒绝。

详解Springboot分布式限流实践

b、漏桶算法

其主要目的是控制数据注入到网络的速率,平滑网络上的突发流量,数据可以以任意速度流入到漏桶中。漏桶算法提供了一种机制,通过它,突发流量可以被整形以便为网络提供一个稳定的流量。 漏桶可以看作是一个带有常量服务时间的单服务器队列,如果漏桶为空,则不需要流出水滴,如果漏桶(包缓存)溢出,那么水滴会被溢出丢弃

详解Springboot分布式限流实践

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分布式限流实践

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。