CallableProcessingInterceptor 应用场景说明

CallableProcessingInterceptor 拦截器用于处理基于 Callable 的异步请求。这种拦截器特别适用于处理那些可能需要很长时间来完成的任务，比如执行数据库查询、调用外部服务、进行文件读写操作等，而不会阻塞服务器的线程。

业务场景：

假设你正在开发一个电商平台，需要提供一个功能来搜索商品。由于商品数据库非常大，搜索操作可能会花费较长时间。为了提高用户体验，你希望搜索操作能够异步执行，不会导致用户浏览器端的长时间等待。

示例场景：

假设你正在开发一个在线购物平台，需要实现一个异步处理订单的功能，该功能可能需要一些时间来处理库存检查、支付确认等操作。

实现 CallableProcessingInterceptor：

import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.async.CallableProcessingInterceptor;
import java.util.concurrent.Callable;

public class OrderProcessingInterceptor implements CallableProcessingInterceptor {

    // 在异步处理开始之前执行的逻辑
    @Override
    public <T> void beforeConcurrentHandling(NativeWebRequest request, Callable<T> task) {
        // 例如，记录日志或初始化任务
        System.out.println("Order processing is starting for order: " + request.getAttribute("orderId", 0));
    }

    // 在调用 Callable.call() 方法之前执行的逻辑
    @Override
    public <T> void preProcess(NativeWebRequest request, Callable<T> task) {
        // 例如，检查订单状态
    }

    // 在异步处理完成之后执行的逻辑
    @Override
    public <T> void postProcess(NativeWebRequest request, Callable<T> task, Object concurrentResult) {
        // 处理结果或异常
        if (concurrentResult instanceof Exception) {
            System.err.println("Order processing failed: " + concurrentResult.getMessage());
        } else {
            System.out.println("Order processed successfully. Result: " + concurrentResult);
        }
    }

    // 处理超时逻辑
    @Override
    public <T> Object handleTimeout(NativeWebRequest request, Callable<T> task) {
        // 可以设置订单状态为超时，记录日志等
        System.out.println("Order processing timed out. Order ID: " + request.getAttribute("orderId", 0));
        return CallableProcessingInterceptor.RESULT_NONE; // 可以选择是否重新尝试等
    }

    // 处理异步处理期间发生的异常
    @Override
    public <T> Object handleError(NativeWebRequest request, Callable<T> task, Throwable t) {
        // 可以记录异常信息，设置订单状态等
        System.err.println("Error processing order: " + t.getMessage());
        return CallableProcessingInterceptor.RESULT_NONE; // 可以选择是否重新尝试等
    }

    // 请求完成后执行的逻辑，无论成功还是失败
    @Override
    public <T> void afterCompletion(NativeWebRequest request, Callable<T> task) {
        // 例如，清理资源或记录请求结束日志
        System.out.println("Order processing completed. Order ID: " + request.getAttribute("orderId", 0));
    }
}

使用拦截器：

在Spring配置类中注册此拦截器：

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.context.annotation.Configuration;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
        configurer.registerCallableInterceptors(new OrderProcessingInterceptor());
    }
}

控制器示例：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.DeferredResult;
import java.util.concurrent.Callable;

@RestController
public class OrderController {

    @GetMapping("/order")
    public Callable<String> processOrder() {

        return () -> {
            // 模拟长时间运行的任务
            try {
                Thread.sleep(3000); // 假设这是订单处理时间
                return "Order processed successfully";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "Order processing was interrupted";
            }
        };
    }
}

目的：

• OrderProcessingInterceptor 允许开发者在订单处理的异步请求的不同阶段插入自定义逻辑，例如记录日志、检查订单状态、处理超时和异常等。
• 通过实现 CallableProcessingInterceptor，可以提高应用程序处理异步任务的能力，优化用户体验，并增强系统的健壮性。