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 服务的第一步，因为 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 服务 bean，例如端点、编组器等。

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

https://127.0.0.1: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://127.0.0.1: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://127.0.0.1?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）。您只需要定义服务器的实例并将其配置为处理传入请求。核心 Spring 框架中的远程处理模块包含一个方便的 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 的支持与其他传输非常相似：有一个 XmppMessageSender 用于 WebServiceTemplate，以及一个 XmppMessageReceiver 用于与 MessageDispatcher 一起使用。

以下示例显示了如何设置服务器端 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 实现。此外，还有 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 类型的异常映射到具有故障字符串 "Invalid request" 的客户端 SOAP 故障，如下面的响应所示

<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);
    }
}

每当在端点调用期间抛出 MyBusinessException 并使用构造函数字符串 "Oops!" 时，都会导致以下响应

<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。