快捷導航

詳解Spring DeferredResult異步操作使用場景

更新時間：2021年10月25日 10:03:37 作者：yangguoqi

本文主要介紹了Spring DeferredResult異步操作使用場景，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下

為什么使用DeferredResult？

API接口需要在指定時間內(nèi)將異步操作的結(jié)果同步返回給前端時；

Controller處理耗時任務(wù)，并且需要耗時任務(wù)的返回結(jié)果時；

當一個請求到達API接口，如果該API接口的return返回值是DeferredResult，在沒有超時或者DeferredResult對象設(shè)置setResult時，接口不會返回，但是Servlet容器線程會結(jié)束，DeferredResult另起線程來進行結(jié)果處理(即這種操作提升了服務(wù)短時間的吞吐能力)，并setResult，如此以來這個請求不會占用服務(wù)連接池太久，如果超時或設(shè)置setResult，接口會立即返回。

使用DeferredResult的流程：

瀏覽器發(fā)起異步請求
請求到達服務(wù)端被掛起
向瀏覽器進行響應(yīng)，分為兩種情況：
- 調(diào)用DeferredResult.setResult()，請求被喚醒，返回結(jié)果
- 超時，返回一個你設(shè)定的結(jié)果
瀏覽得到響應(yīng)，再次重復1，處理此次響應(yīng)結(jié)果

給人一種異步處理業(yè)務(wù)，但是卻同步返回的感覺。

場景

瀏覽器向A系統(tǒng)發(fā)起請求，該請求需要等到B系統(tǒng)(如ＭＱ)給A推送數(shù)據(jù)時，A才會立刻向瀏覽器返回數(shù)據(jù)；

如果指定時間內(nèi)Ｂ未給Ａ推送數(shù)據(jù)，則返回超時。

Demo代碼

接口代碼：

/get是調(diào)用A系統(tǒng)的接口返回數(shù)據(jù)；

/result模擬B系統(tǒng)向A推送數(shù)據(jù)進行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;
    }
 
    /**
     * 設(shè)置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) {
        // 請求超時的回調(diào)函數(shù)
        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層創(chuàng)建的對象
        taskMap.putIfAbsent(requestId, deferredResult::setResult);
    }
 
    /**
     * 這里相當于異步的操作方法
     * 設(shè)置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;
        }
    }
}