所有已知实现类:
CallableProcessingInterceptorAdapter, TimeoutCallableProcessingInterceptor
```
public interface CallableProcessingInterceptor
```
Intercepts concurrent request handling, where the concurrent result is obtained by executing a Callable on behalf of the application with an AsyncTaskExecutor.
A CallableProcessingInterceptor is invoked before and after the invocation of the Callable task in the asynchronous thread, as well as on timeout from a container thread, or after completing for any reason including a timeout or network error.
As a general rule exceptions raised by interceptor methods will cause async processing to resume by dispatching back to the container and using the Exception instance as the concurrent result. Such exceptions will then be processed through the HandlerExceptionResolver mechanism.
The handleTimeout method can select a value to be used to resume processing.
从以下版本开始:
3.2
作者:
Rossen Stoyanchev, Rob Winch

字段概要

字段
修饰符和类型	字段	说明
`static Object`	`RESPONSE_HANDLED`	Constant indicating that the response has been handled by this interceptor without a result and that no further interceptors are to be invoked.
`static Object`	`RESULT_NONE`	Constant indicating that no result has been determined by this interceptor, giving subsequent interceptors a chance.

方法概要

所有方法实例方法抽象方法
修饰符和类型	方法	说明
`<T> void`	`afterCompletion(NativeWebRequest request, Callable<T> task)`	Invoked from a container thread when async processing completes for any reason including timeout or network error.
`<T> void`	`beforeConcurrentHandling(NativeWebRequest request, Callable<T> task)`	Invoked before the start of concurrent handling in the original thread in which the `Callable` is submitted for concurrent handling.
`<T> Object`	`handleTimeout(NativeWebRequest request, Callable<T> task)`	Invoked from a container thread when the async request times out before the `Callable` task completes.
`<T> void`	`postProcess(NativeWebRequest request, Callable<T> task, Object concurrentResult)`	Invoked after the `Callable` has produced a result in the async thread in which the `Callable` is executed.
`<T> void`	`preProcess(NativeWebRequest request, Callable<T> task)`	Invoked after the start of concurrent handling in the async thread in which the `Callable` is executed and before the actual invocation of the `Callable`.

- 字段详细资料
  - RESULT_NONE
```
static final Object RESULT_NONE
```
    Constant indicating that no result has been determined by this interceptor, giving subsequent interceptors a chance.
    另请参阅:
    handleTimeout(org.springframework.web.context.request.NativeWebRequest, java.util.concurrent.Callable<T>)
  - RESPONSE_HANDLED
```
static final Object RESPONSE_HANDLED
```
    Constant indicating that the response has been handled by this interceptor without a result and that no further interceptors are to be invoked.
    另请参阅:
    handleTimeout(org.springframework.web.context.request.NativeWebRequest, java.util.concurrent.Callable<T>)
- 方法详细资料
  - beforeConcurrentHandling
```
<T> void beforeConcurrentHandling(NativeWebRequest request,
                                  Callable<T> task)
                           throws Exception
```
    Invoked before the start of concurrent handling in the original thread in which the Callable is submitted for concurrent handling.
    This is useful for capturing the state of the current thread just prior to invoking the Callable. Once the state is captured, it can then be transferred to the new Thread in preProcess(NativeWebRequest, Callable). Capturing the state of Spring Security's SecurityContextHolder and migrating it to the new Thread is a concrete example of where this is useful.
    参数:
    request - the current request
    task - the task for the current async request
    抛出:
    Exception - in case of errors
  - preProcess
```
<T> void preProcess(NativeWebRequest request,
                    Callable<T> task)
             throws Exception
```
    Invoked after the start of concurrent handling in the async thread in which the Callable is executed and before the actual invocation of the Callable.
    参数:
    request - the current request
    task - the task for the current async request
    抛出:
    Exception - in case of errors
  - postProcess
```
<T> void postProcess(NativeWebRequest request,
                     Callable<T> task,
                     Object concurrentResult)
              throws Exception
```
    Invoked after the Callable has produced a result in the async thread in which the Callable is executed. This method may be invoked later than afterTimeout or afterCompletion depending on when the Callable finishes processing.
    参数:
    request - the current request
    task - the task for the current async request
    concurrentResult - the result of concurrent processing, which could be a Throwable if the Callable raised an exception
    抛出:
    Exception - in case of errors
  - handleTimeout
```
<T> Object handleTimeout(NativeWebRequest request,
                         Callable<T> task)
                  throws Exception
```
    Invoked from a container thread when the async request times out before the Callable task completes. Implementations may return a value, including an Exception, to use instead of the value the Callable did not return in time.
    参数:
    request - the current request
    task - the task for the current async request
    返回:
    a concurrent result value; if the value is anything other than RESULT_NONE or RESPONSE_HANDLED, concurrent processing is resumed and subsequent interceptors are not invoked
    抛出:
    Exception - in case of errors
  - afterCompletion
```
<T> void afterCompletion(NativeWebRequest request,
                         Callable<T> task)
                  throws Exception
```
    Invoked from a container thread when async processing completes for any reason including timeout or network error.
    参数:
    request - the current request
    task - the task for the current async request
    抛出:
    Exception - in case of errors

接口 CallableProcessingInterceptor

字段概要

方法概要

字段详细资料

RESULT_NONE

RESPONSE_HANDLED

方法详细资料

beforeConcurrentHandling

preProcess

postProcess

handleTimeout

afterCompletion