@Async Exception handling Spring Boot

The spring boot @Async annotation enables the class method to run asynchronous. The handling of the exception in the @Async annotation method is therefore complex. Spring boot supports the default Async Uncaught Exception handler that throws the actual exception in the console log. Spring boot allows the Async Uncaught Exception handler to be customised for errors.

This post discusses the step-by-step procedure to enable the asynchronous execution of a method using @Async annotation and exception handling using the custom Async Uncaught Exception handler.

Step 1 – Add @EnableAsync annotation to Application

For asynchronous execution, the spring boot application should be activated. The @EnableAsync annotation will allow the spring boot application in asynchronous mode. Add the @EnableAsync annotation to the class of the spring application main method. The example below shows the @EnableAsync annotation added with the main method class.


package com.yawintutor;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

public class SpringBootAsyncApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringBootAsyncApplication.class, args);


Step 2 – Add @Async annotation to the method

The spring boot @Async annotation enables asynchronous execution of a method. The @Async annotation can be added to the method that has to be implemented asynchronously. The call method will not wait for the asynchronous method to be finished and will not wait for the asynchronous method to respond. Therefore the return data type of the @async method should be either void or future.


package com.yawintutor;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

public class TestService {

	public void print(int index) {
		int a = 1;
		int b = 0;
		int c = 0;
		c = a/b;
		System.out.println("C value is "+c);

Step 3 – Add Controller Class

Create a Rest controller class that invokes a service class that includes the @Async method. The controller class helps to invoke the asynchronous method. iThe example below shows a sample rest controller class that will be auto wired with a service class. The service method is invoked in one of the rest api requests.


package com.yawintutor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

public class TestController {

	TestService testService;
	@RequestMapping(value = "/welcome", method = RequestMethod.GET)
	public String welcome() {
		for(int i=0; i<10; i++) {
		return "success";


Step 4 – Implement AsyncConfigurer interface

Create a custom AsyncConfigurer class that includes two methods that have been implemented. The first method is used to initialise the ThreadPoolTaskExecutor. The ThreadPoolTaskExecutor specifies the size of the pool thread, the size of the queue, etc. The second method is used to configure AsyncUncaughtExceptionHandler. The default AsyncUncaughtExceptionHandler class implemented is SimpleAsyncUncaughtExceptionHandler. The AsyncUncaughtExceptionHandler custom class helps you to manage exceptions. 


package com.yawintutor;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

public class SpringAsyncConfiguration implements AsyncConfigurer {
	public Executor getAsyncExecutor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		return executor;

	public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
		return new AsyncUncaughtExceptionHandler() {

			public void handleUncaughtException(Throwable ex, Method method, Object... params) {
				System.out.println("Throwable Exception message : " + ex.getMessage());
				System.out.println("Method name                 : " + method.getName());
				for (Object param : params) {
					System.out.println("Parameter value             : " + param);
				System.out.println("stack Trace ");


Step 5 – Add pom.xml file

The pom.xml file should contain the spring boot web dependency. The spring boot web dependency will add the dependent jars for the web application. The default tomcat web server will be added to the spring boot application and will run in the default port 8080. The rest api can be invoked in the tomcat server.


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
		<relativePath/> <!-- lookup parent from repository -->
	<description>Spring Boot Project</description>






Step 6 – Run the application

The spring boot application should be started to invoke the url. Once the spring boot application is started, tomcat will run on port 8080. Open a browser and invoke the url http://localhost:8080/welcome. The browser window will show the “success” message. The exception handling will be shown in the console window.

Step 7 – Output

The console window will show the exception handling output . The console log will be shown as below.

Throwable Exception message : / by zero
Method name                 : print
Parameter value             : 0
stack Trace 
java.lang.ArithmeticException: / by zero
	at com.yawintutor.TestService.print(TestService.java:15)
	at com.yawintutor.TestService$$FastClassBySpringCGLIB$$284b10a4.invoke(<generated>)
	at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:771)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749)
	at org.springframework.aop.interceptor.AsyncExecutionInterceptor.lambda$invoke$0(AsyncExecutionInterceptor.java:115)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
	at java.lang.Thread.run(Thread.java:745)

Related Articles

Leave a Reply

Your email address will not be published. Required fields are marked *