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。