DeferredResult

矫情吗；* 2024-03-17 17:49 57阅读 0赞

## 1.为什么使用DeferredResult？ ##

**API接口需要在指定时间内将异步操作的结果同步返回给前端时；**

**Controller处理耗时任务，并且需要耗时任务的返回结果时；**

当一个请求到达API接口，如果该API接口的return返回值是DeferredResult，在没有超时或者DeferredResult对象设置setResult时，接口不会返回，但是Servlet容器线程会结束，DeferredResult另起线程来进行结果处理(即这种操作提升了**服务短时间的吞吐能力**)，并setResult，如此以来这个请求不会占用服务连接池太久，如果超时或设置setResult，接口会立即返回。

使用DeferredResult的流程：

1.  浏览器发起异步请求
2.  请求到达服务端被挂起
3.  向浏览器进行响应，分为两种情况：  
    3.1 调用`DeferredResult.setResult()`，请求被唤醒，返回结果  
    3.2 超时，返回一个你设定的结果
4.  浏览得到响应，再次重复1，处理此次响应结果

给人一种异步处理业务，但是却同步返回的感觉。

## 2.场景 ##

浏览器向A系统发起请求，该请求需要等到B系统(如ＭＱ)给A推送数据时，A才会立刻向浏览器返回数据；

如果指定时间内Ｂ未给Ａ推送数据，则返回超时。

## 3.Demo代码 ##

接口代码：

/get是调用A系统的接口返回数据；

/result模拟B系统向A推送数据进行setResult。

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.context.request.async.DeferredResult;
    
    
    @RestController
    @RequestMapping(value = "/deferred-result")
    public class DeferredResultController {
    
        @Autowired
        private DeferredResultService deferredResultService;
    
        /**
         * 为了方便测试，简单模拟一个
         * 多个请求用同一个requestId会出问题
         */
        private final String requestId = "haha";
    
    
        @GetMapping(value = "/get")
        public DeferredResult<DeferredResultResponse> get(@RequestParam(value = "timeout", required = false, defaultValue = "10000") Long timeout) {
            DeferredResult<DeferredResultResponse> deferredResult = new DeferredResult<>(timeout);
    
            deferredResultService.process(requestId, deferredResult);
    
            return deferredResult;
        }
    
        /**
         * 设置DeferredResult对象的result属性，模拟异步操作
         * @param desired
         * @return
         */
        @GetMapping(value = "/result")
        public String settingResult(@RequestParam(value = "desired", required = false, defaultValue = "成功") String desired) {
            DeferredResultResponse deferredResultResponse = new DeferredResultResponse();
            if (DeferredResultResponse.Msg.SUCCESS.getDesc().equals(desired)){
                deferredResultResponse.setCode(HttpStatus.OK.value());
                deferredResultResponse.setMsg(desired);
            }else{
                deferredResultResponse.setCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
                deferredResultResponse.setMsg(DeferredResultResponse.Msg.FAILED.getDesc());
            }
            deferredResultService.settingResult(requestId, deferredResultResponse);
    
            return "Done";
        }
    }

import org.springframework.http.HttpStatus;
    import org.springframework.stereotype.Service;
    import org.springframework.web.context.request.async.DeferredResult;
    
    import java.util.Map;
    import java.util.Optional;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.function.Consumer;
    
    @Service
    public class DeferredResultService {
    
        private Map<String, Consumer<DeferredResultResponse>> taskMap;
    
        public DeferredResultService() {
            taskMap = new ConcurrentHashMap<>();
        }
    
        /**
         * 将请求id与setResult映射
         *
         * @param requestId
         * @param deferredResult
         */
        public void process(String requestId, DeferredResult<DeferredResultResponse> deferredResult) {
            // 请求超时的回调函数
            deferredResult.onTimeout(() -> {
                taskMap.remove(requestId);
                DeferredResultResponse deferredResultResponse = new DeferredResultResponse();
                deferredResultResponse.setCode(HttpStatus.REQUEST_TIMEOUT.value());
                deferredResultResponse.setMsg(DeferredResultResponse.Msg.TIMEOUT.getDesc());
                deferredResult.setResult(deferredResultResponse);
            });
    
            Optional.ofNullable(taskMap)
                    .filter(t -> !t.containsKey(requestId))
                    .orElseThrow(() -> new IllegalArgumentException(String.format("requestId=%s is existing", requestId)));
    
            // 这里的Consumer，就相当于是传入的DeferredResult对象的地址
            // 所以下面settingResult方法中"taskMap.get(requestId)"就是Controller层创建的对象
            taskMap.putIfAbsent(requestId, deferredResult::setResult);
        }
    
        /**
         * 这里相当于异步的操作方法
         * 设置DeferredResult对象的setResult方法
         *
         * @param requestId
         * @param deferredResultResponse
         */
        public void settingResult(String requestId, DeferredResultResponse deferredResultResponse) {
            if (taskMap.containsKey(requestId)) {
                Consumer<DeferredResultResponse> deferredResultResponseConsumer = taskMap.get(requestId);
                // 这里相当于DeferredResult对象的setResult方法
                deferredResultResponseConsumer.accept(deferredResultResponse);
                taskMap.remove(requestId);
            }
        }
    
    }

import lombok.Data;
    import lombok.Getter;
    
    @Data
    public class DeferredResultResponse {
        private Integer code;
        private String msg;
    
        public enum Msg {
            TIMEOUT("超时"),
            FAILED("失败"),
            SUCCESS("成功");
    
            @Getter
            private String desc;
    
            Msg(String desc) {
                this.desc = desc;
            }
        }
    }

## 4.测试 ##

### 1). 超时 ###

设置超时时间为8s，会一直阻塞8s，如果超时，返回默认超时的结果

![023a4f08fb3044d9f780807d93e87776.png][]

8s过去，没有setResult，返回超时

![59e67263377c1a9aa354dd7f0cc36dae.png][]

### 2). 进行setResult ###

在阻塞期间调用setResult，我这里模拟的是B系统推送数据给A时抛异常失败的情况，会立刻得到返回结果

![0adf74f09dbcf9aef496d9bc9370672a.png][]

![f3c65042208738f3f190499aac42578b.png][]

## 参考来源 ##

[DeferredResult的使用场景及用法 - 胡桃同学的个人空间 - OSCHINA - 中文开源技术交流社区][DeferredResult_ - _ - OSCHINA -]

[023a4f08fb3044d9f780807d93e87776.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/09c23bbb15834c09a55b3dd27d85286f.png
[59e67263377c1a9aa354dd7f0cc36dae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/fbd98db025a54ca8bc59e92d70916b1f.png
[0adf74f09dbcf9aef496d9bc9370672a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7298c50baa67423a98f45c8cc55ed64e.png
[f3c65042208738f3f190499aac42578b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1307631afb6c446aa2608b20fcf5dde8.png
[DeferredResult_ - _ - OSCHINA -]: https://my.oschina.net/ojeta/blog/806087