Implémentation de Completable Future of Java 8

Completable-Future est utilisé pour la programmation asynchrone en Java. La programmation asynchrone signifie écrire non bloquant code en exécutant une tâche sur un thread distinct du thread principal de l’application et en notifiant le thread principal de sa progression, de son achèvement ou de son échec.

De cette façon, le thread principal ne bloque pas/n’attend pas l’achèvement de la tâche et il peut exécuter d’autres tâches en parallèle.

Avoir ce type de parallélisme améliore considérablement les performances de vos programmes.

CompletableFuture est une extension de l’API Future de Java qui a été introduite dans Java 5.

Un Future est utilisé comme référence au résultat d’un calcul asynchrone. Il fournit une méthode isDone() pour vérifier si le calcul est fait ou non, et une méthode get() pour récupérer le résultat du calcul lorsqu’il est fait.

Les API SpringBoot peuvent tirer parti de la concurrence dans sa logique métier à l’aide des annotations Async et de la classe java.util.concurrent.CompletableFuture. Cela permettrait à l’application d’exécuter les méthodes annotées dans un pool de threads séparé, de manière asynchrone chaque fois qu’elles sont appelées. Le thread principal qui effectue l’appel ne serait pas bloqué pour chacun de ces appels. Comment l’activer et l’utiliser dans un exemple d’API ? Continuer à lire.

Les étapes clés derrière l’activation des méthodes Async dans Spring sont ici :

1. Activez le traitement asynchrone dans Spring Boot en annotant la classe Spring Boot Application avec @EnableAsync.

AsyncConfiguration.java

@Configuration @EnableAsync classe publique AsynchConfiguration { @Bean(nom = « asyncExecutor ») exécuteur public asyncExecutor() { ThreadPoolTaskExecutor exécuteur = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(3); exécuteur.setMaxPoolSize(3); executor.setQueueCapacity(100); executor.setThreadNamePrefix(« AsynchThread-« ); exécuteur.initialize(); exécuteur testamentaire ; } }

2. Créez un ThreadPoolExecutor pour exécuter des méthodes asynchrones dans des threads séparés.

@Configuration

@EnableAsync

la classe publique AsyncMethodConfigurer implémente AsyncConfigurer{

@Haricot

public Executor taskExecutor() {

ThreadPoolTaskExecutor exécuteur = new ThreadPoolTaskExecutor();

executor.setCorePoolSize(4);

executor.setMaxPoolSize(5);

executor.setQueueCapacity(500);

executor.setThreadNamePrefix(« AsyncGetUserInfo-« );

exécuteur.initialize();

exécuteur testamentaire ;

}

3. Annotez les méthodes qui doivent être exécutées dans des threads séparés avec @Async.

@Async(« asyncExecutor »)

public CompletableFuture methodOne() lance InterruptedException {

//code

}

4. garder le type de retour de la méthode enveloppé dans : CompletableFuture

@Async

public CompletableFuture findUser(String user) {

5. Renvoyez le résultat comme suit : passez le bloc d’exception. votre try{ }catch ne fonctionnerait pas ici.

return cmpletableFuture.completedFuture(results).exceptionally((throwable -> {

logger.error( » « +jetable);

renvoie nul ;

}));

6. Échantillon de gestionnaire :-

@RequestMapping(valeur = « /async-poc/userinfo », méthode = RequestMethod.GET)

@ResponseBody

public List getAsyncUserInfo(@RequestBody List userList) lance InterruptedException, ExecutionException {

List responseList =new LinkedList();

//Étape 1 : Collecter la liste des entrées pour les méthodes asynchrones

List userNameList = userList.stream().map(User::getName)

.collect(Collectors.toList());

//Étape 2 : appeler les méthodes asynchrones

List futuresList =userNameList.stream().map(asyncUserInfoService::findUser)

.collect(Collectors.toList());

//Étape 3 : Obtenez tous les résultats et combinez-les pour renvoyer l’entité de réponse HTTP

futuresList.stream().map(CompletableFuture::join).collect(Collectors.toList());

for (CompletableFuture complétableFuture : futuresList) {

essayer {

log.info(« – > « +completableFuture.get());

responseList.add((Utilisateur)completableFuture.get());

} catch (exception interrompue e) {

log.error(ex.getMessage());

} catch (ExecutionException e) {

log.error(ex.getMessage());

} capture (Exception e) {

log.error(ex.getMessage());

}

}

renvoie la liste de réponses ;

}

Les classes/méthodes clés utilisées à partir du package de concurrence Java : –

1. CompletableFuture – Classe que nous utiliserons principalement ici.
2. exceptionnellement() ,handle(), whenComplete() – appelé après l’achèvement de votre méthode. conservez ici toute gestion d’erreur.
   1. note : handle() et whenComplete ont accès au résultat de réussite (T) et à l’échec (Throwable) du futur complétable en tant qu’arguments d’entrée. D’autre part, la méthode exceptionnellement() n’a accès qu’à l’échec en tant qu’argument d’entrée.
3. tous
4. – Renvoie une nouvelle CF qui est terminée lorsque toutes les CF données sont terminées. Utilisé par le thread principal pour attendre que les threads asynchrones soient passés, soient terminés et avancent avec le traitement d’autres choses.

join() – pour recevoir le résultat de chaque appel de méthode. votre objet de retour réel qui était auparavant enveloppé dans CF.

1. RÉFÉRENCES:

spring.io/guides2.