Comment envoyer des requêtes GET parallèles et attendre les réponses de résultat?

Je suis en utilisant apache http client dans un délai de spring mvc 3.2.2 envoyer 5 demandes de façon synchrone, comme illustré.

Comment puis-je envoyer tous ces asynchrone (en parallèle) et d'attente pour les demandes de retour pour retourner un analysée de la charge utile de la chaîne de toutes les requêtes GET?

public String myMVCControllerGETdataMethod()
{
   //Send 1st request 
   HttpClient httpclient = new DefaultHttpClient();
   HttpGet httpget = new HttpGet("http://api/data?type=1");   
   ResponseHandler<String> responseHandler = new BasicResponseHandler();
   String responseBody = httpclient.execute(httpget, responseHandler);

   //Send 2st request 
   HttpClient httpclient2 = new DefaultHttpClient();
   HttpGet httpget2 = new HttpGet("http://api/data?type=2");   
   ResponseHandler2<String> responseHandler2 = new BasicResponseHandler();
   String responseBody2 = httpclient.execute(httpget, responseHandler2);

   //o o o more gets here

   //Perform some work here...and wait for all requests to return
   //Parse info out of multiple requests and return
   String results = doWorkwithMultipleDataReturned();

   model.addAttribute(results, results);
   return "index";

}

source d'informationauteur JaJ

  1. 12

    Juste en général, vous avez besoin pour encapsuler vos unités de travail dans un Runnable ou java.util.concurrent.Callable et de les exécuter via java.util.concurrent.Executor (ou org.springframework.core.task.TaskExecutor). Cela permet à chaque unité de travail à être exécuté séparément, généralement de façon asynchrone (en fonction de la mise en œuvre de la Executor).

    Donc, pour votre problème spécifique, vous pourriez faire quelque chose comme ceci:

    import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executor;
import java.util.concurrent.FutureTask;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.DefaultHttpClient;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class MyController {
//inject this
private Executor executor;
@RequestMapping("/your/path/here")
public String myMVCControllerGETdataMethod(Model model) {
//define all async requests and give them to injected Executor
List<GetRequestTask> tasks = new ArrayList<GetRequestTask>();
tasks.add(new GetRequestTask("http://api/data?type=1", this.executor));
tasks.add(new GetRequestTask("http://api/data?type=2", this.executor));
//...
//do other work here
//...
//now wait for all async tasks to complete
while(!tasks.isEmpty()) {
for(Iterator<GetRequestTask> it = tasks.iterator(); it.hasNext();) {
GetRequestTask task = it.next();
if(task.isDone()) {
String request = task.getRequest();
String response = task.getResponse();
//PUT YOUR CODE HERE
//possibly aggregate request and response in Map<String,String>
//or do something else with request and response
it.remove();
}
}
//avoid tight loop in "main" thread
if(!tasks.isEmpty()) Thread.sleep(100);
}
//now you have all responses for all async requests
//the following from your original code
//note: you should probably pass the responses from above
//to this next method (to keep your controller stateless)
String results = doWorkwithMultipleDataReturned();
model.addAttribute(results, results);
return "index";
}
//abstraction to wrap Callable and Future
class GetRequestTask {
private GetRequestWork work;
private FutureTask<String> task;
public GetRequestTask(String url, Executor executor) {
this.work = new GetRequestWork(url);
this.task = new FutureTask<String>(work);
executor.execute(this.task);
}
public String getRequest() {
return this.work.getUrl();
}
public boolean isDone() {
return this.task.isDone();
}
public String getResponse() {
try {
return this.task.get();
} catch(Exception e) {
throw new RuntimeException(e);
}
}
}
//Callable representing actual HTTP GET request
class GetRequestWork implements Callable<String> {
private final String url;
public GetRequestWork(String url) {
this.url = url;
}
public String getUrl() {
return this.url;
}
public String call() throws Exception {
return new DefaultHttpClient().execute(new HttpGet(getUrl()), new BasicResponseHandler());
}
}
}

    Noter que ce code n'a pas été testé.

    Pour votre Executor mise en œuvre, découvrez Le printemps TaskExecutor et tâche:exécuteur testamentaire de l'espace de noms. Vous voudrez probablement une réutilisables pool de threads pour ce cas d'utilisation (au lieu de créer un nouveau thread à chaque fois).

  2. 13

    Vous devez utiliser AsyncHttpClient. Vous pouvez faire un certain nombre de demandes, et il fera un appel de nouveau à vous quand il obtient une réponse. Vous pouvez configurer le nombre de connexions qu'il peut créer. Tous le filetage est gérée par la bibliothèque, de sorte qu'il est beaucoup plus facile que de gérer les threads de vous-même.

    prendre un coup d'oeil un exemple ici: https://github.com/AsyncHttpClient/async-http-client

  3. 0

    Pour l'exécution en parallèle de la demande multiple avec un seul HttpClient instance.

    configurer PoolingHttpClientConnectionManager pour l'exécution en parallèle.

    HttpClientBuilder builder = HttpClientBuilder.create();
PlainConnectionSocketFactory plainConnectionSocketFactory = new PlainConnectionSocketFactory();
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", plainConnectionSocketFactory).build();
PoolingHttpClientConnectionManager ccm = new PoolingHttpClientConnectionManager(registry);
ccm.setMaxTotal(BaseConstant.CONNECTION_POOL_SIZE); //For Example : CONNECTION_POOL_SIZE = 10 for 10 thread parallel execution
ccm.setDefaultMaxPerRoute(BaseConstant.CONNECTION_POOL_SIZE);
builder.setConnectionManager((HttpClientConnectionManager) ccm);
HttpClient objHttpClient = builder.build();