最近工作需要接觸CXF非同步webservice的釋出和呼叫，在網上Google並搗鼓了好一陣子，總算成功了。畢竟這方面的資料比較少，自己總結一下寫下這篇博文。本文將描述如何利用CXF來發布和呼叫非同步的webservice，通過一個示例，帶大家一步一步開發基於CXF的非同步webservice及客戶端呼叫程式。

【參考】

1.非同步webservice簡介

非同步webservice可以讓客戶端呼叫執行緒在呼叫webservice的時候不必阻塞等待服務端返回結果，在呼叫請求後快速返回，然後做其他想做的事情。

1.1 客戶端非同步呼叫方式

(1) Callback

客戶端通過實現javax.xml.ws.AsyncHandler

(2) Polling

客戶端拿到javax.xml.ws.Response型別的返回結果，然後不斷輪詢Response的isDone方法來判斷是否呼叫已經完成。

1.2 服務端非同步呼叫的實現

CXF提供了兩種方法來響應客戶端的非同步webservice請求，包括:

(1) Continuations

CXF提供了API供開發者來建立並使用Continuation,關於continuation的詳細介紹請檢視以下連結:

(2) @UseAsyncMethod annotation

通過@UseAsyncMethod註解同步方法，讓同步方法在滿足非同步呼叫條件下呼叫其對應的非同步方法

@UseAsyncMethod
public String sayHello(String username) {
    return "hello " + username;
}

public Future<String> sayHelloAsync(String username,    AsyncHandler<String> asyncHandler) {
    // ...
    return null;
}

public Response<String> sayHelloAsync
 
(String username) {
    // ...
    return null;
}

如上所示,sayHello方法註解了@UseAsyncMethod,如果web容器支援非同步呼叫，將會呼叫其對應的sayHelloAsync方法,如果不支援非同步呼叫，那麼將會呼叫同步的sayHello方法。

【注意】

CXF依賴於Web容器來發布webservice,必須確保Web容器支援非同步機制才能使CXF釋出的webservice成功處理來自客戶端的非同步請求。eg:通過Tomcat配置CXF釋出webservice必須確保配置在web.xml的CXFServlet配置了async-supported為true

2. 示例

通過釋出一個HelloService非同步webservice以及開發HelloClient來向大家說明基於CXF如何開發和呼叫非同步的webservice。示例程式碼可以在我的github拉取:CXFTutorial

2.1 環境說明

【軟體環境】

• JDK 6+
• STS(Eclipse)
• Tomcat7

【依賴庫】

• aopalliance-1.0.jar
• asm-3.3.1.jar
• commons-logging-1.1.1.jar
• cxf-bundle-2.7.15.jar
• httpasyncclient-4.0-beta3.jar
• httpclient-4.2.5.jar
• httpcore-4.2.4.jar
• httpcore-nio-4.2.4.jar
• neethi-3.0.3.jar
• spring-aop-3.0.7.RELEASE.jar
• spring-asm-3.0.7.RELEASE.jar
• spring-beans-3.0.7.RELEASE.jar
• spring-context-3.0.7.RELEASE.jar
• spring-core-3.0.7.RELEASE.jar
• spring-expression-3.0.7.RELEASE.jar
• spring-web-3.0.7.RELEASE.jar
• stax2-api-3.1.4.jar
• woodstox-core-asl-4.4.1.jar
• wsdl4j-1.6.3.jar
• xmlschema-core-2.1.0.jar

2.2 開發webservice介面及實現類

2.2.1 開發HelloService介面

package com.hello;

import java.util.concurrent.Future;

import javax.jws.WebService;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Response;
import javax.xml.ws.ResponseWrapper;

@WebService(name = "helloService")
public interface HelloService {

    @ResponseWrapper(localName = "sayHelloResponse", className = "java.lang.String")
    public String sayHello(String username);

    @ResponseWrapper(localName = "sayHelloResponse", className = "java.lang.String")
    public Future<String> sayHelloAsync(String username, AsyncHandler<String> asyncHandler);

    public Response<String> sayHelloAsync(String username);

}

2.2.2 實現HelloServiceImpl

package com.hello;

import java.util.concurrent.Future;

import javax.jws.WebService;
import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Response;

import org.apache.cxf.annotations.UseAsyncMethod;
import org.apache.cxf.jaxws.ServerAsyncResponse;

@WebService(endpointInterface="com.hello.HelloService")
public class HelloServiceImpl implements HelloService {

    @Override
    @UseAsyncMethod
    public String sayHello(String username) {
        System.out.println("execute sayHello method");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "hello " + username;
    }

    @Override
    public Future<String> sayHelloAsync(String username,
            AsyncHandler<String> asyncHandler) {
        System.out.println("execute sayHelloAsync method");
        final ServerAsyncResponse<String> asyncResponse = new ServerAsyncResponse<String>();
        new Thread() {
            public void run() {
                String result = sayHello(username);
                asyncResponse.set(result);
                System.out.println("Responding on background thread\n");
                asyncHandler.handleResponse(asyncResponse);
            }
        }.start();
        return asyncResponse;
    }

    @Override
    public Response<String> sayHelloAsync(String username) {
        // TODO Auto-generated method stub
        return null;
    }

}

2.3 釋出webservice

2.3.1 配置cxf.xml

通過Spring配置CXF釋出webservice的埠及地址

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
    xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

    <jaxws:endpoint id="helloService" implementor="com.hello.HelloServiceImpl" address="/helloService"></jaxws:endpoint>

</beans>

【注意】 cxf.xml檔案放置在/WEB-INF/目錄下，即與web.xml處於同個目錄

2.3.2 配置web.xml

在web.xml裡面配置CXFServlet來發布webservice

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
version="3.0" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee           
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>WEB-INF/cxf.xml</param-value>
    </context-param>

    <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
    <servlet-name>CXFServlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
    </servlet>

    <servlet-mapping>
    <servlet-name>CXFServlet</servlet-name>
    <url-pattern>/services/*</url-pattern>
    </servlet-mapping>
</web-app>

2.3.3 使用Tomcat載入應用


2.4 開發webservice客戶端呼叫

package com.hello.client;

import java.util.concurrent.Future;


import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;

import com.hello.HelloService;


public final class HelloClient2 {

    public static void main(String args[]) throws Exception {

    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

    factory.setServiceClass(HelloService.class);
    factory.setAddress("http://192.168.16.52:8080/CXFTutorial/services/helloService?wsdl");
    factory.getInInterceptors().add(new LoggingInInterceptor());
    factory.getOutInterceptors().add(new LoggingOutInterceptor());
    HelloService client = (HelloService) factory.create();


    // callback method
    TestAsyncHandler testAsyncHandler = new TestAsyncHandler();
    System.out.println("Invoking changeStudentAsync using callback object...");
    Future<?> response = client.sayHelloAsync(
        "CrazyPig", testAsyncHandler);
    while (!response.isDone()) {
        Thread.sleep(100);
    }

    String resp = testAsyncHandler.getResponse();
    System.out.println("Server responded through callback with: " + resp);

    System.exit(0);
    }
}

通過實現了AsyncHandler介面的TestAsyncHandler來處理webservice響應結果，handleResponse方法會在服務端處理完結果後被呼叫，即所謂的回撥機制。

使用response.isDone()來判斷並休眠是為了防止main函式過快退出。實際上可以替換成你想做的其他事情。

當然，如果你需要根據webservice返回結果來進行你的下一步邏輯，也可以直接呼叫response.get()，這個方法會阻塞到呼叫結果成功返回。(實際上這樣跟呼叫同步方法沒什麼區別了)

package com.hello.client;

import javax.xml.ws.AsyncHandler;
import javax.xml.ws.Response;

public class TestAsyncHandler implements AsyncHandler<String> {

    private String reply;

    public void handleResponse(Response<String> response) {
    try {
        System.out.println("handleResponse called");
        reply = response.get();
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    }

    public String getResponse() {
    return reply;
    }

}