Exception handling in async in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when an exception is thrown inside an @Async method without a custom AsyncUncaughtExceptionHandler?

Consider a Spring Boot service method annotated with @Async that throws a runtime exception. What is the default behavior if no custom AsyncUncaughtExceptionHandler is configured?

Spring Boot

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

@Service
public class AsyncService {
    @Async
    public void asyncMethod() {
        throw new RuntimeException("Error in async method");
    }
}

A The exception is silently ignored without any logging or notification.

B The exception is propagated back to the caller thread and must be caught there.

C The application crashes immediately due to the uncaught exception in the async thread.

D The exception is logged by Spring's SimpleAsyncUncaughtExceptionHandler and does not propagate to the caller thread.

💡 Hint

Think about how Spring handles exceptions in void async methods by default.

By default, Spring uses SimpleAsyncUncaughtExceptionHandler which logs exceptions thrown from @Async methods that return void. The exception does not propagate to the caller thread.

📝 Syntax

intermediate

Which method signature correctly allows exception handling for an async method returning a Future?

You want to handle exceptions thrown in an async method that returns a CompletableFuture<String>. Which method signature is correct to enable catching exceptions in the caller thread?

A

@Async
public CompletableFuture<String> asyncMethod() {
    return CompletableFuture.supplyAsync(() -> {
        if(true) throw new RuntimeException("Error");
        return "Done";
    });
}

B

@Async
public void asyncMethod() throws Exception {
    throw new RuntimeException("Error");
}

C

@Async
public CompletableFuture<String> asyncMethod() {
    throw new RuntimeException("Error");
}

D

@Async
public String asyncMethod() {
    throw new RuntimeException("Error");
}

💡 Hint

Think about how to return a Future that can carry exceptions asynchronously.

Returning a CompletableFuture allows exceptions to be captured and handled asynchronously by the caller. Throwing exceptions directly in the method body without wrapping them in a Future will not propagate exceptions properly.

🔧 Debug

advanced

Why does this custom AsyncUncaughtExceptionHandler not log exceptions as expected?

Given the following custom AsyncUncaughtExceptionHandler, exceptions thrown in async void methods are not logged. What is the likely cause?

Spring Boot

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component
public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // Missing logging implementation
    }
}

A The method signature is incorrect and does not override the interface method.

B The @Component annotation is missing, so Spring does not detect the handler.

C The handler does not log or print the exception, so exceptions appear unlogged.

D The handler must extend SimpleAsyncUncaughtExceptionHandler to work properly.

💡 Hint

Check what the handler does inside the overridden method.

The handler method is empty and does not log or handle the exception, so exceptions are effectively ignored.

🧠 Conceptual

advanced

How can you globally configure a custom AsyncUncaughtExceptionHandler in Spring Boot?

Which approach correctly sets a global custom AsyncUncaughtExceptionHandler for all @Async methods in a Spring Boot application?

A Implement AsyncConfigurer in a @Configuration class and override getAsyncUncaughtExceptionHandler() to return your handler bean.

B Annotate your handler class with @AsyncUncaughtExceptionHandler and Spring auto-detects it.

C Register your handler as a @Bean of type AsyncUncaughtExceptionHandler in any @Configuration class.

D Add @ExceptionHandler annotation on your handler class to catch async exceptions globally.

💡 Hint

Think about how Spring Boot allows configuring async behavior globally.

Implementing AsyncConfigurer and overriding getAsyncUncaughtExceptionHandler() is the standard way to globally set a custom handler for async exceptions.

❓ state_output

expert

What is the output when an exception is thrown inside an async method returning CompletableFuture and handled with exceptionally()?

Consider this Spring Boot async method and caller code. What will be printed?

Spring Boot

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;

@Service
public class AsyncService {
    @Async
    public CompletableFuture<String> asyncMethod() {
        return CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Async error");
        });
    }
}

// Caller code
AsyncService service = new AsyncService();
service.asyncMethod()
    .exceptionally(ex -> {
        System.out.println("Caught: " + ex.getMessage());
        return "Recovered";
    })
    .thenAccept(result -> System.out.println("Result: " + result));

A

Caught: java.lang.RuntimeException: Async error
Result: Recovered

B

Caught: Async error
Result: Recovered

C No output because exceptions in async are swallowed silently

D Result: Recovered

💡 Hint

Check how the exception message is accessed inside exceptionally().

The exceptionally block catches the RuntimeException. ex.getMessage() returns "Async error". So it prints "Caught: Async error" and then "Result: Recovered".

Practice

1. What is the main purpose of using AsyncUncaughtExceptionHandler in Spring Boot asynchronous methods?

easy

A. To handle exceptions thrown by async methods that return void

B. To automatically retry failed async methods

C. To log successful completion of async methods

D. To convert async methods into synchronous ones

Solution

1. Step 1: Understand async method return types

   Async methods returning void cannot return exceptions directly to the caller.

2. Step 2: Role of AsyncUncaughtExceptionHandler

   This handler catches exceptions from void async methods to prevent app crashes.

3. Final Answer:

   To handle exceptions thrown by async methods that return void -> Option A

4. Quick Check:

   Void async exceptions need AsyncUncaughtExceptionHandler [OK]

Hint: Void async methods need special exception handler [OK]

Common Mistakes:

• Thinking AsyncUncaughtExceptionHandler retries failed tasks
• Assuming it handles exceptions for Future-returning methods
• Confusing it with synchronous exception handling

2. Which of the following is the correct way to declare an async method that returns a result and handles exceptions properly?

easy

A. @Async public void processData() throws Exception { ... }

B. @Async public Future<String> fetchData() throws InterruptedException { return null; }

C. @Async public String fetchData() { return "data"; }

D. @Async public CompletableFuture<String> fetchData() { return CompletableFuture.completedFuture("data"); }

Solution

1. Step 1: Identify async method return types

   Async methods returning results should return Future or CompletableFuture to handle async results and exceptions.

2. Step 2: Check method signatures

   @Async public CompletableFuture<String> fetchData() { return CompletableFuture.completedFuture("data"); } returns CompletableFuture<String> correctly and does not declare checked exceptions, which is proper for async methods.

3. Final Answer:

   @Async public CompletableFuture<String> fetchData() { return CompletableFuture.completedFuture("data"); } -> Option D

4. Quick Check:

   Async methods with results use CompletableFuture [OK]

Hint: Async methods with results return CompletableFuture or Future [OK]

Common Mistakes:

• Declaring async methods with void when result is needed
• Throwing checked exceptions directly in async methods
• Returning raw types instead of Future or CompletableFuture

3. Given the following async method, what will be the output if an exception occurs inside the CompletableFuture?

medium

A. The exception is caught inside exceptionally and a fallback value is returned

B. The exception is automatically logged and the method returns null

C. The exception crashes the application immediately

D. The exception is ignored and the method returns normally

Solution

1. Step 1: Analyze CompletableFuture exception handling

   The exceptionally method handles exceptions and provides fallback values.

2. Step 2: Understand method behavior on exception

   If an exception occurs, exceptionally returns the fallback value instead of propagating the exception.

3. Final Answer:

   The exception is caught inside exceptionally and a fallback value is returned -> Option A

4. Quick Check:

   CompletableFuture.exceptionally handles exceptions [OK]

Hint: Use exceptionally to catch async exceptions with fallback [OK]

Common Mistakes:

• Assuming exceptions crash the app without handling
• Expecting null return instead of fallback value
• Ignoring the need for exceptionally or handle methods

4. Identify the error in this async method that uses Future and explain why exceptions are not handled properly:

@Async
public Future<String> loadData() {
  throw new RuntimeException("Failed");
}

medium

A. Future cannot be used with @Async methods

B. Method should not be annotated with @Async when returning Future

C. Throwing exception directly in async method causes it to be lost; should return Future with exception

D. RuntimeException must be caught inside the method before throwing

Solution

1. Step 1: Understand async method exception handling

   Exceptions thrown directly in async methods returning Future are not propagated properly.

2. Step 2: Proper way to handle exceptions in Future

   Return a Future that completes exceptionally instead of throwing directly.

3. Final Answer:

   Throwing exception directly in async method causes it to be lost; should return Future with exception -> Option C

4. Quick Check:

   Throwing exceptions directly in async Future methods is incorrect [OK]

Hint: Return Future with exception, don't throw directly in async methods [OK]

Common Mistakes:

• Throwing exceptions directly in async methods returning Future
• Ignoring exception handling in async methods
• Misusing @Async annotation with incompatible return types

5. You have an async method returning CompletableFuture<String> that may throw exceptions. How can you combine exception handling and fallback logic so the caller always gets a valid string without blocking?

hard

A. Use get() on CompletableFuture and catch exceptions synchronously

B. Use handle method on CompletableFuture to catch exceptions and provide fallback value

C. Wrap the async method call in a try-catch block in the caller thread

D. Declare the async method to throw checked exceptions and let caller handle them

Solution

1. Step 1: Understand async exception handling with CompletableFuture

   The handle method allows processing both result and exception without blocking.

2. Step 2: Implement fallback logic in handle

   Inside handle, check if exception is present and return fallback string if so.

3. Final Answer:

   Use handle method on CompletableFuture to catch exceptions and provide fallback value -> Option B

4. Quick Check:

   CompletableFuture.handle combines result and exception handling [OK]

Hint: Use CompletableFuture.handle for async fallback without blocking [OK]

Common Mistakes:

• Blocking caller thread with get() defeats async purpose
• Trying to catch exceptions outside async context
• Declaring checked exceptions in async methods unnecessarily