Comment utiliser AsyncRestTemplate pour effectuer plusieurs appels simultanément?

Si vous n'avez pas à utiliser "AsyncRestTemplate' je suggère d'utiliser RxJava à la place. RxJava zip opérateur est ce que vous cherchez. Code de vérification ci-dessous:

private rx.Observable<String> externalCall(String url, int delayMilliseconds) {
    return rx.Observable.create(
            subscriber -> {
                try {
                    Thread.sleep(delayMilliseconds); //simulate long operation
                    subscriber.onNext("response(" + url + ") ");
                    subscriber.onCompleted();
                } catch (InterruptedException e) {
                    subscriber.onError(e);
                }
            }
    );
}

public void callServices() {
    rx.Observable<String> call1 = externalCall("url1", 1000).subscribeOn(Schedulers.newThread());
    rx.Observable<String> call2 = externalCall("url2", 4000).subscribeOn(Schedulers.newThread());
    rx.Observable<String> call3 = externalCall("url3", 5000).subscribeOn(Schedulers.newThread());
    rx.Observable.zip(call1, call2, call3, (resp1, resp2, resp3) -> resp1 + resp2 + resp3)
            .subscribeOn(Schedulers.newThread())
            .subscribe(response -> System.out.println("done with: " + response));
}

Toutes les demandes de services externes seront exécutées dans des threads séparés, lors du dernier appel sera fini de la transformation de la fonction( dans l'exemple simple concaténation de chaîne) sera appliquée et le résultat (chaîne concaténée) sera emmited de 'zip' observable.

Vous pouvez utiliser CompletableFuture classe (javadoc).

1. Transformer vos appels en CompletableFuture. Par exemple.

   final CompletableFuture<ResponseEntity<String>> cf = CompletableFuture.supplyAsync(() -> {
       try {
           return future.get();
       } catch (InterruptedException | ExecutionException e) {
           throw new RuntimeException(e);
       }
   });

2. Prochain appel CompletableFuture::allOf méthode avec vos 3 nouvellement créé complétées à terme.

3. Appel join() méthode sur le résultat. Après que la complétées avenir est résolu, vous pouvez obtenir les résultats de chaque complétées avenir que vous avez créé à l'étape 3.

Je ne pense pas que toutes les réponses précédentes de réaliser le parallélisme. Le problème avec @diginoise réponse est qu'il ne fait pas les atteindre parallélisme. Dès que nous appelons getnous sommes bloqués. Considérer que les appels sont vraiment lents tels que future1 prend 3 secondes pour terminer, future2 2 secondes et future3 3 secondes. Avec 3 get appelle l'un après l'autre, nous nous retrouvons en attente 3 + 2 + 3 = 8 secondes.
@Vikrant Kashyap réponse blocs ainsi sur while (!(future1 .isDone() && future2.isDone() && future3.isDone())). En plus de la while boucle est assez laid à la recherche morceau de code pour les 3 contrats à terme, que si vous avez plus? @lkz réponse utilise une technologie différente que vous avez demandé, et même alors, je ne suis pas sûr si zip va faire le travail. De Observables Javadoc:

zip applique cette fonction dans un ordre strict, de sorte que le premier élément
émis par le nouveau Observable sera le résultat de la fonction
appliqué sur le premier élément émis par chaque source Observables;
le deuxième élément émis par le nouveau Observable sera le résultat de
la fonction appliquée à la deuxième question émise par chacun de ces
Observables; et ainsi de suite.

En raison du Printemps popularité, ils essaient très dur de maintenir une compatibilité ascendante et en agissant de la sorte, parfois faire des compromis avec l'API. AsyncRestTemplate les méthodes retournant ListenableFuture est un de ces cas. Si ils se sont engagés à Java 8+, CompletableFuture pourrait être utilisé à la place. Pourquoi? Puisque nous ne traitant avec des pools de threads directement, nous n'avons pas une bonne façon de savoir si tous les ListenableFutures avez terminé. CompletableFuture a un allOf méthode qui crée une nouvelle CompletableFuture qui est terminé lorsque toutes les CompletableFutures complète. Puisque nous n'avons pas que dans ListenableFuturenous aurons à improviser.
Je n'ai pas compilé le code suivant mais il devrait être clair ce que je suis en train de faire. Je suis à l'aide de Java 8 parce que c'est la fin de l'année 2016.

//Lombok FTW
@RequiredArgsConstructor
public final class CounterCallback implements ListenableFutureCallback<ResponseEntity<String>> {
  private final LongAdder adder;

  public void onFailure(Throwable ex) {
    adder.increment();
  }
  public void onSuccess(ResponseEntity<String> result) {
    adder.increment();
  }
}

ListenableFuture<ResponseEntity<String>> f1 = asyncRestTemplate
        .getForEntity(url1, String.class);
f1.addCallback(//);
//more futures

LongAdder adder = new LongAdder();
ListenableFutureCallback<ResponseEntity<String>> callback = new CounterCallback(adder);
Stream.of(f1, f2, f3)
  .forEach {f -> f.addCallback(callback)}

for (int counter = 1; adder.sum() < 3 && counter < 10; counter++) {
  Thread.sleep(1000);
}
//either all futures are done or we're done waiting
Map<Boolean, ResponseEntity<String>> futures = Stream.of(f1, f2, f3)
  .collect(Collectors.partitioningBy(Future::isDone));

Maintenant, nous avons un Map pour qui futures.get(Boolean.TRUE) va nous donner tous les contrats à terme qui ont complété et futures.get(Boolean.FALSE) va nous donner à ceux qui n'ont pas. Nous vous souhaitez annuler ceux qui n'ont pas complète.

Ce code n'est quelques choses qui sont importantes à la programmation parallèle:

1. Il ne bloque pas.
2. Elle limite le fonctionnement de certains maximale autorisée de temps.
3. Il sépare clairement de succès et d'échec des cas.