Обработчик исключений Spring Async Uncaught

@Async методы могут быть настроены с помощью пользовательского Executor для регистрации любых сгенерированных исключений.

Следующий код реализует этот шаблон. Любой метод, помеченный @Async, будет использовать Executor, возвращаемый методом public Executor getAsyncExecutor(). Это возвращает HandlingExecutor, который позаботится обо всем ведении журнала (в этом случае он просто печатает слово «CAUGHT!», но вы можете заменить его на ведение журнала.

@Configuration
@EnableAsync
public class ExampleConfig implements AsyncConfigurer {
    @Bean
    public Runnable testExec() {
        return new TestExec();
    }

    @Override
    public Executor getAsyncExecutor() {
        final ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(7);
        executor.setMaxPoolSize(42);
        executor.setQueueCapacity(11);
        executor.setThreadNamePrefix("MyExecutor-");
        executor.initialize();
        return new HandlingExecutor(executor);
    }
}

public class HandlingExecutor implements AsyncTaskExecutor {
    private AsyncTaskExecutor executor;

    public HandlingExecutor(AsyncTaskExecutor executor) {
        this.executor = executor;
    }

    @Override
    public void execute(Runnable task) {
        executor.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        executor.execute(createWrappedRunnable(task), startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return executor.submit(createWrappedRunnable(task));
    }

    @Override
    public <T> Future<T> submit(final Callable<T> task) {
        return executor.submit(createCallable(task));
    }

    private <T> Callable<T> createCallable(final Callable<T> task) {
        return new Callable<T>() {
            @Override
            public T call() throws Exception {
                try {
                    return task.call();
                } catch (Exception e) {
                    handle(e);
                    throw e;
                }
            }
        };
    }

    private Runnable createWrappedRunnable(final Runnable task) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    task.run();
                } catch (Exception e) {
                    handle(e);
                }
            }
        };
    }

    private void handle(Exception e) {
        System.out.println("CAUGHT!");
    }
}

Обновление: Начиная с Spring 4.1

Начиная с Spring 4.1 можно иметь AsyncUncaughtExceptionHandler для @Async void методов.

Справочный документ Spring, Глава 34.4 .5 Управление исключениями с помощью @Async

... Однако с типом возвращаемого значения void исключение не перехватывается и не может быть передано. Для этих случаев можно предоставить AsyncUncaughtExceptionHandler для обработки таких исключений.

По умолчанию исключение просто регистрируется. Пользовательский AsyncUncaughtExceptionHandler можно определить с помощью AsyncConfigurer или XML-элемента task:annotation-driven.

(Эта функция была введена после того, как DD отправил запрос на улучшение: https://jira.spring.io/browse/SPR-8995 , см. комментарии к этому ответу)

До Spring 4.1

Похоже, отсутствует функция обработки исключений метода void, возвращающего @Async. (Я не могу найти подсказку в справочнике или java-документе)

Что я могу представить для решения: попробуйте использовать AspectJ, чтобы написать какую-то оболочку вокруг всех @Async методов, которые регистрируют исключения.

Что касается термина журнала, я бы порекомендовал создать запрос freature в средстве отслеживания ошибок Spring.

Прежде всего, вы должны создать собственный класс обработчика исключений, как показано ниже:

@Component
public class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

        private final Logger logger = LoggerFactory.getLogger(AsyncExceptionHandler.class);

        @Override
        public void handleUncaughtException(Throwable ex, Method method, Object... params) {
            logger.error("Unexpected asynchronous exception at : "
                    + method.getDeclaringClass().getName() + "." + method.getName(), ex);
        }

    }

После этого вы должны установить свой собственный класс обработчика исключений в своей конфигурации, как показано ниже:

@Configuration
@EnableAsync
public class AsyncConfig extends AsyncConfigurerSupport {

    @Autowired
    private AsyncExceptionHandler asyncExceptionHandler;

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return asyncExceptionHandler;
    }

}

Примечание. Внедряемый обработчик исключений является опцией. Вы можете создать новый экземпляр для каждого исключения. Мой совет - использовать Injection для класса обработчика исключений, потому что областью действия Spring по умолчанию является singleton, поэтому нет необходимости создавать новый экземпляр для каждого исключения.

Вы можете использовать стандартный подход Spring AOP.

@Aspect
@Component
@Slf4j
public class AsyncHandler {

   @Around("@annotation(org.springframework.scheduling.annotation.Async)")
   private Object handle(ProceedingJoinPoint pjp) throws Throwable {
       try {
           Object retVal = pjp.proceed();
           return retVal;
       } catch (Throwable e) {
           log.error("in ASYNC, method: " + pjp.getSignature().toLongString() + ", args: " + AppStringUtils.transformToWellFormattedJsonString(pjp.getArgs()) + ", exception: "+ e, e);
           throw e;
       }
   }

}