org.springframework.web.context.request.async

## Class CallableProcessingInterceptorAdapter

- java.lang.Object
- - org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter

- All Implemented Interfaces:
    CallableProcessingInterceptor
  Direct Known Subclasses:
    AsyncRequestInterceptor, AsyncRequestInterceptor, TimeoutCallableProcessingInterceptor

      public abstract class CallableProcessingInterceptorAdapter
      extends Object
      implements CallableProcessingInterceptor

  Abstract adapter class for the `CallableProcessingInterceptor` interface, for simplified implementation of individual methods.
  Since:
    3.2
  Author:
    Rossen Stoyanchev, Rob Winch

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.web.context.request.async.CallableProcessingInterceptor

      `RESPONSE_HANDLED, RESULT_NONE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `CallableProcessingInterceptorAdapter()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `<T> void` | `afterCompletion(NativeWebRequest request, Callable<T> task)` This implementation is empty.
    `<T> void` | `beforeConcurrentHandling(NativeWebRequest request, Callable<T> task)` This implementation is empty.
    `<T> Object` | `handleTimeout(NativeWebRequest request, Callable<T> task)` This implementation always returns `RESULT_NONE`.
    `<T> void` | `postProcess(NativeWebRequest request, Callable<T> task, Object concurrentResult)` This implementation is empty.
    `<T> void` | `preProcess(NativeWebRequest request, Callable<T> task)` This implementation is empty.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### CallableProcessingInterceptorAdapter

          public CallableProcessingInterceptorAdapter()

  - ### Method Detail

    - #### beforeConcurrentHandling

          public <T> void beforeConcurrentHandling(NativeWebRequest request,
                                          Callable<T> task)
                                        throws Exception

      This implementation is empty.
      Specified by:
        `beforeConcurrentHandling` in interface `CallableProcessingInterceptor`
      Parameters:
        `request` - the current request
        `task` - the task for the current async request
      Throws:
        `Exception` - in case of errors

    - #### preProcess

          public <T> void preProcess(NativeWebRequest request,
                            Callable<T> task)
                          throws Exception

      This implementation is empty.
      Specified by:
        `preProcess` in interface `CallableProcessingInterceptor`
      Parameters:
        `request` - the current request
        `task` - the task for the current async request
      Throws:
        `Exception` - in case of errors

    - #### postProcess

          public <T> void postProcess(NativeWebRequest request,
                             Callable<T> task,
                             Object concurrentResult)
                           throws Exception

      This implementation is empty.
      Specified by:
        `postProcess` in interface `CallableProcessingInterceptor`
      Parameters:
        `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
      Throws:
        `Exception` - in case of errors

    - #### handleTimeout

          public <T> Object handleTimeout(NativeWebRequest request,
                                 Callable<T> task)
                               throws Exception

      This implementation always returns `RESULT_NONE`.
      Specified by:
        `handleTimeout` in interface `CallableProcessingInterceptor`
      Parameters:
        `request` - the current request
        `task` - the task for the current async request
      Returns:
        a concurrent result value; if the value is anything other than `CallableProcessingInterceptor.RESULT_NONE` or `CallableProcessingInterceptor.RESPONSE_HANDLED`, concurrent processing is resumed and subsequent interceptors are not invoked
      Throws:
        `Exception` - in case of errors

    - #### afterCompletion

          public <T> void afterCompletion(NativeWebRequest request,
                                 Callable<T> task)
                               throws Exception

      This implementation is empty.
      Specified by:
        `afterCompletion` in interface `CallableProcessingInterceptor`
      Parameters:
        `request` - the current request
        `task` - the task for the current async request
      Throws:
        `Exception` - in case of errors