Paralel GET istekleri nasıl gönderilir ve sonuç yanıtları beklenir?

Question

Yaygın olarak gösterildiği gibi 5 alma isteği göndermek için spring mvc 3.2.2 içinde apache http istemcisini kullanıyorum.

Tüm bu eşzamansız olarak (paralel olarak) nasıl gönderebilir ve tüm GET isteklerinden ayrıştırılmış bir yük dizesi döndürmek için isteklerin geri dönmesini bekleyebilir miyim? Sadece genel olarak

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"; 

} 

Answer 1

, bir Runnable veya java.util.concurrent.Callable işin birimleri saklanması ve java.util.concurrent.Executor (veya org.springframework.core.task.TaskExecutor) üzerinden bunları yürütmek gerekiyor. Bu, her bir iş biriminin, genellikle eşzamansız bir şekilde (Executor'un uygulanmasına bağlı olarak) ayrı ayrı yürütülmesine izin verir. Bu kod test edilmediğini

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()); 
     } 
    } 
} 

Not:

Yani Özgül sorun, böyle bir şey yapabilirdi.

Executor uygulamanız için Spring's TaskExecutor ve task:executor namespace'a bakın. Muhtemelen bu kullanım durumu için yeniden kullanılabilir bir havuz havuzu (her seferinde yeni bir iplik oluşturmak yerine) istiyorsunuz.

Answer 2

AsyncHttpClient'i kullanmalısınız. İstediğiniz sayıda istekte bulunabilirsiniz ve yanıt alındığında size bir geri arama yapar. Ne kadar bağlantı oluşturabileceğini yapılandırabilirsiniz. Tüm iş parçacığı kitaplık tarafından işlenir, bu nedenle iş parçacıklarını kendiniz yönetmek daha kolaydır.

buraya bir göz bir örneği inceleyelim: https://github.com/AsyncHttpClient/async-http-client