SpringBoot微服务异步任务选型与回调API实现咨询

一、异步方案选择：@Async vs CompletableFuture+线程池 #

优先选@Async的场景 #

如果只是需要简单触发单个耗时异步任务（比如调用外部慢服务、批量数据库操作），@Async是最优选择：

• 开发成本极低，只需在方法上加@Async注解，启动类加@EnableAsync即可，Spring自动托管线程池；
• 可通过实现AsyncConfigurer或配置ThreadPoolTaskExecutor Bean自定义线程池，轻松控制线程数、队列大小、线程命名等参数，避免默认线程池的资源耗尽风险；
• 代码简洁，无需手动处理Future的创建与管理。

选CompletableFuture+线程池的场景 #

当需要复杂任务编排时（比如多个异步任务并行执行、串联执行、合并多任务结果），CompletableFuture的链式API（thenApply、thenAccept、thenCombine等）更灵活：

• 可手动指定自定义线程池，对任务执行流程做精细化控制；
• 支持异步回调的链式处理，代码可读性更强，适配复杂业务逻辑。

总结 #

• 常规单任务异步：用@Async，省心高效；
• 复杂任务编排：用CompletableFuture+自定义线程池，灵活可控。

二、异步任务完成后调用客户端Callback URL的实现 #

1. 配置HTTP客户端（推荐WebClient） #

Spring 5+推荐用WebClient作为非阻塞HTTP客户端，适配异步场景，先配置Bean：

@Bean
public WebClient webClient() {
    return WebClient.builder()
            // 可选：开启日志便于排查问题
            .clientConnector(new ReactorClientHttpConnector(HttpClient.create().wiretap(true)))
            .build();
}

2. 异步任务中触发回调 #

用@Async的示例

@Service
public class AsyncTaskService {

    private final WebClient webClient;

    // 构造注入WebClient
    public AsyncTaskService(WebClient webClient) {
        this.webClient = webClient;
    }

    // 指定自定义线程池执行异步任务
    @Async("customAsyncExecutor")
    public void handleLongRunningTask(String requestId, String callbackUrl, RequestData requestData) {
        CallbackResult result = new CallbackResult();
        result.setRequestId(requestId);
        
        try {
            // 模拟耗时操作：调用外部服务/数据库
            Thread.sleep(5000);
            result.setStatus("SUCCESS");
            result.setData("处理完成的业务数据");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            result.setStatus("FAILED");
            result.setMessage("任务执行被中断");
        } catch (Exception ex) {
            result.setStatus("FAILED");
            result.setMessage("任务执行异常：" + ex.getMessage());
        } finally {
            // 调用客户端回调URL
            sendCallback(callbackUrl, result);
        }
    }

    private void sendCallback(String callbackUrl, CallbackResult result) {
        webClient.post()
                .uri(callbackUrl)
                .contentType(MediaType.APPLICATION_JSON)
                .bodyValue(result)
                .retrieve()
                .bodyToMono(Void.class)
                .doOnError(ex -> {
                    // 回调失败处理：记录日志、重试（可结合Spring Retry）
                    System.err.printf("回调失败，requestId: %s，错误信息：%s%n", result.getRequestId(), ex.getMessage());
                })
                .subscribe();
    }
}

用CompletableFuture的示例

如果用CompletableFuture，逻辑类似，仅任务触发方式不同：

@Service
public class AsyncTaskService {

    private final WebClient webClient;
    private final Executor customExecutor;

    public AsyncTaskService(WebClient webClient, @Qualifier("customAsyncExecutor") Executor customExecutor) {
        this.webClient = webClient;
        this.customExecutor = customExecutor;
    }

    public void handleLongRunningTask(String requestId, String callbackUrl, RequestData requestData) {
        CompletableFuture.runAsync(() -> {
            CallbackResult result = new CallbackResult();
            result.setRequestId(requestId);
            // 耗时操作逻辑同@Async示例
            try {
                Thread.sleep(5000);
                result.setStatus("SUCCESS");
                result.setData("处理完成的业务数据");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                result.setStatus("FAILED");
                result.setMessage("任务执行被中断");
            } catch (Exception ex) {
                result.setStatus("FAILED");
                result.setMessage("任务执行异常：" + ex.getMessage());
            }
            sendCallback(callbackUrl, result);
        }, customExecutor)
        .exceptionally(ex -> {
            // 处理任务执行异常
            CallbackResult failResult = new CallbackResult();
            failResult.setRequestId(requestId);
            failResult.setStatus("FAILED");
            failResult.setMessage("任务异常：" + ex.getMessage());
            sendCallback(callbackUrl, failResult);
            return null;
        });
    }

    // sendCallback方法同前
}

3. 控制器层的即时响应 #

客户端请求进来后，先通过@Valid+JSR-380注解做Schema校验，然后触发异步任务，立即返回接受响应：

@RestController
@RequestMapping("/api/resources")
public class ResourceController {

    private final AsyncTaskService asyncTaskService;

    public ResourceController(AsyncTaskService asyncTaskService) {
        this.asyncTaskService = asyncTaskService;
    }

    @PostMapping
    public ResponseEntity<ApiResponse> createResource(@Valid @RequestBody CreateResourceRequest request) {
        String requestId = UUID.randomUUID().toString();
        // 启动异步任务
        asyncTaskService.handleLongRunningTask(requestId, request.getCallbackUrl(), request.getData());
        // 返回即时响应，告知客户端请求已受理
        return ResponseEntity.accepted()
                .body(new ApiResponse(requestId, "请求已接受，正在后台处理"));
    }
}

4. 关键注意事项 #

• 自定义线程池：不管用哪种方案，一定要配置自定义线程池，避免使用Spring默认线程池（默认线程池无队列限制，易耗尽系统资源）；
• 回调重试：客户端可能不可用，需加入重试机制（比如用Spring Retry，或手动实现次数限制的重试逻辑）；
• 任务持久化：如果需要高可靠性，把未完成的任务信息存入数据库，服务重启后可加载继续执行，避免任务丢失；
• 日志监控：记录任务执行和回调的日志，便于排查问题。

内容的提问来源于stack exchange，提问作者kakoli