SpringMVC异步处理的 5 种方式

SpringMVC异步处理的 5 种方式

Spring MVC 处理异步请求的主要原因是提高 Web 应用的性能和可扩展性，特别是在处理长时间运行的任务或需要等待外部资源（如数据库查询、远程服务调用等）时。以下是一些具体原因和优势：

优势

1. 资源利用效率

在传统的同步请求处理中，服务器在处理请求时会占用一个线程直到请求完成。对于长时间运行的任务，这会导致线程被长时间占用，影响服务器的并发处理能力。通过异步请求处理，服务器在等待任务完成时可以释放线程资源，使其能够处理更多的请求，从而提高整体的资源利用效率。

2. 提高并发能力

异步请求处理能够显著提高服务器的并发处理能力。对于高并发的 Web 应用，特别是需要处理大量长时间运行任务的应用，异步处理能够有效减少线程阻塞，提高服务器的吞吐量和响应能力。

3. 改善用户体验

异步处理能够在后台执行长时间运行的任务，而不会阻塞主线程，从而可以更快地响应用户请求。这对于需要快速响应的 Web 应用来说，能够显著改善用户体验。

4. 支持长轮询和推送技术

异步请求处理是实现长轮询（long polling）和服务器推送（server push）技术的基础。通过这些技术，服务器可以在有新数据时主动推送给客户端，而不是让客户端频繁轮询服务器，从而减少网络开销和延迟，提高实时性。

5. 更好的架构设计

通过异步请求处理，可以将长时间运行的任务和短时间运行的任务解耦，采用更灵活的架构设计。这样可以更容易地实现负载均衡和任务调度，提高系统的可维护性和扩展性。

长连接的实现，用到了 servlet 的异步处理。异步处理最大的好处是可以提高并发量，不阻塞当前线程。其实 Spring MVC 也支持了异步处理，本文记录下相关的技术点。

异步处理 demo

如果要启用异步返回，需要开启 @EnableAsync。如下的代码中，使用 DeferredResult 进行异步处理。

请求进来后，首先创建 DeferredResult 对象，设置超时时间为 60 秒。然后指定 DeferredResult 在异步完成和等待超时时的回调。同步的处理只需要创建异步任何，然后返回 DeferredResult 即可。这样 Spring MVC 处理完此次请求后，不会立即返回 response 给客户端，会一直等待 DeferredResult 处理完成。如果 DeferredResult 没有在 60 秒内处理完成，就会触发超时，然后返回 response 给客户端。

@RequestMapping(value = "/async/demo")
public DeferredResult<String> async(){
    // 创建 DeferredResult，设置超时时间 60s
    DeferredResult<String> deferredResult = new DeferredResult<>((long)60 * 1000);
 
    String uuid = UUID.randomUUID().toString();
    Runnable callback = () -> manager.remove(deferredResult, uuid);
    // 设置完成和超时的回调
    deferredResult.onCompletion(callback);
    deferredResult.onTimeout(callback);
 
    // 创建异步任务
    manager.addAsyncTask(deferredResult, uuid);
 
    // 同步返回 DeferredResult
    return deferredResult;
}

对于异步任务来说，需要持有 DeferredResult 对象。在异步处理结束时，需要手动调用 DeferredResult.setResult 完成输出。调用 setResult 时，数据输出写到客户端，然后触发异步完成事件执行回调。

task.getDeferredResult().setResult(ConfigJsonUtils.toJsonString(map));

使用 DeferredResult 进行异步处理

DeferredResult 这个类代表延迟结果。DeferredResult 可以用在异步任务中，其他线程能够获取 DeferredResult 并设置 DeferredResult 的返回数据。通常可以使用线程池、队列等配合 DeferredResult 实现异步处理。

根据官方描述，Spring MVC 处理流程如下：

1. 把 controller 返回的 DeferredResult 保存在内存队列或集合当中；
2. Spring MVC 调用 request.startAsync()，开启异步；
3. DispatcherServlet 和所有的 Filter 退出当前请求线程；
4. 业务应用在异步线程中设置 DeferredResult 的返回值，Spring MVC 会再次发送请求；
5. DispatcherServlet 再次被调用，并使用 DeferredResult 的返回值；

使用 Callable 进行异步处理

使用 Callable 进行异步处理与 DeferredResult 类似。不同的是，Callable 会交给系统指定的 TaskExecutor 执行。

根据官方描述，Spring MVC 处理流程如下：

1. controller 返回 Callable；
2. Spring MVC 调用 request.startAsync()，开启异步，提交 Callable 到一个任务线程池；
3. DispatcherServlet 和所有的 Filter 退出当前请求线程；
4. 业务应用在异步线程中返回值，Spring MVC 会再次发送请求；
5. DispatcherServlet 再次被调用，并使用 Callable 的返回值；

@RequestMapping(value = "/async/demo")
public Callable<String> async(){
    Callable<String> callable = () -> String.valueOf(System.currentTimeMillis());
    // 同步返回
    return callable;
}

使用 ListenableFuture 进行异步处理

ListenableFuture 作为返回值，与 DeferredResult 类似。也需要使用者自行处理异步线程，但不支持超时、完成回调，需要自行处理。

@RequestMapping(value = "/async/demo")
public ListenableFuture<String> async(){
    ListenableFutureTask<String> ListenableFuture= new ListenableFutureTask<>(() -> {
        return String.valueOf(System.currentTimeMillis());
    });
    Executors.newSingleThreadExecutor().submit(ListenableFuture);
    return ListenableFuture;
}

使用 ResponseBodyEmitter 进行异步处理

DeferredResult 和 Callable 都只能返回一个异步值。如果需要返回多个对象，就要使用 ResponseBodyEmitter。返回的每个对象都会被 HttpMessageConverter 处理并写回输出流。如果希望设置更多返回数据，如 header、status 等，可以把 ResponseBodyEmitter 作为 ResponseEntity 的实体数据返回。

@RequestMapping("/async/responseBodyEmitter")
public ResponseBodyEmitter responseBodyEmitter(){
    ResponseBodyEmitter responseBodyEmitter=new ResponseBodyEmitter();
 
    Executors.newSingleThreadExecutor().submit(() -> {
        try {
            responseBodyEmitter.send("demo");
            responseBodyEmitter.send("test");
            responseBodyEmitter.complete();
        } catch (Exception ignore) {}
    });
 
    return responseBodyEmitter;

使用 StreamingResponseBody 进行异步处理

如果希望跳过返回值的自动转换，直接把输出流写入 OutputStream，可以使用 StreamingResponseBody。也可以作为 ResponseEntity 的实体数据返回。

@RequestMapping("/async/streamingResponseBody")
public StreamingResponseBody streamingResponseBody(){
    StreamingResponseBody streamingResponseBody = outputStream -> {
        Executors.newSingleThreadExecutor().submit(() -> {
            try {
                outputStream.write("<html>streamingResponseBody</html>".getBytes());
            } catch (IOException ignore) {}
        });
    };
    return streamingResponseBody;
}

各种处理方式的对比

以上几种异步处理方式各有差异，需要按需取舍。对比如下。

	可返回次数	数据转换	回调	线程池
DeferredResult	1 次	有	完成、超时	自行处理
Callable	1 次	有	无	系统处理
ListenableFuture	1 次	有	无	自行处理
ResponseBodyEmitter	多次	有	无	自行处理
StreamingResponseBody	多次	无	无	自行处理