如何向不同的Web服務發送多個異步請求？

Question

我需要向多個不同的Web服務發送多個請求並接收結果。 問題是，如果我逐個發送請求，只要我需要單獨發送和處理所有請求。

我想知道如何立即發送所有請求並收到結果。

如下面的代碼所示，我有三個主要方法，每個方法都有自己的子方法。 每個子方法向其關聯的Web服務發送請求並接收結果;因此，例如，為了接收Web服務9的結果，我必須等到1到8的所有Web服務都完成，這需要很長時間才能發送所有請求一個接一個，並收到他們的結果。

如下所示，沒有任何方法或子方法彼此相關，所以我可以將它們全部調用並以任何順序接收它們的結果，唯一重要的是接收每個子方法的結果並填充它們相關列表。

private List<StudentsResults> studentsResults = new ArrayList();
private List<DoctorsResults> doctorsResults = new ArrayList();
private List<PatientsResults> patientsResults = new ArrayList();

main (){
    retrieveAllLists();
}

retrieveAllLists(){

     retrieveStudents();
     retrieveDoctors();
     retrievePatients();
}

retrieveStudents(){

    this.studentsResults = retrieveStdWS1();   //send request to Web Service 1 to receive its  list of students
    this.studentsResults = retrieveStdWS2();  //send request to Web Service 2 to receive its  list of students
    this.studentsResults = retrieveStdWS3(); //send request to Web Service 3 to receive its  list of students

}

retrieveDoctors(){

   this.doctorsResults = retrieveDocWS4();   //send request to Web Service 4 to receive its list of doctors
   this.doctorsResults = retrieveDocWS5();  //send request to Web Service 5 to receive its  list of doctors
   this.doctorsResults = retrieveDocWS6(); //send request to Web Service 6 to receive its  list of doctors

}

retrievePatients(){

   this.patientsResults = retrievePtWS7();   //send request to Web Service 7 to receive its list of patients
   this.patientsResults = retrievePtWS8();  //send request to Web Service 8 to receive its list of patients
   this.patientsResults = retrievePtWS9(); //send request to Web Service 9 to receive its list of patients

}

Answer 1

這是一種簡單的fork-join方法，但為了清楚起見，您可以啟動任意數量的線程並在以后檢查結果，例如此方法。

    ExecutorService pool = Executors.newFixedThreadPool(10);
    List<Callable<String>> tasks = new ArrayList<>();
    tasks.add(new Callable<String>() {
        public String call() throws Exception {
            Thread.sleep((new Random().nextInt(5000)) + 500);
            return "Hello world";
        }

    });
    List<Future<String>> results = pool.invokeAll(tasks);

    for (Future<String> future : results) {
        System.out.println(future.get());
    }
    pool.shutdown();

更新，完成：

這是一個冗長但可行的解決方案。 我是專門寫的，並沒有編譯它。 鑒於三個列表具有不同的類型，並且WS方法是個體的，它不是真正的模塊化，而是嘗試使用您最好的編程技能，看看您是否可以更好地模塊化它。

    ExecutorService pool = Executors.newFixedThreadPool(10);

    List<Callable<List<StudentsResults>>> stasks = new ArrayList<>();
    List<Callable<List<DoctorsResults>>> dtasks = new ArrayList<>();
    List<Callable<List<PatientsResults>>> ptasks = new ArrayList<>();

    stasks.add(new Callable<List<StudentsResults>>() {
        public List<StudentsResults> call() throws Exception {
            return retrieveStdWS1();
        }

    });
    stasks.add(new Callable<List<StudentsResults>>() {
        public List<StudentsResults> call() throws Exception {
            return retrieveStdWS2();
        }

    });
    stasks.add(new Callable<List<StudentsResults>>() {
        public List<StudentsResults> call() throws Exception {
            return retrieveStdWS3();
        }

    });

    dtasks.add(new Callable<List<DoctorsResults>>() {
        public List<DoctorsResults> call() throws Exception {
            return retrieveDocWS4();
        }

    });
    dtasks.add(new Callable<List<DoctorsResults>>() {
        public List<DoctorsResults> call() throws Exception {
            return retrieveDocWS5();
        }

    });
    dtasks.add(new Callable<List<DoctorsResults>>() {
        public List<DoctorsResults> call() throws Exception {
            return retrieveDocWS6();
        }

    });

    ptasks.add(new Callable<List<PatientsResults>>() {
        public List<PatientsResults> call() throws Exception {
            return retrievePtWS7();
        }

    });
    ptasks.add(new Callable<List<PatientsResults>>() {
        public List<PatientsResults> call() throws Exception {
            return retrievePtWS8();
        }

    });
    ptasks.add(new Callable<List<PatientsResults>>() {
        public List<PatientsResults> call() throws Exception {
            return retrievePtWS9();
        }

    });

    List<Future<List<StudentsResults>>> sresults = pool.invokeAll(stasks);
    List<Future<List<DoctorsResults>>> dresults = pool.invokeAll(dtasks);
    List<Future<List<PatientsResults>>> presults = pool.invokeAll(ptasks);

    for (Future<List<StudentsResults>> future : sresults) {
       this.studentsResults.addAll(future.get());
    }
    for (Future<List<DoctorsResults>> future : dresults) {
       this.doctorsResults.addAll(future.get());
    }
    for (Future<List<PatientsResults>> future : presults) {
       this.patientsResults.addAll(future.get());
    }
    pool.shutdown();

每個Callable返回一個結果列表，並在其自己的單獨線程中調用。
當您調用Future.get()方法時，您將結果返回到主線程。
在Callable完成之前，結果不可用，因此沒有並發問題。

Answer 2

所以，為了好玩，我提供了兩個工作示例。 第一個顯示了在java 1.5之前執行此操作的舊學校方法。 第二個顯示了使用java 1.5中提供的工具更清晰的方式：

import java.util.ArrayList;

public class ThreadingExample
{
    private ArrayList <MyThread> myThreads;

    public static class MyRunnable implements Runnable
    {
        private String data;

        public String getData()
        {
            return data;
        }

        public void setData(String data)
        {
            this.data = data;
        }

        @Override
        public void run()
        {
        }
    }

    public static class MyThread extends Thread
    {
        private MyRunnable myRunnable;

        MyThread(MyRunnable runnable)
        {
            super(runnable);
            setMyRunnable(runnable);
        }

        /**
         * @return the myRunnable
         */
        public MyRunnable getMyRunnable()
        {
            return myRunnable;
        }

        /**
         * @param myRunnable the myRunnable to set
         */
        public void setMyRunnable(MyRunnable myRunnable)
        {
            this.myRunnable = myRunnable;
        }
    }

    public ThreadingExample()
    {
        myThreads = new ArrayList <MyThread> ();
    }

    public ArrayList <String> retrieveMyData ()
    {
        ArrayList <String> allmyData = new ArrayList <String> ();

        if (isComplete() == false)
        {
            // Sadly we aren't done
            return (null);
        }

        for (MyThread myThread : myThreads)
        {
            allmyData.add(myThread.getMyRunnable().getData());
        }

        return (allmyData);
    }

    private boolean isComplete()
    {
        boolean complete = true;

        // wait for all of them to finish
        for (MyThread x : myThreads)
        {
            if (x.isAlive())
            {
                complete = false;
                break;
            }
        }
        return (complete);
    }

    public void kickOffQueries()
    {
        myThreads.clear();

        MyThread a = new MyThread(new MyRunnable()
        {
            @Override
            public void run()
            {
                // This is where you make the call to external services
                // giving the results to setData("");
                setData("Data from list A");
            }
        });
        myThreads.add(a);

        MyThread b = new MyThread (new MyRunnable()
        {
            @Override
            public void run()
            {
                // This is where you make the call to external services
                // giving the results to setData("");
                setData("Data from list B");
            }
        });
        myThreads.add(b);

        for (MyThread x : myThreads)
        {
            x.start();
        }

        boolean done = false;

        while (done == false)
        {
            if (isComplete())
            {
                done = true;
            }
            else
            {
                // Sleep for 10 milliseconds
                try
                {
                    Thread.sleep(10);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }


    public static void main(String [] args)
    {
        ThreadingExample example = new ThreadingExample();
        example.kickOffQueries();

        ArrayList <String> data = example.retrieveMyData();
        if (data != null)
        {
            for (String s : data)
            {
                System.out.println (s);
            }
        }
    }
}

這是更簡單的工作版本：

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadingExample
{

    public static void main(String [] args)
    {
        ExecutorService service = Executors.newCachedThreadPool();
        Set <Callable<String>> callables = new HashSet <Callable<String>> ();

        callables.add(new Callable<String>()
        {
            @Override
            public String call() throws Exception
            {
                return "This is where I make the call to web service A, and put its results here";
            }
        });

        callables.add(new Callable<String>()
        {
            @Override
            public String call() throws Exception
            {
                return "This is where I make the call to web service B, and put its results here";
            }
        });

        callables.add(new Callable<String>()
        {
            @Override
            public String call() throws Exception
            {
                return "This is where I make the call to web service C, and put its results here";
            }
        });

        try
        {
            List<Future<String>> futures = service.invokeAll(callables);
            for (Future<String> future : futures)
            {
                System.out.println (future.get());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        catch (ExecutionException e)
        {
            e.printStackTrace();
        }
    }
}

Answer 3

看看這個問題，您需要將您的應用程序與10多個不同的webservices集成。同時使所有調用異步。 這可以通過Apache Camel輕松完成。 它是企業集成的重要框架，也支持異步處理。 您可以使用其CXF組件調用Web服務及其路由引擎以調用和處理結果。 看看下面的頁面關於駱駝的異步路由能力。 他們還提供了一個完整的示例，使用CXF調用webservices異步，它可以在maven repo上找到 。 有關詳細信息，另請參閱以下頁面 。

Answer 4

您可以考慮以下創建工作的范例（按順序），但實際工作是並行完成的。 一種方法是：1）讓你的“主”創建一個工作項隊列; 2）創建一個“doWork”對象，查詢隊列中要做的工作; 3）讓“main”啟動一些“doWork”線程（可以是與不同服務的數量相同的數字，或者更小的數字）; 讓“doWork”對象把它們的結果添加到一個對象列表（無論構造工作Vector，列表......）。

每個“doWork”對象都會標記其隊列項完成，將所有結果放入傳遞的容器中並檢查新工作（如果隊列中沒有更多，則會睡眠並再次嘗試）。

當然，您將希望了解如何構建類模型。 如果每個Web服務在解析方面完全不同，那么您可能希望創建一個每個“retrieveinfo”類都承諾實現的接口。

Answer 5

您可以要求您的jax-ws實現為Web服務生成異步綁定。

這有兩個我可以看到的優點：

1. 正如在使用JAX-WS的異步Web服務調用中所討論的：使用wsimport支持異步或滾動我自己的？ ， jax-ws將為您生成經過良好測試的（並且可能更高級的）代碼，您無需自己實例化ExecutorService。 所以你的工作少了！ （但對線程實現細節的控制也較少）
2. 生成的綁定包括一個方法，您可以在其中指定一個回調處理程序，它可以更好地滿足您的需要，而不是同步get()調用調用retrieveAllLists()的線程上的所有響應列表。 它允許每服務調用錯誤處理，並將並行處理結果，如果處理非常重要，這是很好的。

---

可以在Metro站點上找到Metro的示例。 請注意自定義綁定文件custom-client.xml的內容 ：

<bindings ...>    
    <bindings node="wsdl:definitions">
        <enableAsyncMapping>true</enableAsyncMapping>
    </bindings>    
</bindings>

當您將此綁定文件指定給wsimport ，它將生成一個客戶端，該客戶端返回一個實現javax.xml.ws.Response<T>的對象。 Response擴展了Future界面，其他人也建議您在滾動自己的實現時使用。

所以，不出所料，如果你沒有回調，代碼將看起來與其他答案類似：

public void retrieveAllLists() throws ExecutionException{
    // first fire all requests
    Response<List<StudentsResults>> students1 = ws1.getStudents();
    Response<List<StudentsResults>> students2 = ws2.getStudents();
    Response<List<StudentsResults>> students3 = ws3.getStudents();

    Response<List<DoctorsResults>> doctors1 = ws4.getDoctors();
    Response<List<DoctorsResults>> doctors2 = ws5.getDoctors();
    Response<List<DoctorsResults>> doctors3 = ws6.getDoctors();

    Response<List<PatientsResults>> patients1 = ws7.getPatients();
    Response<List<PatientsResults>> patients2 = ws8.getPatients();
    Response<List<PatientsResults>> patients3 = ws9.getPatients();

    // then await and collect all the responses
    studentsResults.addAll(students1.get());
    studentsResults.addAll(students2.get());
    studentsResults.addAll(students3.get());

    doctorsResults.addAll(doctors1.get());
    doctorsResults.addAll(doctors2.get());
    doctorsResults.addAll(doctors3.get());

    patientsResults.addAll(patients1.get());
    patientsResults.addAll(patients2.get());
    patientsResults.addAll(patients3.get());
}

如果你創建回調手，如

private class StudentsCallbackHandler 
            implements AsyncHandler<Response<List<StudentsResults>>> {
    public void handleResponse(List<StudentsResults> response) {
        try {
            studentsResults.addAll(response.get());
        } catch (ExecutionException e) {
            errors.add(new CustomError("Failed to retrieve Students.", e.getCause()));
        } catch (InterruptedException e) {
            log.error("Interrupted", e);
        }
    }
}

你可以像這樣使用它們：

public void retrieveAllLists() {
    List<Future<?>> responses = new ArrayList<Future<?>>();
    // fire all requests, specifying callback handlers
    responses.add(ws1.getStudents(new StudentsCallbackHandler()));
    responses.add(ws2.getStudents(new StudentsCallbackHandler()));
    responses.add(ws3.getStudents(new StudentsCallbackHandler()));

    ...

    // await completion 
    for( Future<?> response: responses ) {
        response.get();
    }

    // or do some other work, and poll response.isDone()
}

請注意，studentResults集合現在需要是線程安全的，因為結果將同時添加！

Answer 6

它有各種各樣的選擇來開發它。

1. JMS：服務質量和管理，例如重新傳遞嘗試，死信息隊列，負載管理，可擴展性，集群，監控等。
2. 只需使用Observer模式即可。 有關詳細信息OODesign以及如何解決產品和消費者關注此Kodelog **