Asynchronous API Calls: Spring Boot, Feign, and Spring @Async
Learn how to make asynchronous API calls from Spring Boot using Spring Cloud OpenFeign and Spring @Async to reduce the response time to that of a one-page call.
Join the DZone community and get the full member experience.
Join For FreeThe requirement was to hit an eternal web endpoint and fetch some data and apply some logic to it, but the external API was super slow and the response time grew linearly with the number of records fetched. This called for the need to parallelize the entire API call in chunks/pages and aggregate the data.
Our synchronous FeignClient:
@FeignClient(url = "${external.resource.base}", name = "external")
public interface ExternalFeignClient {
@GetMapping(value = "${external.resource.records}", produces = "application/json")
ResponseWrapper<Record> getRecords(@RequestHeader Map<String, String> header,
@RequestParam Map<String, String> queryMap,
@RequestParam("limit") Integer limit,
@RequestParam("offset") Integer offset);
}Let's prepare the configuration for the async framework:
@EnableAsync
@Configuration
public class AsyncConfig {
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5); // set the core pool size
executor.setMaxPoolSize(10); // max pool size
executor.setThreadNamePrefix("ext-async-"); // give an optional name to your threads
executor.initialize();
return executor;
}
} Now to make the feign clients work in asynchronous mode, we need to wrap them with an async wrapper returning a CompletableFuture.
@Service
public class ExternalFeignClientAsync {
@Awtowired
private ExternalFeignClient externalFeignClient;
@Async
CompletableFuture<ResponseWrapper<Record>> getRecordsAsync(Map<String, String> header,
Map<String, String> header,
Integer limit,
Integer offset){
CompletableFuture.completedFuture(externalFeignClient.getRecords(header,header,limit,offset));
}
}Now our async feign client is ready with a paginating option using the limit and offset. Let's suppose we know or we figure out by some means (out of scope for this article), the total number of records available. We can then consider a page size for each call and figure out how many API calls we need to make and fire them in parallel.
@Service
public class ExternalService {
@Autowired
private ExternalFeignClientAsync externalFeignClientAsync;
List<Record> getAllRecords(){
final AtomicInteger offset = new AtomicInteger();
int pageSize = properties.getPageSize(); // set this as you wish
int batches = (totalCount / pageSize) + (totalCount % pageSize > 0 ? 1 : 0);
return IntStream.range(0, batches)
.parallel()
.mapToObj(i -> {
final int os = offset.getAndAdd(pageSize);
return externalFeignClientAsync.getRecordsAsync(requestHeader, queryMap, fetchSize, os);
})
.map(CompletableFuture::join)
.map(ResponseWrapper::getItems)
.flatMap(List::stream)
.toList();
}
}
And voila!
The entire API call is now broken down into pages and fired asynchronously, with the overall response time reduced to the time taken by a one-page call.
Opinions expressed by DZone contributors are their own.
Comments