淺談Spring2.5集合Web Service

作者：歸鴻聲斷殘云碧 2009-06-25 14:45:05

本文將簡單談談Spring2.5集合Web Service。Spring為JAX-RPC servlet的端點實現提供了一個方便的基類 - ServletEndpointSupport. 未來暴露我們的 AccountService我們擴展Spring的ServletEndpointSupport類并在這里實現了我們的業務邏輯，通常將調用交給業務層。

使用JAX-RPC暴露基于servlet的web服務

Spring為JAX-RPC servlet的端點實現提供了一個方便的基類 - ServletEndpointSupport. 未來暴露我們的 AccountService我們擴展Spring的ServletEndpointSupport類并在這里實現了我們的業務邏輯，通常將調用交給業務層。

/**  
* JAX-RPC compliant RemoteAccountService implementation that simply delegates  
* to the AccountService implementation in the root web application context.  
*  
* This wrapper class is necessary because JAX-RPC requires working with dedicated  
* endpoint classes. If an existing service needs to be exported, a wrapper that  
* extends ServletEndpointSupport for simple application context access is  
* the simplest JAX-RPC compliant way.  
*  
* This is the class registered with the server-side JAX-RPC implementation.  
* In the case of Axis, this happens in "server-config.wsdd" respectively via  
* deployment calls. The web service engine manages the lifecycle of instances  
* of this class: A Spring application context can just be accessed here.  
*/import org.springframework.remoting.jaxrpc.ServletEndpointSupport;  
 
public class AccountServiceEndpoint extends ServletEndpointSupport implements RemoteAccountService {  
      
    private AccountService biz;  
 
    protected void onInit() {  
        this.biz = (AccountService) getWebApplicationContext().getBean("accountService");  
    }  
 
    public void insertAccount(Account acc) throws RemoteException {  
        biz.insertAccount(acc);  
    }  
 
    public Account[] getAccounts(String name) throws RemoteException {  
        return biz.getAccounts(name);  
    }  
}

AccountServletEndpoint需要在Spring中同一個上下文的web應用里運行，以獲得對Spring的訪問能力。如果使用Axis，把AxisServlet定義復制到你的'web.xml'中，并且在'server-config.wsdd'中設置端點（或使用發布工具）。參看JPetStore這個例子中OrderService是如何用Axis發布成一個Web服務的。

使用JAX-RPC訪問web服務

Spring提供了兩個工廠bean用來創建Web服務代理，LocalJaxRpcServiceFactoryBean 和 JaxRpcPortProxyFactoryBean。前者只返回一個JAX-RPC服務類供我們使用。后者是一個全功能的版本，可以返回一個實現我們業務服務接口的代理。本例中，我們使用后者來為前面段落中暴露的AccountService端點創建一個代理。你將看到Spring對Web服務提供了極好的支持，只需要很少的代碼 - 大多數都是通過類似下面的Spring配置文件：

<bean id="accountWebService" class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean"> 
    <property name="serviceInterface" value="example.RemoteAccountService"/> 
    <property name="wsdlDocumentUrl" value="http://localhost:8080/account/services/accountService?WSDL"/> 
    <property name="namespaceUri" value="http://localhost:8080/account/services/accountService"/> 
    <property name="serviceName" value="AccountService"/> 
    <property name="portName" value="AccountPort"/> 
</bean>

serviceInterface是我們客戶端將使用的遠程業務接口。 wsdlDocumentUrl是WSDL文件的URL. Spring需要用它作為啟動點來創建JAX-RPC服務。 namespaceUri對應.wsdl文件中的targetNamespace。 serviceName 對應.wsdl文件中的服務名。 portName 對應.wsdl文件中的端口號。

現在我們可以很方便的訪問web服務，因為我們有一個可以將它暴露為RemoteAccountService接口的bean工廠。我們可以在Spring中這樣使用：

<bean id="client" class="example.AccountClientImpl"> 
    ...  
    <property name="service" ref="accountWebService"/> 
</bean>

從客戶端代碼上看，除了它拋出RemoteException，我們可以把這個web服務當成一個普通的類進行訪，。

public class AccountClientImpl {  
 
    private RemoteAccountService service;  
      
    public void setService(RemoteAccountService service) {  
        this.service = service;  
    }  
      
    public void foo() {  
        try {  
            service.insertAccount(...);  
        }  
        catch (RemoteException ex) {  
            // ouch  
        }  
    }  
}

我們可以不檢查受控異常RemoteException，因為Spring將它自動轉換成相應的非受控異常RemoteException。這也需要我們提供一個非RMI的接口。現在配置文件如下：

<bean id="accountWebService" class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean"> 
    <property name="serviceInterface" value="example.AccountService"/> 
    <property name="portInterface" value="example.RemoteAccountService"/> 
</bean>

我們的serviceInterface變成了非RMI接口。我們的RMI接口現在使用portInterface屬性來定義。我們的客戶端代碼可以避免處理異常java.rmi.RemoteException:

public class AccountClientImpl {  
 
    private AccountService service;  
      
    public void setService(AccountService service) {  
        this.service = service;  
    }  
      
    public void foo() {  
        service.insertAccount(...);  
    }  
}

請注意你也可以去掉"portInterface"部分并指定一個普通業務接口作為"serviceInterface"。這樣JaxRpcPortProxyFactoryBean將自動切換到JAX-RPC "動態調用接口", 不使用固定端口存根來進行動態調用。這樣做的好處是你甚至不需要使用一個RMI相關的Java接口（比如在非Java的目標web服務中）；你只需要一個匹配的業務接口。查看JaxRpcPortProxyFactoryBean的javadoc來了解運行時實行的細節。

注冊JAX-RPC Bean映射

T為了傳遞類似Account等復雜對象，我們必須在客戶端注冊bean映射。

注意

在服務器端通常在'server-config.wsdd'中使用Axis進行bean映射注冊。

我們將使用Axis在客戶端注冊bean映射。為此，我們需要通過程序注冊這個bean映射:

public class AxisPortProxyFactoryBean extends JaxRpcPortProxyFactoryBean {  
 
    protected void postProcessJaxRpcService(Service service) {  
        TypeMappingRegistry registry = service.getTypeMappingRegistry();  
        TypeMapping mapping = registry.createTypeMapping();  
        registerBeanMapping(mapping, Account.class, "Account");  
        registry.register("http://schemas.xmlsoap.org/soap/encoding/", mapping);  
    }  
 
    protected void registerBeanMapping(TypeMapping mapping, Class type, String name) {  
        QName qName = new QName("http://localhost:8080/account/services/accountService", name);  
        mapping.register(type, qName,  
                new BeanSerializerFactory(type, qName),  
                new BeanDeserializerFactory(type, qName));  
    }  
}

注冊自己的JAX-RPC 處理器

本節中，我們將注冊自己的javax.rpc.xml.handler.Handler 到Web服務代理，這樣我們可以在SOAP消息被發送前執行定制的代碼。Handler是一個回調接口。jaxrpc.jar中有個方便的基類javax.rpc.xml.handler.GenericHandler供我們繼承使用：

public class AccountHandler extends GenericHandler {  
 
    public QName[] getHeaders() {  
        return null;  
    }  
 
    public boolean handleRequest(MessageContext context) {  
        SOAPMessageContext smc = (SOAPMessageContext) context;  
        SOAPMessage msg = smc.getMessage();  
        try {  
            SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();  
            SOAPHeader header = envelope.getHeader();  
            ...  
        }  
        catch (SOAPException ex) {  
            throw new JAXRPCException(ex);  
        }  
        return true;  
    }  
}

我們現在要做的就是把AccountHandler注冊到JAX-RPC服務，這樣它可以在消息被發送前調用 handleRequest(..)。Spring目前對注冊處理方法還不提供聲明式支持，所以我們必須使用編程方式。但是Spring中這很容易實現，我們只需覆寫專門為此設計的 postProcessJaxRpcService(..) 方法：

public class AccountHandlerJaxRpcPortProxyFactoryBean extends JaxRpcPortProxyFactoryBean {  
 
    protected void postProcessJaxRpcService(Service service) {  
        QName port = new QName(this.getNamespaceUri(), this.getPortName());  
        List list = service.getHandlerRegistry().getHandlerChain(port);  
        list.add(new HandlerInfo(AccountHandler.class, null, null));  
        logger.info("Registered JAX-RPC AccountHandler on port " + port);  
    }  
}

***，我們要記得更改Spring配置文件來使用我們的工廠bean:

<bean id="accountWebService" class="example.AccountHandlerJaxRpcPortProxyFactoryBean"> 
    ...  
</bean>

使用JAX-WS暴露基于servlet的web服務
Spring為JAX-WS servlet端點實現提供了一個方便的基類 - SpringBeanAutowiringSupport。要暴露我們的AccountService接口，我們可以擴展Spring的SpringBeanAutowiringSupport類并實現我們的業務邏輯，通常把調用交給業務層。我們將簡單的使用Spring 2.5的@Autowired注解來聲明依賴于Spring管理的bean。

/**  
* JAX-WS compliant AccountService implementation that simply delegates  
* to the AccountService implementation in the root web application context.  
*  
* This wrapper class is necessary because JAX-WS requires working with dedicated  
* endpoint classes. If an existing service needs to be exported, a wrapper that  
* extends SpringBeanAutowiringSupport for simple Spring bean autowiring (through  
* the @Autowired annotation) is the simplest JAX-WS compliant way.  
*  
* This is the class registered with the server-side JAX-WS implementation.  
* In the case of a Java EE 5 server, this would simply be defined as a servlet  
* in web.xml, with the server detecting that this is a JAX-WS endpoint and reacting  
* accordingly. The servlet name usually needs to match the specified WS service name.  
*  
* The web service engine manages the lifecycle of instances of this class.  
* Spring bean references will just be wired in here.  
*/import org.springframework.web.context.support.SpringBeanAutowiringSupport;  
 
@WebService(serviceName="AccountService")  
public class AccountServiceEndpoint extends SpringBeanAutowiringSupport {  
 
    @Autowired  
    private AccountService biz;  
 
    @WebMethod  
    public void insertAccount(Account acc) {  
       biz.insertAccount(acc);  
    }  
 
    @WebMethod  
    public Account[] getAccounts(String name) {  
       return biz.getAccounts(name);  
    }  
}

為了能夠讓Spring上下文使用Spring設施，我們的AccountServletEndpoint類需要運行在同一個web應用中。在Java EE 5環境中這是默認的情況，它使用JAX-WS servlet端點安裝標準契約。詳情請參閱Java EE 5 web服務教程。

使用JAX-WS暴露單獨web服務
Sun JDK 1.6提供的內置JAX-WS provider 使用內置的HTTP服務器來暴露web服務。Spring的SimpleJaxWsServiceExporter類檢測所有在Spring應用上下文中配置的l@WebService 注解bean，然后通過默認的JAX-WS服務器（JDK 1.6 HTTP服務器）來暴露它們。

在這種場景下，端點實例將被作為Spring bean來定義和管理。它們將使用JAX-WS來注冊，但其生命周期將一直跟隨Spring應用上下文。這意味著Spring的顯示依賴注入可用于端點實例。當然通過@Autowired來進行注解驅動的注入也可以正常工作。

<bean class="org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter"> 
    <property name="baseAddress" value="http://localhost:9999/"/> 
</bean> 
 
<bean id="accountServiceEndpoint" class="example.AccountServiceEndpoint"> 
    ...  
</bean> 
 
...

AccountServiceEndpoint類可能源自Spring的 SpringBeanAutowiringSupport類，也可能不是。因為這里的端點是由Spring完全管理的bean。這意味著端點實現可能像下面這樣沒有任何父類定義 - 而且Spring的@Autowired配置注解仍然能夠使用：

@WebService(serviceName="AccountService")  
public class AccountServiceEndpoint {  
 
    @Autowired  
    private AccountService biz;  
 
    @WebMethod  
    public void insertAccount(Account acc) {  
       biz.insertAccount(acc);  
    }  
 
    @WebMethod  
    public Account[] getAccounts(String name) {  
       return biz.getAccounts(name);  
    }  
}

使用Spring支持的JAX-WS RI來暴露服務

Sun的JAX-WS RI被作為GlassFish項目的一部分來開發,它使用了Spring支持來作為JAX-WS Commons項目的一部分。這允許把JAX-WS端點作為Spring管理的bean來定義。這與前面章節討論的單獨模式類似 - 但這次是在Servlet環境中。注意這在Java EE 5環境中是不可遷移的，建議在沒有EE的web應用環境如Tomcat中嵌入JAX-WS RI。

與標準的暴露基于servlet的端點方式不同之處在于端點實例的生命周期將被Spring管理。這里在web.xml將只有一個JAX-WS servlet定義。在標準的Java EE 5風格中(如上所示)，你將對每個服務端點定義一個servlet，每個服務端點都代理到Spring bean (通過使用@Autowired，如上所示)。

關于安裝和使用詳情請查閱https://jax-ws-commons.dev.java.net/spring/。

使用JAX-WS訪問web服務
類似JAX-RPC支持，Spring提供了2個工廠bean來創建JAX-WS web服務代理，它們是LocalJaxWsServiceFactoryBean和JaxWsPortProxyFactoryBean。前一個只能返回一個JAX-WS服務對象來讓我們使用。后面的是可以返回我們業務服務接口的代理實現的完整版本。這個例子中我們使用后者來為AccountService端點再創建一個代理：

<bean id="accountWebService" class="org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean"> 
    <property name="serviceInterface" value="example.AccountService"/> 
    <property name="wsdlDocumentUrl" value="http://localhost:8080/account/services/accountService?WSDL"/> 
    <property name="namespaceUri" value="http://localhost:8080/account/services/accountService"/> 
    <property name="serviceName" value="AccountService"/> 
    <property name="portName" value="AccountPort"/> 
</bean>

現在我們可以很方便的訪問web服務，因為我們有一個可以將它暴露為AccountService接口的bean工廠。我們可以在Spring中這樣使用：

<bean id="client" class="example.AccountClientImpl"> 
    ...  
    <property name="service" ref="accountWebService"/> 
</bean>

從客戶端代碼上我們可以把這個web服務當成一個普通的類進行訪問：

public class AccountClientImpl {  
 
    private AccountService service;  
 
    public void setService(AccountService service) {  
        this.service = service;  
    }  
 
    public void foo() {  
        service.insertAccount(...);  
    }  
}

注意: 上面被稍微簡化了，因為JAX-WS需要端點接口及實現類來使用@WebService, @SOAPBinding等注解。這意味著你不能簡單的使用普通的Java接口和實現來作為JAX-WS端點，你需要首先對它們進行相應的注解。這些需求詳情請查閱JAX-WS文檔。

使用XFire來暴露Web服務

XFire是一個Codehaus提供的輕量級SOAP庫。暴露XFire是通過XFire自帶的context，這個context將和RemoteExporter風格的bean相結合，后者需要被加入到在你的WebApplicationContext中。對于所有讓你來暴露服務的方法，你需要創建一個DispatcherServlet類并有相應的WebApplicationContext來封裝你將要暴露的服務：

<servlet> 
    <servlet-name>xfire</servlet-name> 
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
</servlet>

你還必須鏈接XFire配置。這是通過增加一個context文件到由ContextLoaderListener（或者ContextLoaderServlet）加載的 contextConfigLocations 參數中。

<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>classpath:org/codehaus/xfire/spring/xfire.xml</param-value> 
</context-param> 
 
<listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
</listener>

在你加入一個Servlet映射后（映射/*到上面定義的XFire Servlet），你只需要增加一個額外的bean來使用XFire暴露服務。例如，在 'xfire-servlet.xml' 中增加如下配置：

<beans> 
 
    <bean name="/Echo" class="org.codehaus.xfire.spring.remoting.XFireExporter"> 
        <property name="serviceInterface" value="org.codehaus.xfire.spring.Echo"/> 
        <property name="serviceBean"> 
            <bean class="org.codehaus.xfire.spring.EchoImpl"/> 
        </property> 
        <!-- the XFire bean is defined in the xfire.xml file --> 
        <property name="xfire" ref="xfire"/> 
</bean> 
 
</beans>

XFire處理了其他的事情。它檢查你的服務接口并產生一個WSDL文件。這里的部分文檔來自XFire網站，要了解更多有關XFire Spring的集成請訪問 docs.codehaus.org/display/XFIRE/Spring。

【編輯推薦】

JSF和Spring的集成
在Spring中進行集成測試
比較JSF、Spring MVC、Stripes、Struts 2、Tapestry、Wicket
Spring中的TopLink ServerSession
Spring is coming

責任編輯：彭凡來源：百度空間

Spring2.5