Why async processing matters in Spring Boot - See It in Action

Why async processing matters

📖 Scenario: You are building a simple Spring Boot web service that handles user requests. Normally, the service processes each request one by one, which can cause delays when some tasks take longer. To improve user experience, you want to make the service handle tasks asynchronously, so it can start a task and continue working on others without waiting.

🎯 Goal: Build a Spring Boot application that demonstrates asynchronous processing by running a time-consuming task in the background while immediately responding to the user.

📋 What You'll Learn

Create a Spring Boot application with a REST controller

Add a method that simulates a long-running task

Configure asynchronous processing using @EnableAsync

Use @Async annotation to run the long task asynchronously

Return immediate response while the task runs in the background

💡 Why This Matters

🌍 Real World

Async processing helps web services handle slow tasks without making users wait, improving responsiveness and user experience.

💼 Career

Understanding async in Spring Boot is essential for backend developers building scalable and efficient web applications.

1

Create a REST controller with a long task method

Create a Spring Boot REST controller class named AsyncController with a method longTask that simulates a 5-second delay using Thread.sleep(5000) and returns the string "Task Completed".

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {
    
    // Your code here
}

Need a hint?

Use @RestController and @GetMapping("/longtask") annotations. Use Thread.sleep(5000) inside longTask method.

2

Enable asynchronous processing in the application

Create a configuration class named AsyncConfig and annotate it with @Configuration and @EnableAsync to enable asynchronous method execution.

Spring Boot

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
    // Your code here
}

Need a hint?

Use @Configuration and @EnableAsync annotations on the class.

3

Make the long task method asynchronous

Modify the longTask method in AsyncController to run asynchronously by adding the @Async annotation and changing its return type to CompletableFuture<String>. Wrap the result "Task Completed" in CompletableFuture.completedFuture().

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.scheduling.annotation.Async;
import java.util.concurrent.CompletableFuture;

@RestController
public class AsyncController {
    
    @Async
    @GetMapping("/longtask")
    public CompletableFuture longTask() {
        // Your code here
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

Need a hint?

Add @Async above the method and change return type to CompletableFuture<String>. Return the string wrapped in CompletableFuture.completedFuture().

4

Add a quick response endpoint to show async behavior

Add a new method quickResponse in AsyncController mapped to /quick that immediately returns the string "Quick Response" to demonstrate the app can respond without waiting for the long task.

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.scheduling.annotation.Async;
import java.util.concurrent.CompletableFuture;

@RestController
public class AsyncController {
    
    @Async
    @GetMapping("/longtask")
    public CompletableFuture longTask() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("Task Completed");
    }

    @GetMapping("/quick")
    public String quickResponse() {
        // Your code here
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

Need a hint?

Add a method with @GetMapping("/quick") that returns "Quick Response" immediately.