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"/>

http://localhost: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="http://localhost:8080/ordersService/">
  <sws:xsd location="/WEB-INF/xsd/Orders.xsd"/>
</sws:dynamic-wsdl>

作为 MessageDispatcherServlet 的替代方案，您可以在标准的 Spring-Web MVC DispatcherServlet 中配置 MessageDispatcher。默认情况下，DispatcherServlet 只能委托给 Controllers，但我们可以通过添加 WebServiceMessageReceiverHandlerAdapter 到 servlet 的 Web 应用上下文来指示它委托给 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://localhost?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 发送新消息更新。如果您使用的 IMAP 服务器支持 IDLE 命令，则可以将 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）。您只需要定义服务器实例并将其配置为处理传入请求。Spring 核心框架中的 remoting 模块包含一个用于 HTTP 服务器的方便的工厂 bean：SimpleHttpServerFactoryBean。最重要的属性是 contexts，它将上下文路径映射到相应的 HttpHandler。

Spring Web Services 提供了两种 HttpHandler 接口的实现：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 时，响应将不会发送回客户端。

有一些标准的 EndpointInterceptor 实现可以在你的 Web 服务中使用。此外，还有一个 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 Fault，如下所示

<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 的异常映射到具有故障字符串 "Invalid request" 的客户端 SOAP Fault，如下面的响应所示

<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 Fault。为了使这些注解被拾取，你需要将 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。