Spring @ExceptionHandler and multi-threading

Question

I've got the following controller advice:

@ControllerAdvice
public class ExceptionHandlerAdvice {

    @ExceptionHandler(NotCachedException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ModelAndView handleNotCachedException(NotCachedException ex) {
        LOGGER.warn("NotCachedException: ", ex);
        return generateModelViewError(ex.getMessage());
    }

}

It works great most of the time but when the NotCachedException is thrown from a method annotated with @Async, the exception is not handled properly.

@RequestMapping(path = "", method = RequestMethod.PUT)
@Async
public ResponseEntity<String> store(@Valid @RequestBody FeedbackRequest request, String clientSource) {
    cachingService.storeFeedback(request, ClientSource.from(clientSource));
    return new ResponseEntity<>(OK);
}

Here is the config of the Executor:

@SpringBootApplication
@EnableAsync
public class Application {

private static final Logger LOGGER = LoggerFactory.getLogger(Application.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        SettingsConfig settings = context.getBean(SettingsConfig.class);
        LOGGER.info("{} ({}) started", settings.getArtifact(), settings.getVersion());
        createCachingIndex(cachingService);
    }

    @Bean(name = "matchingStoreExecutor")
    public Executor getAsyncExecutor() {
        int nbThreadPool = 5;
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(nbThreadPool);
        executor.setMaxPoolSize(nbThreadPool * 2);
        executor.setQueueCapacity(nbThreadPool * 10);
        executor.setThreadNamePrefix("matching-store-executor-");
        executor.initialize();
        return executor;
    }

}

What can I do in order to make it work with @Async annotated methods?

What do you mean with "the exception is not handled properly"? — snovelli, May 23 '17 at 18:28
@snovelli The ExceptionHandler methods in the ControllerAdvice just doesn't see the exceptions. — Rlarroque, May 24 '17 at 07:38
@Rlarroque have you looked into http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#scheduling-annotation-support-exception ? Maybe this could help your exception handling — gnos, May 24 '17 at 09:36

Vijender Kumar · Accepted Answer · 2017-07-12T18:45:49.707

8

The default exception handling machenism does not work in case of @Async Enabled. To handle exception thrown from methods annotated with @Async, you need to implement a custom AsyncExceptionHandler as.

public class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler{
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // Here goes your exception handling logic.

    }
}

Now You need to configure this customExceptionHandler in you Application class as

@EnableAsync
public class Application implements AsyncConfigurer {
     @Override Executor getAsyncExecutor(){
      // your ThreadPoolTaskExecutor configuration goes here. 
}


@Override
public AsyncUncaughExceptionHandler getAsyncUncaughtExceptionHandler(){
   return new AsyncExceptionHandler();
}

Note: Make sure in order to make your AsyncExceptionHandler work you need to implement AsyncConfigurer in your Application class.

edited Jul 12 '17 at 18:45

answered Jul 12 '17 at 14:27

Vijender Kumar

1,285
2
17
26

Would you need to implement AsyncConfigurer if you are using spring boot? – cmptrwizard Feb 08 '18 at 16:55
1

Why it is answer? AsyncUncaughExceptionHandler doesn't have a sink to send HTTP response. Just logging a stacktrace is not enough. – Daniil Iaitskov Sep 13 '18 at 17:45
Agree with @DaneelS.Yaitskov this is not an answer. – akuma8 Feb 23 '19 at 22:09

Justinas Jakavonis · Answer 2 · 2021-12-18T21:58:51.963

@Async shouldn't be used on controller methods as you would have one thread per request anyway. More details: is using @Async and CompletableFuture in controller can increase performance of our api?

If a service method like cachingService.storeFeedback takes long time to be completed and you want immediate response from endpoint then it could be annotated @Async in the service layer so cachingService.storeFeedback could be executed in the background.

For controller method below, neither @ExceptionHandler nor previous answer would help to return HTTP error response if exception would occur in the void @Async service method:

@RequestMapping(path = "", method = RequestMethod.PUT)
public ResponseEntity<String> store(@Valid @RequestBody FeedbackRequest request, String clientSource) {
    cachingService.storeFeedback(request, ClientSource.from(clientSource));
    return new ResponseEntity<>(OK);
}

If controller would return Future from @Async service then @ExceptionHandler should be sufficient to handle endpoint errors:

@RequestMapping(path = "", method = RequestMethod.PUT)
public CompletableFuture<String> store(@Valid @RequestBody FeedbackRequest request, String clientSource) {
    return cachingService.storeFeedback(request, ClientSource.from(clientSource));
}

According to How To Do @Async in Spring:

When a method return type is a Future, exception handling is easy. Future.get() method will throw the exception.

But if the return type is void, exceptions will not be propagated to the calling thread. So, we need to add extra configurations to handle exceptions.

Spring @ExceptionHandler and multi-threading

2 Answers2

Linked