Practical Guide to Async APIs with CompletableFuture and Spring Boot

Unlock Asynchronous Power: Mastering Async APIs with CompletableFuture and Spring Boot!

Dive into the world of asynchronous APIs! This guide will show you how to leverage CompletableFuture in your Spring Boot applications for improved performance and responsiveness.

Learn practical techniques for handling concurrent operations and building non-blocking services.

Read More

Introduction to Asynchronous APIs

Asynchronous APIs are a crucial component of modern, scalable applications. They allow your services to handle multiple requests concurrently without blocking, leading to improved performance and a better user experience. In this guide, we'll explore how to implement asynchronous APIs using CompletableFuture in a Spring Boot environment.

Understanding CompletableFuture

CompletableFuture is a powerful class in Java's java.util.concurrent package that represents a future result of an asynchronous computation. It provides a rich set of methods for composing, combining, and handling asynchronous operations.

• Creating a CompletableFuture: You can create a CompletableFuture in several ways, including using CompletableFuture.supplyAsync(), CompletableFuture.runAsync(), and CompletableFuture.completedFuture().
• Handling Results: Methods like thenApply(), thenAccept(), and thenRun() allow you to process the result of a CompletableFuture asynchronously.
• Combining CompletableFutures: You can combine multiple CompletableFutures using methods like thenCombine(), thenCompose(), and allOf().
• Exception Handling: The exceptionally() and handle() methods provide ways to handle exceptions that occur during asynchronous computations.

Setting up a Spring Boot Project

To begin, create a new Spring Boot project using Spring Initializr or your IDE. Include the necessary dependencies, such as spring-boot-starter-web.

Implementing an Asynchronous API with CompletableFuture

Let's create a simple example of an asynchronous API that fetches data from an external service:

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

 import java.util.concurrent.CompletableFuture;

 @Service
 public class AsyncService {

  @Async
  public CompletableFuture<String> fetchDataAsync() {
   // Simulate fetching data from an external service
   return CompletableFuture.supplyAsync(() -> {
    try {
     Thread.sleep(2000); // Simulate a 2-second delay
    } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     throw new IllegalStateException(e);
    }
    return "Data from external service";
   });
  }
 }
 

In this code:

• The @Async annotation tells Spring to execute the fetchDataAsync() method asynchronously in a separate thread.
• CompletableFuture.supplyAsync() creates a new CompletableFuture that will execute the provided lambda expression asynchronously.
• We simulate a delay using Thread.sleep() to mimic the time it takes to fetch data from an external service.

Creating a Controller

Now, let's create a controller to expose the asynchronous API:

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

 import java.util.concurrent.CompletableFuture;

 @RestController
 public class AsyncController {

  @Autowired
  private AsyncService asyncService;

  @GetMapping("/async-data")
  public CompletableFuture<String> getAsyncData() {
   return asyncService.fetchDataAsync();
  }
 }
 

In this code:

• The /async-data endpoint returns a CompletableFuture<String>.
• Spring will automatically handle the asynchronous nature of the CompletableFuture and return the result to the client when it becomes available.

Configuration

To enable asynchronous method execution, add @EnableAsync to your Spring Boot application class:

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

 @SpringBootApplication
 @EnableAsync
 public class AsyncApplication {

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

Testing the Asynchronous API

Run your Spring Boot application and access the /async-data endpoint. You'll notice that the request returns almost immediately, and the data is fetched asynchronously in the background. The client will receive the data once it's available.

Advanced Usage: Combining CompletableFutures

You can combine multiple CompletableFutures to perform more complex asynchronous operations. For example:

 CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result 1");
 CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result 2");

 CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(future1, future2);

 combinedFuture.thenRun(() -> {
  String result1 = future1.join();
  String result2 = future2.join();
  System.out.println("Combined Result: " + result1 + ", " + result2);
 });
 

In this code:

• CompletableFuture.allOf() creates a new CompletableFuture that completes when all the provided CompletableFutures have completed.
• join() blocks until the CompletableFuture completes and returns the result. It is generally used when the main thread needs the result of asynchronous operations.

Remember to handle exceptions properly when working with asynchronous operations. Use the exceptionally() or handle() methods to catch and handle any exceptions that may occur.

Conclusion

By following this guide, you’ve successfully implemented asynchronous APIs using CompletableFuture in a Spring Boot application, enabling improved performance and responsiveness. Happy coding!

Show your love, follow us javaoneworld