SpringBoot接口 - 如何实现接口限流之单实例
Posted 明平姚博客
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot接口 - 如何实现接口限流之单实例相关的知识，希望对你有一定的参考价值。
在以SpringBoot开发Restful接口时，当流量超过服务极限能力时，系统可能会出现卡死、崩溃的情况，所以就有了降级和限流。在接口层如何做限流呢？ 本文主要回顾限流的知识点，并实践单实例限流的一种思路。
# 准备知识点
主要的知识点，请参考架构之高并发：限流, 这里小结下。
# 为什么要限流
每个系统都有服务的上线，所以当流量超过服务极限能力时，系统可能会出现卡死、崩溃的情况，所以就有了降级和限流。限流其实就是：当高并发或者瞬时高并发时，为了保证系统的稳定性、可用性，系统以牺牲部分请求为代价或者延迟处理请求为代价，保证系统整体服务可用。
# 限流有哪些常见思路？
- 从算法上看
令牌桶(Token Bucket)、漏桶(leaky bucket)和计数器算法是最常用的三种限流的算法。
- 单实例
应用级限流方式只是单应用内的请求限流，不能进行全局限流。
- 限流总资源数
- 限流总并发/连接/请求数
- 限流某个接口的总并发/请求数
- 限流某个接口的时间窗请求数
- 平滑限流某个接口的请求数
- Guava RateLimiter
- 分布式
我们需要分布式限流和接入层限流来进行全局限流。
- redis+lua实现中的lua脚本
- 使用nginx+Lua实现的Lua脚本
- 使用 OpenResty 开源的限流方案
- 限流框架，比如Sentinel实现降级限流熔断
# 实现思路
主要思路：AOP拦截自定义的RateLimit注解，在AOP中通过Guava RateLimiter; Guava RateLimiter提供了令牌桶算法实现：平滑突发限流(SmoothBursty)和平滑预热限流(SmoothWarmingUp)实现。
# 定义RateLimit注解
package tech.pdai.ratelimit.guava.config.ratelimit;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author pdai
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit
int limit() default 10;
# 定义AOP
package tech.pdai.ratelimit.guava.config.ratelimit;
import java.lang.reflect.Method;
import java.util.concurrent.ConcurrentHashMap;
import com.google.common.util.concurrent.RateLimiter;
import lombok.extern.slf4j.Slf4j;
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.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
/**
* @author pdai
*/
@Slf4j
@Aspect
@Component
public class RateLimitAspect
private final ConcurrentHashMap<String, RateLimiter> EXISTED_RATE_LIMITERS = new ConcurrentHashMap<>();
@Pointcut("@annotation(tech.pdai.ratelimit.guava.config.ratelimit.RateLimit)")
public void rateLimit()
@Around("rateLimit()")
public Object around(ProceedingJoinPoint point) throws Throwable
MethodSignature signature = (MethodSignature) point.getSignature();
Method method = signature.getMethod();
RateLimit annotation = AnnotationUtils.findAnnotation(method, RateLimit.class);
// get rate limiter
RateLimiter rateLimiter = EXISTED_RATE_LIMITERS.computeIfAbsent(method.getName(), k -> RateLimiter.create(annotation.limit()));
// process
if (rateLimiter!=null && rateLimiter.tryAcquire())
return point.proceed();
else
throw new RuntimeException("too many requests, please try again later...");
# 自定义相关异常
package tech.pdai.ratelimit.guava.config.exception;
import lombok.extern.slf4j.Slf4j;
/**
* business exception, besides normal exception.
*
* @author pdai
*/
@Slf4j
public class BusinessException extends RuntimeException
/**
* Constructs a new exception with @code null as its detail message. The cause is not initialized, and may
* subsequently be initialized by a call to @link #initCause.
*/
public BusinessException()
super();
/**
* Constructs a new exception with the specified detail message. The cause is not initialized, and may subsequently
* be initialized by a call to @link #initCause.
*
* @param message the detail message. The detail message is saved for later retrieval by the @link #getMessage()
* method.
*/
public BusinessException(final String message)
super(message);
/**
* Constructs a new exception with the specified detail message and cause.
* <p>
* Note that the detail message associated with @code cause is <i>not</i> automatically incorporated in this
* exception's detail message.
*
* @param message the detail message (which is saved for later retrieval by the @link #getMessage() method).
* @param cause the cause (which is saved for later retrieval by the @link #getCause() method). (A <tt>null</tt>
* value is permitted, and indicates that the cause is nonexistent or unknown.)
* @since 1.4
*/
public BusinessException(final String message, final Throwable cause)
super(message, cause);
/**
* Constructs a new exception with the specified cause and a detail message of
* <tt>(cause==null ? null : cause.toString())</tt> (which typically contains the class and detail message of
* <tt>cause</tt>). This constructor is useful for exceptions that are little more than wrappers for other
* throwables (for example, @link java.security.PrivilegedActionException).
*
* @param cause the cause (which is saved for later retrieval by the @link #getCause() method). (A <tt>null</tt>
* value is permitted, and indicates that the cause is nonexistent or unknown.)
* @since 1.4
*/
public BusinessException(final Throwable cause)
super(cause);
/**
* Constructs a new exception with the specified detail message, cause, suppression enabled or disabled, and
* writable stack trace enabled or disabled.
*
* @param message the detail message.
* @param cause the cause. (A @code null value is permitted, and indicates that the cause is nonexistent or
* unknown.)
* @param enableSuppression whether or not suppression is enabled or disabled
* @param writableStackTrace whether or not the stack trace should be writable
* @since 1.7
*/
protected BusinessException(final String message, final Throwable cause, boolean enableSuppression,
boolean writableStackTrace)
super(message, cause, enableSuppression, writableStackTrace);
异常的处理
package tech.pdai.ratelimit.guava.config.exception;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import tech.pdai.ratelimit.guava.config.response.ResponseResult;
import tech.pdai.ratelimit.guava.config.response.ResponseStatus;
/**
* @author pdai
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler
/**
* handle business exception.
*
* @param businessException business exception
* @return ResponseResult
*/
@ResponseBody
@ExceptionHandler(BusinessException.class)
public ResponseResult<BusinessException> processBusinessException(BusinessException businessException)
log.error(businessException.getLocalizedMessage());
return ResponseResult.fail(null, businessException.getLocalizedMessage()==null
? ResponseStatus.HTTP_STATUS_500.getDescription()
:businessException.getLocalizedMessage());
/**
* handle other exception.
*
* @param exception exception
* @return ResponseResult
*/
@ResponseBody
@ExceptionHandler(Exception.class)
public ResponseResult<Exception> processException(Exception exception)
log.error(exception.getLocalizedMessage(), exception);
return ResponseResult.fail(null, ResponseStatus.HTTP_STATUS_500.getDescription());
# 统一结果返回封装
package tech.pdai.ratelimit.guava.config.response;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
public class ResponseResult<T>
/**
* response timestamp.
*/
private long timestamp;
/**
* response code, 200 -> OK.
*/
private String status;
/**
* response message.
*/
private String message;
/**
* response data.
*/
private T data;
/**
* response success result wrapper.
*
* @param <T> type of data class
* @return response result
*/
public static <T> ResponseResult<T> success()
return success(null);
/**
* response success result wrapper.
*
* @param data response data
* @param <T> type of data class
* @return response result
*/
public static <T> ResponseResult<T> success(T data)
return ResponseResult.<T>builder().data(data)
.message(ResponseStatus.SUCCESS.getDescription())
.status(ResponseStatus.SUCCESS.getResponseCode())
.timestamp(System.currentTimeMillis())
.build();
/**
* response error result wrapper.
*
* @param message error message
* @param <T> type of data class
* @return response result
*/
public static <T extends Serializable> ResponseResult<T> fail(String message)
return fail(null, message);
/**
* response error result wrapper.
*
* @param data response data
* @param message error message
* @param <T> type of data class
* @return response result
*/
public static <T> ResponseResult<T> fail(T data, String message)
return ResponseResult.<T>builder().data(data)
.message(message)
.status(ResponseStatus.FAIL.getResponseCode())
.timestamp(System.currentTimeMillis())
.build();
# controller接口
package tech.pdai.ratelimit.guava.controller;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import tech.pdai.ratelimit.guava.config.ratelimit.RateLimit;
import tech.pdai.ratelimit.guava.config.response.ResponseResult;
/**
* @author pdai
*/
@Slf4j
@RestController
public class RateLimitTestController
@RateLimit
@GetMapping("/limit")
public ResponseResult<String> limit()
log.info("limit");
return ResponseResult.success();
@RateLimit(limit = 5)
@GetMapping("/limit1")
public ResponseResult<String> limit1()
log.info("limit1");
return ResponseResult.success();
@GetMapping("/nolimit")
public ResponseResult<String> noRateLimiter()
log.info("no limit");
return ResponseResult.success();
# 接口测试
@SneakyThrows
public static void test(int clientSize)
CountDownLatch downLatch = new CountDownLatch(clientSize);
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(clientSize);
IntStream.range(0, clientSize).forEach(i ->
fixedThreadPool.submit(() ->
RestTemplate restTemplate = new RestTemplate();
restTemplate.getForObject("http://localhost:8080/limit1", ResponseResult.class);
downLatch.countDown();
)
);
downLatch.await();
fixedThreadPool.shutdown();
测试结果
2021-10-01 15:22:47.171 INFO 30092 --- [nio-8080-exec-4] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.171 INFO 30092 --- [nio-8080-exec-8] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.171 INFO 30092 --- [nio-8080-exec-5] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.187 INFO 30092 --- [nio-8080-exec-9] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.187 INFO 30092 --- [nio-8080-exec-2] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.187 INFO 30092 --- [io-8080-exec-10] t.p.r.g.c.RateLimitTestController : limit1
2021-10-01 15:22:47.202 ERROR 30092 --- [nio-8080-exec-7] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.202 ERROR 30092 --- [nio-8080-exec-6] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.221 ERROR 30092 --- [nio-8080-exec-1] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.222 ERROR 30092 --- [nio-8080-exec-5] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [nio-8080-exec-6] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [nio-8080-exec-8] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [nio-8080-exec-3] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [io-8080-exec-12] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [io-8080-exec-14] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [io-8080-exec-13] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.225 ERROR 30092 --- [io-8080-exec-15] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.240 ERROR 30092 --- [io-8080-exec-11] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.240 ERROR 30092 --- [nio-8080-exec-4] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
2021-10-01 15:22:47.256 ERROR 30092 --- [nio-8080-exec-2] t.p.r.g.c.e.GlobalExceptionHandler : too many requests, please try again later...
# 上述实现方案的槽点
注意
必须要说明一下，上述实现方式只是单实例下一种思路而已，如果细细的看，上面的代码存在一些槽点。
- 首先,
EXISTED_RATE_LIMITERS.computeIfAbsent(method.getName(), k -> RateLimiter.create(annotation.limit()))这行代码中method.getName()表明是对方法名进行限流的，其实并不合适，应该需要至少加上类名； - 其次, 如果首次运行时访问的请求是一次性涌入的，即EXISTED_RATE_LIMITERS还是空的时候并发请求@RateLimit接口，那么RateLimiter.create(annotation.limit())是会重复创建并加入到EXISTED_RATE_LIMITERS的，这是明显的bug；
- 再者, 上述实现方式按照方法名去限定请求量，对于很多情况下至少需要支持按照IP和方法名，或者其它自定义的方式进行限流。
- 其它一些场景支持的参数抽象和封装等
轻松两步，在 SpringBoot 服务上实现接口限流
重磅资讯、干货，第一时间送达
来源：https://urlify.cn/YjY322
Sentinel是阿里巴巴开源的限流器熔断器，并且带有可视化操作界面。
在日常开发中，限流功能时常被使用，用于对某些接口进行限流熔断，譬如限制单位时间内接口访问次数；或者按照某种规则进行限流，如限制ip的单位时间访问次数等。
之前我们已经讲过接口限流的工具类ratelimter可以实现令牌桶的限流，很明显sentinel的功能更为全面和完善。来看一下sentinel的简介：
https://github.com/spring-cloud-incubator/spring-cloud-alibaba/wiki/Sentinel
Sentinel 介绍
随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
Sentinel 具有以下特征:
-
丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、实时熔断下游不可用应用等。
-
完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
-
广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。
-
完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展点。您可以通过实现扩展点，快速的定制逻辑。例如定制规则管理、适配数据源等。
来简单使用一下Sentinel。
Sentinel包括服务端和客户端，服务端有可视化界面，客户端需引入jar后即可和服务端通信并完成限流功能。
启动服务端的jar
这个jar是个标准的Springboot应用，可以通过
java -jar sentinel-dashboard-1.6.0.jar来启动，这样就是默认的设置，启动在8080端口。也可以加上一些自定义配置来启动
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar。具体配置的解释，可以到GitHub上看一下文档。
这里我们直接使用默认java -jar sentinel-dashboard-1.6.0.jar来启动，之后访问localhost:8080。可以看到界面：
输入账号密码sentinel后进入主界面
此时因为我们并没有启动客户端，所以界面是空的。
启动客户端
新建一个Springboot项目，pom如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.maimeng.baobanq</groupId>
<artifactId>baobanserver</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>baobanserver</name>
<description>Demo project for Spring Boot</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Finchley.SR1</spring-cloud.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--sentinel-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<!--sentinel end-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>0.2.2.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
需要注意引用的SpringCloud-alibaba的版本是0.2.2，当前的最新版，如果是Springboot2.x的项目，需要引0.2.x的。Springboot1.x的引0.1.x的。
Sentinel的客户端依赖也很简单，spring-cloud-starter-alibaba-sentinel加这一个引用即可。
spring:
application:
name: baobanserver
cloud:
sentinel:
transport:
dashboard: localhost:8080
#eager: true
另外由于8080端口已被占用，自行设置一个端口，如8888.
做完这些，新建一个controller，
@RestController
public class TestController {
@GetMapping(value = "/hello")
public String hello() {
return "Hello Sentinel";
}
}
就是一个普通的controller接口。
之后启动该项目。启动后回到server的控制台界面
发现并没有什么变化。然后我们调用一下hello接口。之后再次刷新server控制台。
界面已经出现了我们的项目，并且有一堆规则。
因为Sentinel采用延迟加载，只有在主动发起一次请求后，才会被拦截并发送给服务端。如果想关闭这个延迟，就在上面的yml里把eager的注释放掉。
然后在簇点链路里hello接口的流控那里设置限流规则，将单机阈值设为1.就代表一秒内最多只能通过1次请求到达该hello接口。
之后再次连续访问hello接口。
发现已经被拦截了，限流已经生效。
这样就完成了一次简单的限流操作，并且能看到各接口的QPS的统计。
后续我们来研究集群的限流、降级等功能。
最后，再附上我历时三个月总结的 Java 面试 + Java 后端技术学习指南，这是本人这几年及春招的总结，目前，已经拿到了大厂offer，拿去不谢！
下载方式
1. 首先扫描下方二维码
2. 后台回复「Java面试」即可获取
以上是关于SpringBoot接口 - 如何实现接口限流之单实例的主要内容，如果未能解决你的问题，请参考以下文章