MessageDispatcherServlet 是一個標準的 Servlet，它方便地擴充套件了標準的 Spring Web DispatcherServlet，幷包裝了一個 MessageDispatcher。因此，它將這些屬性合併為一個：作為一個 MessageDispatcher，它遵循與上一節中描述的相同的請求處理流程。作為一個 servlet，MessageDispatcherServlet 在您的 Web 應用程式的 web.xml 中配置。您希望 MessageDispatcherServlet 處理的請求將必須使用相同的 web.xml 檔案中的 URL 對映進行對映。這是標準的 Java EE servlet 配置；下面可以找到此類 MessageDispatcherServlet 宣告和對映的示例。

<web-app>

    <servlet>
        <servlet-name>spring-ws</servlet-name>
        <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring-ws</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

</web-app>

在上面的示例中，所有請求都將由 'spring-ws' MessageDispatcherServlet 處理。這只是設定 Spring Web Services 的第一步，因為 Spring-WS 框架使用的各種元件 bean 也需要配置；此配置由標準 Spring XML <bean/> 定義組成。因為 MessageDispatcherServlet 是一個標準的 Spring DispatcherServlet，它將在您的 Web 應用程式的 WEB-INF 目錄中查詢名為 [servlet-name]-servlet.xml 的檔案，並在 Spring 容器中建立其中定義的 bean。在上面的示例中，這意味著它查詢“/WEB-INF/spring-ws-servlet.xml”。此檔案將包含所有 Spring Web Services bean，例如端點、編組器等。

<sws:static-wsdl id="orders" location="/WEB-INF/wsdl/orders.wsdl"/>

https://:8080/spring-ws/orders.wsdl

<web-app>

  <servlet>
    <servlet-name>spring-ws</servlet-name>
    <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet</servlet-class>
    <init-param>
      <param-name>transformWsdlLocations</param-name>
      <param-value>true</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>spring-ws</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

</web-app>

<sws:dynamic-wsdl id="orders"
    portTypeName="Orders"
    locationUri="https://:8080/ordersService/">
  <sws:xsd location="/WEB-INF/xsd/Orders.xsd"/>
</sws:dynamic-wsdl>

作為 MessageDispatcherServlet 的替代方案，您可以在標準的 Spring-Web MVC DispatcherServlet 中連線 MessageDispatcher。預設情況下，DispatcherServlet 只能委託給 Controllers，但我們可以透過向 servlet 的 Web 應用程式上下文新增 WebServiceMessageReceiverHandlerAdapter 來指示它委託給 MessageDispatcher

<beans>

    <bean class="org.springframework.ws.transport.http.WebServiceMessageReceiverHandlerAdapter"/>

    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="defaultHandler" ref="messageDispatcher"/>
    </bean

    <bean id="messageDispatcher" class="org.springframework.ws.soap.server.SoapMessageDispatcher"/>

    ...

    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    
</beans>

請注意，透過顯式新增 WebServiceMessageReceiverHandlerAdapter，排程器 servlet 不會載入預設介面卡，並且無法處理標準 Spring-MVC Controllers。因此，我們在末尾新增 SimpleControllerHandlerAdapter。

以類似的方式，您可以連線 WsdlDefinitionHandlerAdapter 以確保 DispatcherServlet 可以處理 WsdlDefinition 介面的實現

<beans>

    <bean class="org.springframework.ws.transport.http.WebServiceMessageReceiverHandlerAdapter"/>

    <bean class="org.springframework.ws.transport.http.WsdlDefinitionHandlerAdapter"/>

    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
           <props>
             <prop key="*.wsdl">myServiceDefinition</prop>
           </props>
        </property>
        <property name="defaultHandler" ref="messageDispatcher"/>
    </bean>

    <bean id="messageDispatcher" class="org.springframework.ws.soap.server.SoapMessageDispatcher"/>

    <bean id="myServiceDefinition" class="org.springframework.ws.wsdl.wsdl11.SimpleWsdl11Definition">
       <prop name="wsdl" value="/WEB-INF/myServiceDefintion.wsdl"/>
    </bean>

    ...

</beans>

Spring Web Services 透過 Spring 框架中提供的 JMS 功能支援伺服器端 JMS 處理。Spring Web Services 提供了 WebServiceMessageListener 以插入 MessageListenerContainer。此訊息偵聽器需要 WebServiceMessageFactory 和 MessageDispatcher 才能執行。以下配置片段顯示了這一點

<beans>

    <bean id="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="vm://?broker.persistent=false"/>
    </bean>

    <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"/>

    <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destinationName" value="RequestQueue"/>
        <property name="messageListener">
            <bean class="org.springframework.ws.transport.jms.WebServiceMessageListener">
                <property name="messageFactory" ref="messageFactory"/>
                <property name="messageReceiver" ref="messageDispatcher"/>
            </bean>
        </property>
    </bean>

    <bean id="messageDispatcher" class="org.springframework.ws.soap.server.SoapMessageDispatcher">
        <property name="endpointMappings">
            <bean
              class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
                <property name="defaultEndpoint">
                    <bean class="com.example.MyEndpoint"/>
                </property>
            </bean>
        </property>
    </bean>
</beans>

作為 WebServiceMessageListener 的替代方案，Spring Web Services 提供了 WebServiceMessageDrivenBean，一個 EJB MessageDrivenBean。有關 EJB 的更多資訊，請參閱 WebServiceMessageDrivenBean 的類級別 Javadoc。

除了 HTTP 和 JMS，Spring Web Services 還提供伺服器端電子郵件處理。此功能透過 MailMessageReceiver 類提供。該類監視 POP3 或 IMAP 資料夾，將電子郵件轉換為 WebServiceMessage，並使用 SMTP 傳送任何響應。主機名可以透過 storeUri 進行配置，它指示要監視請求的郵件資料夾（通常是 POP3 或 IMAP 資料夾），以及 transportUri，它指示用於傳送響應的伺服器（通常是 SMTP 伺服器）。

MailMessageReceiver 如何監視傳入訊息可以透過可插拔策略進行配置：MonitoringStrategy。預設情況下，使用輪詢策略，每五分鐘輪詢一次傳入資料夾以獲取新訊息。此間隔可以透過設定策略上的 pollingInterval 屬性來更改。預設情況下，所有 MonitoringStrategy 實現都刪除已處理的訊息；這可以透過設定 deleteMessages 屬性來更改。

作為效率較低的輪詢方法的替代方案，有一種使用 IMAP IDLE 的監視策略。IDLE 命令是 IMAP 電子郵件協議的可選擴充套件，允許郵件伺服器非同步地向 MailMessageReceiver 傳送新訊息更新。如果您使用支援 IDLE 命令的 IMAP 伺服器，您可以將 ImapIdleMonitoringStrategy 插入到 monitoringStrategy 屬性中。除了支援的伺服器，您還需要使用 JavaMail 1.4.1 或更高版本。

以下配置片段顯示瞭如何使用伺服器端電子郵件支援，將預設輪詢間隔覆蓋為每 30 秒檢查一次（30,000 毫秒）的值

<beans>

    <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"/>

    <bean id="messagingReceiver" class="org.springframework.ws.transport.mail.MailMessageReceiver">
        <property name="messageFactory" ref="messageFactory"/>
        <property name="from" value="Spring-WS SOAP Server &lt;[email protected]&gt;"/>
        <property name="storeUri" value="imap://server:[email protected]/INBOX"/>
        <property name="transportUri" value="smtp://smtp.example.com"/>
        <property name="messageReceiver" ref="messageDispatcher"/>
        <property name="monitoringStrategy">
            <bean class="org.springframework.ws.transport.mail.monitor.PollingMonitoringStrategy">
                <property name="pollingInterval" value="30000"/>
            </bean>
        </property>
    </bean>

    <bean id="messageDispatcher" class="org.springframework.ws.soap.server.SoapMessageDispatcher">
        <property name="endpointMappings">
            <bean
              class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
                <property name="defaultEndpoint">
                    <bean class="com.example.MyEndpoint"/>
                </property>
            </bean>
        </property>
    </bean>
</beans>

Spring Web Services 提供了一種基於 Sun JRE 1.6 HTTP 伺服器的傳輸。嵌入式 HTTP 伺服器是一個獨立的伺服器，配置簡單。它是一種比傳統 servlet 容器更輕量級的替代方案。

使用嵌入式 HTTP 伺服器時，不需要外部部署描述符（web.xml）。您只需要定義伺服器例項並將其配置為處理傳入請求。Core Spring Framework 中的 remoting 模組包含 HTTP 伺服器的便捷工廠 bean：SimpleHttpServerFactoryBean。最重要的屬性是 contexts，它將上下文路徑對映到相應的 HttpHandler。

Spring Web Services 提供了 HttpHandler 介面的 2 種實現：WsdlDefinitionHttpHandler 和 WebServiceMessageReceiverHttpHandler。前者將傳入的 GET 請求對映到 WsdlDefinition。後者負責處理 Web 服務訊息的 POST 請求，因此需要 WebServiceMessageFactory（通常是 SaajSoapMessageFactory）和 WebServiceMessageReceiver（通常是 SoapMessageDispatcher）來完成其任務。

為了與 servlet 世界進行類比，contexts 屬性扮演著 web.xml 中 servlet 對映的角色，而 WebServiceMessageReceiverHttpHandler 相當於 MessageDispatcherServlet。

以下片段顯示了 HTTP 伺服器傳輸的簡單配置示例

<beans>

    <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"/>
    
    <bean id="messageReceiver" class="org.springframework.ws.soap.server.SoapMessageDispatcher">
        <property name="endpointMappings" ref="endpointMapping"/>
    </bean>

    <bean id="endpointMapping" class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
        <property name="defaultEndpoint" ref="stockEndpoint"/>
    </bean>
    
    <bean id="httpServer" class="org.springframework.remoting.support.SimpleHttpServerFactoryBean">
        <property name="contexts">
            <map>
                <entry key="/StockService.wsdl" value-ref="wsdlHandler"/>
                <entry key="/StockService" value-ref="soapHandler"/>
            </map>
        </property>
    </bean>

    <bean id="soapHandler" class="org.springframework.ws.transport.http.WebServiceMessageReceiverHttpHandler">
        <property name="messageFactory" ref="messageFactory"/>
        <property name="messageReceiver" ref="messageReceiver"/>
    </bean>

    <bean id="wsdlHandler" class="org.springframework.ws.transport.http.WsdlDefinitionHttpHandler">
        <property name="definition" ref="wsdlDefinition"/>
    </bean>
</beans>

有關 SimpleHttpServerFactoryBean 的更多資訊，請參閱 Javadoc。

最後，Spring Web Services 2.0 引入了對 XMPP 的支援，也稱為 Jabber。此支援基於 Smack 庫。

Spring Web Services 對 XMPP 的支援與其他傳輸非常相似：WebServiceTemplate 有一個 XmppMessageSender，MessageDispatcher 有一個 XmppMessageReceiver。

以下示例展示瞭如何設定伺服器端 XMPP 元件

<beans>

    <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"/>

    <bean id="connection" class="org.springframework.ws.transport.xmpp.support.XmppConnectionFactoryBean">
        <property name="host" value="jabber.org"/>
        <property name="username" value="username"/>
        <property name="password" value="password"/>
    </bean>

    <bean id="messagingReceiver" class="org.springframework.ws.transport.xmpp.XmppMessageReceiver">
        <property name="messageFactory" ref="messageFactory"/>
        <property name="connection" ref="connection"/>
        <property name="messageReceiver" ref="messageDispatcher"/>
    </bean>

    <bean id="messageDispatcher" class="org.springframework.ws.soap.server.SoapMessageDispatcher">
        <property name="endpointMappings">
            <bean
              class="org.springframework.ws.server.endpoint.mapping.PayloadRootAnnotationMethodEndpointMapping">
                <property name="defaultEndpoint">
                    <bean class="com.example.MyEndpoint"/>
                </property>
            </bean>
        </property>
    </bean>

</beans>

為了讓端點實際處理傳入的 XML 訊息，它需要有一個或多個處理方法。處理方法可以接受各種引數和返回型別，但通常它們有一個引數將包含訊息有效負載，並返回響應訊息的有效負載（如果有）。您將在本節中瞭解支援哪些引數和返回型別。

為了指示方法可以處理哪種型別的訊息，該方法通常使用 @PayloadRoot 或 @SoapAction 註解進行註解。您將在第 5.5 節，“端點對映”中瞭解有關這些註解的更多資訊。

這是一個處理方法的示例

@PayloadRoot(localPart = "order", namespace = "http://samples")
public void order(@RequestPayload Element orderElement) {
  Order order = createOrder(orderElement);
  orderService.createOrder(order);
}

order 方法將一個 Element 作為引數，並用 @RequestPayload 註解。這意味著訊息的有效負載作為 DOM 元素傳遞給此方法。該方法的返回型別為 void，表示不傳送響應訊息。

package samples;

import javax.xml.transform.Source;

import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.Namespace;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.XPathParam;

@Endpoint
public class AnnotationOrderEndpoint {

  private final OrderService orderService;

  public AnnotationOrderEndpoint(OrderService orderService) {
    this.orderService = orderService;
  }

  @PayloadRoot(localPart = "orderRequest", namespace = "http://samples")
  @Namespace(prefix = "s", uri="http://samples")
  public Order getOrder(@XPathParam("/s:orderRequest/@id") int orderId) {
    Order order = orderService.getOrder(orderId);
    // create Source from order and return it
}

}

WS-Addressing 指定了一種與傳輸無關的路由機制。它基於 To 和 Action SOAP 頭部，分別指示 SOAP 訊息的目的地和意圖。此外，WS-Addressing 允許您定義返回地址（用於正常訊息和故障），以及可用於關聯的唯一訊息識別符號^[2]。以下是 WS-Addressing 訊息的示例

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope"
    xmlns:wsa="http://www.w3.org/2005/08/addressing">
  <SOAP-ENV::Header>
    <wsa:MessageID>urn:uuid:21363e0d-2645-4eb7-8afd-2f5ee1bb25cf</wsa:MessageID>
    <wsa:ReplyTo>
      <wsa:Address>http://example.com/business/client1</wsa:Address>
    </wsa:ReplyTo>
    <wsa:To S:mustUnderstand="true">http://example/com/fabrikam</wsa:To>
    <wsa:Action>http://example.com/fabrikam/mail/Delete</wsa:Action>
  </SOAP-ENV:Header>
  <SOAP-ENV:Body>
    <f:Delete xmlns:f="http://example.com/fabrikam">
      <f:maxCount>42</f:maxCount>
    </f:Delete>
  </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

在此示例中，目的地設定為 http://example/com/fabrikam，而操作設定為 http://example.com/fabrikam/mail/Delete。此外，還有一個訊息識別符號和回覆地址。預設情況下，此地址是“匿名”地址，表示應使用與請求相同的通道（即 HTTP 響應）傳送響應，但它也可以是另一個地址，如本示例所示。

在 Spring Web Services 中，WS-Addressing 實現為一個端點對映。使用此對映，您將 WS-Addressing 動作與端點關聯，類似於上面描述的 SoapActionAnnotationMethodEndpointMapping。

package samples;

import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.soap.addressing.server.annotation.Action

@Endpoint
public class AnnotationOrderEndpoint {
    private final OrderService orderService;

    public AnnotationOrderEndpoint(OrderService orderService) {
        this.orderService = orderService;
    }

    @Action("http://samples/RequestOrder")
    public Order getOrder(OrderRequest orderRequest) {
        return orderService.getOrder(orderRequest.getId());
    }

    @Action("http://samples/CreateOrder")
    public void order(Order order) {
        orderService.createOrder(order);
    }

}

端點對映機制具有端點攔截器的概念。當您想要將特定功能應用於某些請求時，這些功能非常有用，例如，處理與安全相關的 SOAP 標頭，或記錄請求和響應訊息。

端點攔截器通常透過在應用程式上下文中，使用 <sws;interceptors > 元素定義。在此元素中，您可以簡單地定義適用於該應用程式上下文中定義的所有端點的端點攔截器 bean。或者，您可以使用 <sws:payloadRoot> 或 <sws:soapAction> 元素來指定攔截器應適用於哪個有效負載根名稱或 SOAP 操作。例如

<sws:interceptors>
  <bean class="samples.MyGlobalInterceptor"/>
  <sws:payloadRoot namespaceUri="http://www.example.com">
    <bean class="samples.MyPayloadRootInterceptor"/>
  </sws:payloadRoot>
  <sws:soapAction value="http://www.example.com/SoapAction">
    <bean class="samples.MySoapActionInterceptor1"/>
    <ref bean="mySoapActionInterceptor2"/>
  </sws:soapAction>
</sws:interceptors>

<bean id="mySoapActionInterceptor2" class="samples.MySoapActionInterceptor2"/>

這裡，我們定義了一個“全域性”攔截器（MyGlobalInterceptor），它攔截所有請求和響應。我們還定義了一個攔截器，它只適用於有效負載根名稱空間為 http://www.example.com 的 XML 訊息。在這裡，除了 namespaceUri 之外，我們還可以定義一個 localPart 屬性，以進一步限制攔截器適用的訊息。最後，我們定義了兩個攔截器，當訊息具有 http://www.example.com/SoapAction SOAP 操作時應用。請注意，第二個攔截器實際上是對 <interceptors> 元素之外的 bean 定義的引用。您可以在 <interceptors> 元素內的任何地方使用 bean 引用。

攔截器必須實現 org.springframework.ws.server 包中的 EndpointInterceptor 介面。此介面定義了三個方法，一個用於在實際端點執行之前處理請求訊息，一個用於處理正常響應訊息，另一個用於處理故障訊息，這兩個方法都將在端點執行之後呼叫。這三個方法應提供足夠的靈活性來執行各種預處理和後處理。

攔截器上的 handleRequest(..) 方法返回一個布林值。您可以使用此方法中斷或繼續處理呼叫鏈。當此方法返回 true 時，端點執行鏈將繼續；當它返回 false 時，MessageDispatcher 將其解釋為攔截器本身已處理好事情，並且不會繼續執行呼叫鏈中的其他攔截器和實際端點。handleResponse(..) 和 handleFault(..) 方法也具有布林返回值。當這些方法返回 false 時，響應將不會發送回客戶端。

您可以在 Web 服務中使用一些標準的 EndpointInterceptor 實現。此外，還有 XwsSecurityInterceptor，在第 7.2 節，“XwsSecurityInterceptor”中進行了描述。

  <sws:interceptors>
    <bean class="org.springframework.ws.server.endpoint.interceptor.PayloadLoggingInterceptor"/>
  </sws:interceptors>

</beans>

<bean id="validatingInterceptor"
        class="org.springframework.ws.soap.server.endpoint.interceptor.PayloadValidatingInterceptor">
    <property name="schema" value="/WEB-INF/orders.xsd"/>
    <property name="validateRequest" value="false"/>
    <property name="validateResponse" value="true"/>
</bean>

<bean id="transformingInterceptor"
        class="org.springframework.ws.server.endpoint.interceptor.PayloadTransformingInterceptor">
    <property name="requestXslt" value="/WEB-INF/oldRequests.xslt"/>
    <property name="responseXslt" value="/WEB-INF/oldResponses.xslt"/>
</bean>

SoapFaultMappingExceptionResolver 是一個更復雜的實現。此解析器使您能夠獲取可能丟擲的任何異常的類名並將其對映到 SOAP 故障，如下所示

<beans>
    <bean id="exceptionResolver"
        class="org.springframework.ws.soap.server.endpoint.SoapFaultMappingExceptionResolver">
        <property name="defaultFault" value="SERVER"/>
        <property name="exceptionMappings">
            <value>
                org.springframework.oxm.ValidationFailureException=CLIENT,Invalid request
            </value>
        </property>
    </bean>
</beans>

鍵值和預設端點使用 faultCode,faultString,locale 格式，其中只有故障程式碼是必需的。如果未設定故障字串，則預設為異常訊息。如果未設定語言，則預設為英語。上述配置將 ValidationFailureException 型別的異常對映到客戶端 SOAP 故障，其故障字串為 "Invalid request"，如下面的響應所示

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <SOAP-ENV:Body>
       <SOAP-ENV:Fault>
           <faultcode>SOAP-ENV:Client</faultcode>
           <faultstring>Invalid request</faultstring>
       </SOAP-ENV:Fault>
    </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

如果發生任何其他異常，它將返回預設故障：一個伺服器端故障，其故障字串為異常訊息。

最後，還可以使用 @SoapFault 註解異常類，以指示在丟擲該異常時應返回的 SOAP 故障。為了使這些註解被拾取，您需要在應用程式上下文中新增 SoapFaultAnnotationExceptionResolver。註解的元素包括故障程式碼列舉、故障字串或原因以及語言。這是一個示例異常

package samples;

import org.springframework.ws.soap.server.endpoint.annotation.FaultCode;
import org.springframework.ws.soap.server.endpoint.annotation.SoapFault;

@SoapFault(faultCode = FaultCode.SERVER)
public class MyBusinessException extends Exception {

    public MyClientException(String message) {
        super(message);
    }
}

每當在端點呼叫期間丟擲帶有建構函式字串 "Oops!" 的 MyBusinessException 時，它將導致以下響應

<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
    <SOAP-ENV:Body>
       <SOAP-ENV:Fault>
           <faultcode>SOAP-ENV:Server</faultcode>
           <faultstring>Oops!</faultstring>
       </SOAP-ENV:Fault>
    </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

Spring Web Services 2.0 引入了對建立端點整合測試的支援。在此上下文中，端點是處理（SOAP）訊息的類（參見第 5.4 節，“端點”）。

整合測試支援位於 org.springframework.ws.test.server 包中。該包中的核心類是 MockWebServiceClient。基本思想是，此客戶端建立請求訊息，然後將其傳送到在標準 MessageDispatcherServlet 應用程式上下文中配置的端點（參見第 5.3.1 節，“MessageDispatcherServlet”）。這些端點將處理訊息並建立響應。然後客戶端接收此響應，並根據註冊的期望進行驗證。

MockWebServiceClient 的典型用法是

例如，考慮這個簡單的 Web 服務端點類

import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;

@Endpoint                                                                                
public class CustomerEndpoint {

  @ResponsePayload                                                                       
  public CustomerCountResponse getCustomerCount(                                         
      @RequestPayload CustomerCountRequest request) {                                    
    CustomerCountResponse response = new CustomerCountResponse();
    response.setCustomerCount(10);
    return response;
  }

}

CustomerEndpoint 的典型測試如下所示

import javax.xml.transform.Source;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.xml.transform.StringSource;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.ws.test.server.MockWebServiceClient;                          
import static org.springframework.ws.test.server.RequestCreators.*;                      
import static org.springframework.ws.test.server.ResponseMatchers.*;                     

@RunWith(SpringJUnit4ClassRunner.class)                                                  
@ContextConfiguration("spring-ws-servlet.xml")                                           
public class CustomerEndpointIntegrationTest {

  @Autowired
  private ApplicationContext applicationContext;                                         

  private MockWebServiceClient mockClient;

  @Before
  public void createClient() {
    mockClient = MockWebServiceClient.createClient(applicationContext);                  
  }

  @Test
  public void customerEndpoint() throws Exception {
    Source requestPayload = new StringSource(
      "<customerCountRequest xmlns='http://springframework.org/spring-ws'>" +
        "<customerName>John Doe</customerName>" +
      "</customerCountRequest>");
    Source responsePayload = new StringSource(
      "<customerCountResponse xmlns='http://springframework.org/spring-ws'>" +
        "<customerCount>10</customerCount>" +
      "</customerCountResponse>");

    mockClient.sendRequest(withPayload(requestPayload)).                                 
      andExpect(payload(responsePayload));                                               
  }
}

最初，MockWebServiceClient 需要為端點建立請求訊息以供消費。客戶端為此目的使用 RequestCreator 策略介面

public interface RequestCreator {

  WebServiceMessage createRequest(WebServiceMessageFactory messageFactory)
    throws IOException;

}

您可以編寫此介面的自己的實現，透過使用訊息工廠建立請求訊息，但您當然不必這樣做。RequestCreators 類提供了一種基於給定有效負載透過 withPayload() 方法建立 RequestCreator 的方法。您通常會靜態匯入 RequestCreators。

當請求訊息由端點處理並收到響應後，MockWebServiceClient 可以驗證此響應訊息是否符合某些期望。客戶端為此目的使用 ResponseMatcher 策略介面

public interface ResponseMatcher {

    void match(WebServiceMessage request,
               WebServiceMessage response)
      throws IOException, AssertionError;

}

再次，您可以編寫此介面的自己的實現，當訊息不符合您的期望時丟擲 AssertionError，但您當然不必這樣做，因為 ResponseMatchers 類為您提供了標準 ResponseMatcher 實現，供您在測試中使用。您通常會靜態匯入此類。

ResponseMatchers 類提供了以下響應匹配器

您可以透過鏈式呼叫 andExpect() 來設定多個響應期望，如下所示

mockClient.sendRequest(...).
 andExpect(payload(expectedResponsePayload)).
 andExpect(validPayload(schemaResource));

有關 ResponseMatchers 提供的請求匹配器的更多資訊，請參閱類級別 Javadoc。