SpringBoot中异步操作的深度解析与实践指南

在开发中，优化接口响应速度是一个重要的性能考量。异步操作是一种有效的方法，可以在不阻塞主线程的情况下执行耗时的任务，从而提高接口的响应速度。以下是一些关于异步操作适用场景以及如何在SpringBoot中实现异步方法的详细介绍。

异步操作适用场景

异步方法适用于业务逻辑之间可以相互分割且互不影响的情况。例如：

生成并发送验证码：在用户注册或找回密码时，生成验证码和发送验证码可以异步执行。用户无需等待验证码发送成功即可收到响应，提升用户体验。
发送邮件或推送通知：在用户完成某些操作后，如下单或更新个人信息，发送确认邮件或推送通知可以异步处理，避免用户等待。
日志记录：在用户完成操作后，记录日志信息可以异步执行，不影响主业务流程。
数据缓存更新：在用户查询数据后，更新缓存数据可以异步进行，避免在主线程中执行耗时的数据库操作。

SpringBoot中的异步方法实现

在SpringBoot中，可以通过@Async注解来实现异步方法。以下是实现步骤和示例：

1. 开启异步支持

首先，需要在配置类中使用@EnableAsync注解来开启异步支持。

@Configuration
@EnableAsync
public class AsyncConfig {// 可以在这里配置线程池等参数
}

2. 使用`@Async`注解

在需要异步执行的方法上使用@Async注解。这个方法将在单独的线程中执行，而不会阻塞主线程。

@Service
public class AsyncService {@Asyncpublic void performLongRunningTask() {System.out.println("Starting long running task on thread: " + Thread.currentThread().getName());try {Thread.sleep(5000); // 模拟耗时操作} catch (InterruptedException e) {Thread.currentThread().interrupt();}System.out.println("Completed long running task on thread: " + Thread.currentThread().getName());}
}

3. 调用异步方法

在业务逻辑中调用标记了@Async的方法，这些方法将在后台线程中异步执行。

@RestController
public class AsyncController {@Autowiredprivate AsyncService asyncService;@GetMapping("/async/task")public String executeAsyncTask() {asyncService.performLongRunningTask();return "Task executed asynchronously";}
}

4. 自定义线程池

为了更好地控制异步任务的执行，可以自定义线程池。在配置类中定义一个ThreadPoolTaskExecutor Bean，并在@Async注解中指定线程池名称。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {@Overridepublic Executor getAsyncExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setCorePoolSize(10);executor.setMaxPoolSize(20);executor.setQueueCapacity(100);executor.setThreadNamePrefix("AsyncThread-");executor.initialize();return executor;}@Overridepublic AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {return new SimpleAsyncUncaughtExceptionHandler();}
}

在@Async注解中指定线程池名称：

@Async("customExecutor")
public void performLongRunningTask() {// 任务执行逻辑
}

通过这种方式，可以有效地将耗时操作异步化，从而提高接口的响应速度和用户体验。同时，自定义线程池可以更好地控制异步任务的执行，避免系统资源的浪费。

2.使用CompletableFuture：

CompletableFuture是Java 8引入的，它提供了一个可编程的异步API，可以用来编写异步代码。例如：

@Service
public class AsyncService {public CompletableFuture<String> asyncTask() {return CompletableFuture.supplyAsync(() -> {// 异步任务执行的逻辑return "异步任务执行完成";});}
}

这种方式可以让你有更多的控制权，比如可以组合多个异步任务，或者在异步任务完成后执行额外的逻辑。

使用TaskExecutor：通过实现AsyncConfigurer接口，你可以定义自己的TaskExecutor来执行异步任务。例如：

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {@Overridepublic Executor getAsyncExecutor() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();// 配置线程池参数return executor;}
}

然后，你可以在服务中注入这个TaskExecutor并使用它来执行异步任务：

@Service
public class AsyncService {@Autowiredprivate TaskExecutor taskExecutor;public void asyncTask() {taskExecutor.execute(() -> {// 异步任务执行的逻辑});}
}

这种方式给你提供了更多的灵活性，比如可以自定义线程池的大小和行为。

3、使用Servlet 3.0的异步支持：如果你的应用运行在支持Servlet 3.0的容器中，你可以使用AsyncContext来实现异步请求。例如：

@RequestMapping(value = "/email/servletReq", method = GET)
public void servletReq(HttpServletRequest request, HttpServletResponse response) {AsyncContext asyncContext = request.startAsync();// 设置监听器asyncContext.addListener(new AsyncListener() {@Overridepublic void onComplete(AsyncEvent event) throws IOException {// 完成时的逻辑}// 其他事件处理方法...});// 执行异步逻辑
}

这种方式适用于处理需要长时间运行的任务，比如文件上传或下载，而不需要阻塞服务器资源。

4、使用WebAsyncTask：

WebAsyncTask是Spring MVC提供的一个用于处理异步请求的类，它可以返回一个DeferredResult，允许你稍后设置响应。例如：

@RequestMapping(value = "/email/deferredResultReq", method = GET)
@ResponseBody
public DeferredResult<String> deferredResultReq() {DeferredResult<String> result = new DeferredResult<>(60 * 1000L);// 处理业务逻辑result.setResult("处理结果");return result;
}

这种方式适用于需要在后台执行一些操作，然后返回结果给客户端的场景

但是上述这些方法有一些局限性，就是处理结果仅仅返回单个值。在一些场景下需要异步不断的向客户端响应处理结果的时候就不能使用这些方法了，那么这时候可以看看下面的这些接口

5、 ResponseBodyEmitter

ResponseBodyEmitter 允许你发送一个流式响应，你可以在需要时发送数据片段，而不需要一次性将所有数据发送给客户端。这非常适合需要长时间运行的任务，或者需要动态生成内容并且逐步发送给客户端的场景。

举个例子：比如说在一个大型分布式系统中，系统管理员要实时监控应用的日志信息，以便快速响应潜在的问题。我们将创建一个模拟的日志生成器，它将在后台线程中生成日志条目，并通过ResponseBodyEmitter将这些条目实时发送到客户端。

@RestController
public class LogController {@GetMapping("/logs")public ResponseBodyEmitter streamLogs() {final ResponseBodyEmitter emitter = new ResponseBodyEmitter();// 启动一个新的线程来模拟日志生成new Thread(() -> {try {for (int i = 0; ; i++) {// 模拟日志消息String logEntry = "Log entry " + i + " at " + new Date();// 发送日志消息到客户端emitter.send(logEntry + "\n", MediaType.TEXT_PLAIN);// 模拟日志生成的时间间隔Thread.sleep(1000);}} catch (InterruptedException e) {// 如果线程被中断，则完成发送Thread.currentThread().interrupt();emitter.complete();} catch (IOException e) {// 如果发生IO异常，则以错误结束发送emitter.completeWithError(e);}}).start();return emitter;}
}

在这个例子中，创建了一个新的线程来模拟日志生成。这个线程会无限循环，生成日志条目，并通过ResponseBodyEmitter将它们发送到客户端。

6. SseEmitter

SseEmitter 是一种特殊的ResponseBodyEmitter，它提供了服务器发送事件（Server-Sent Events，SSE）的支持。它允许服务器主动向客户端推送实时数据。这种单向通信机制类似于你观看直播时的视频流，数据源源不断地从服务器流向客户端，而不是等待客户端定期来拉取。

SSE在服务器和客户端之间开了一条单向通道，服务端响应的是text/event-stream类型的数据流信息，在有数据变更的时候从客户端流式的传输到客户端。

想象一下，你正在观看一场足球比赛的直播，每一秒都可能有新的比分或精彩瞬间。作为观众，你希望能够立即看到这些更新，而不是每隔几分钟刷新一次页面来查看最新情况。这就是SseEmitter发挥作用的地方。

实现实时数据推送的步骤

首先，我们需要一个Spring Boot控制器来处理SSE连接，并发送消息给客户端。


@RestController
public class SseEmitterController {private final ExecutorService executor = Executors.newCachedThreadPool();// 用于存储所有的SseEmitter，以便我们可以发送消息给特定的客户端private final CopyOnWriteArrayList<SseEmitter> emitters = new CopyOnWriteArrayList<>();@GetMapping(value = "/subSseEmitter/{userId}", produces = MediaType.TEXT_EVENT_STREAM_VALUE)public SseEmitter sseEmitter(@PathVariable String userId) {SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);emitters.add(emitter);emitter.onCompletion(() -> emitters.remove(emitter));emitter.onTimeout(() -> emitter.complete());// 模拟异步消息发送executor.execute(() -> {try {for (int i = 0; ; i++) {Thread.sleep(1000); // 模拟消息发送延迟emitter.send(SseEmitter.event().data("Message " + i + " for user " + userId));}} catch (IOException | InterruptedException e) {emitter.completeWithError(e);} finally {emitters.remove(emitter);}});return emitter;}// 用于从其他端点触发消息发送@PostMapping("/sendSseMsg/{userId}")public void sendSseMsg(@PathVariable String userId, @RequestBody String msg) {for (SseEmitter emitter : emitters) {try {emitter.send(SseEmitter.event().data(msg));} catch (IOException e) {// 如果无法发送消息，则移除该emitteremitter.completeWithError(e);emitters.remove(emitter);}}}
}

客户端（HTML + JavaScript）

接下来，我们需要一个简单的HTML页面来连接到SSE端点，并显示从服务器接收到的消息。

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>SSE Client Example</title><style>#message {margin-top: 20px;border: 1px solid #ccc;padding: 10px;height: 300px;overflow: auto;}</style>
</head>
<body>
<div id="content" style="text-align: center;"><h1>SSE: Receiving Server-Side Events</h1><div id="message">Waiting for messages...</div>
</div><script>let source = null;let userId = 7777; // 可以替换为动态的用户IDfunction setMessageInnerHTML(message) {const messageDiv = document.getElementById("message");const newParagraph = document.createElement("p");newParagraph.textContent = message;messageDiv.appendChild(newParagraph);}if (window.EventSource) {// Establish a connection//建立连接source = new EventSource(`/subSseEmitter/${userId}`);setMessageInnerHTML("Connected as user=" + userId);//接受到服务端传来的消息source.addEventListener('message', function(event) {setMessageInnerHTML(event.data);});//建立连接后就会触发open事件source.addEventListener('open', function(event) {setMessageInnerHTML("Connection opened.");}, false);source.onerror = function(event) {if (source.readyState === EventSource.CLOSED) {setMessageInnerHTML("Connection was closed.");source.close();}};} else {setMessageInnerHTML("Your browser does not support SSE.");}
</script>
</body>
</html>

当客户端和服务端连接建立后，即使客户端重启也会自动重连

3. StreamingResponseBody

StreamingResponseBody 允许你以流的形式写入响应体，这在处理大文件或实时数据流时非常有用。

举个例子：在一个内容管理系统中，用户可以请求生成一个包含大量数据的年度销售报告。这个报告可能非常大，包含详细的销售数据、图表和分析，如果一次性加载到内存中，可能会导致内存溢出或性能问题。使用StreamingResponseBody可以解决这个问题，因为它允许服务器以流的形式发送数据，从而减少内存使用。

@RestController
public class ReportDownloadController {@GetMapping("/download-large-report")public ResponseEntity<StreamingResponseBody> downloadLargeReport() {return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=annual_sales_report.pdf").contentType(MediaType.APPLICATION_PDF).body(out -> {// 模拟生成PDF文件的过程generateLargeReportPdf(out);});}private void generateLargeReportPdf(OutputStream outputStream) {// 这里使用iText或类似的库来生成PDF// 以下代码仅为示例，实际生成PDF的代码会依赖于具体的库try {// 假设我们有一个方法来生成PDFboolean success = generatePdfDocument(outputStream);if (!success) {// 如果生成失败，可以抛出异常或发送错误消息throw new RuntimeException("Failed to generate the report PDF.");}} catch (IOException e) {throw new UncheckedIOException(e);}}private boolean generatePdfDocument(OutputStream outputStream) throws IOException {// 这里使用iText库来生成PDF// 以下代码仅为示例，实际生成PDF的代码会依赖于具体的库// 模拟生成一个大型PDF文件的过程for (int i = 0; i < 1000; i++) {String content = "Page " + (i + 1) + " - Sales Data as of " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "\n";outputStream.write(content.getBytes());outputStream.flush(); // 调用一次flush就会向客户端写入一次数据try {Thread.sleep(100); // 模拟生成页面的耗时操作} catch (InterruptedException e) {Thread.currentThread().interrupt();}}return true;}
}

在使用 StreamingResponseBody 时，前端下载的文件是合并成一个单一文件的，而不是多个单独的文件。这是因为 StreamingResponseBody 允许服务器以流的形式发送数据，客户端会将这些数据流连续地接收并写入到同一个文件中。

在前面的例子中，服务器端的代码通过循环生成报告的每个部分，并在每次循环中写入输出流 OutputStream。每次调用 out.flush() 时，都会将缓冲区中的数据发送到客户端。客户端浏览器会持续接收这些数据流，并将其作为单一文件处理。

这个过程类似于观看视频流或听音频流，数据是连续不断地发送和接收的，而不是分成多个独立的部分。因此，用户最终得到的是一个完整的PDF文件，而不是多个文件片段。

这里是一个简化的示意图，说明数据是如何被发送和接收的：

服务器端                             客户端
--------                             --------
| 生成数据 | --流式发送--> | 接收数据 | --写入--> | 完整文件 |
| 部分 1   |             | 部分 1   |           | PDF 文件  |
| 部分 2   |             | 部分 2   |           |           |
| ...      |             | ...      |           |           |
| 部分 N   |             | 部分 N   |           |           |
--------                             --------