WebServiceTemplate 是 Spring-WS 中客户端 Web 服务访问的核心类。它包含发送 Source 对象，以及接收响应消息作为 Source 或 Result 的方法。此外，它可以在通过传输发送对象之前将对象 marshalling 到 XML，并将任何响应 XML 再次 unmarshalling 为对象。

<beans>

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

    <bean id="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
        <constructor-arg ref="messageFactory"/>
        <property name="defaultUri" value="http://example.com/WebService"/>
    </bean>

</beans>

<bean id="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
    <constructor-arg ref="messageFactory"/>
    <property name="messageSender">
        <bean class="org.springframework.ws.transport.http.HttpComponentsMessageSender">
            <property name="credentials">
                <bean class="org.apache.http.auth.UsernamePasswordCredentials">
                    <constructor-arg value="john:secret"/>
                </bean>
            </property>
        </bean>
    </property>
    <property name="defaultUri" value="http://example.com/WebService"/>
</bean>

<beans>

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

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

    <bean id="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
        <constructor-arg ref="messageFactory"/>
        <property name="messageSender">
            <bean class="org.springframework.ws.transport.jms.JmsMessageSender">
                <property name="connectionFactory" ref="connectionFactory"/>
            </bean>
        </property>
        <property name="defaultUri" value="jms:RequestQueue?deliveryMode=NON_PERSISTENT"/>
    </bean>

</beans>

<beans>

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

    <bean id="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
        <constructor-arg ref="messageFactory"/>
        <property name="messageSender">
            <bean class="org.springframework.ws.transport.mail.MailMessageSender">
                <property name="from" value="Spring-WS SOAP Client &lt;[email protected]&gt;"/>
                <property name="transportUri" value="smtp://client:[email protected]"/>
                <property name="storeUri" value="imap://client:[email protected]/INBOX"/>
            </bean>
        </property>
        <property name="defaultUri" value="mailto:[email protected]?subject=SOAP%20Test"/>
    </bean>

</beans>

<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="webServiceTemplate" class="org.springframework.ws.client.core.WebServiceTemplate">
        <constructor-arg ref="messageFactory"/>
        <property name="messageSender">
            <bean class="org.springframework.ws.transport.xmpp.XmppMessageSender">
                <property name="connection" ref="connection"/>
            </bean>
        </property>
        <property name="defaultUri" value="xmpp:[email protected]"/>
    </bean>

</beans>

WebServiceTemplate 包含许多发送和接收 Web 服务消息的便利方法。有些方法接受并返回 Source，有些则返回 Result。此外，还有将对象 marshalling 到 XML 和 unmarshalling 对象的方法。以下是一个向 Web 服务发送简单 XML 消息的示例。

import java.io.StringReader;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.springframework.ws.WebServiceMessageFactory;
import org.springframework.ws.client.core.WebServiceTemplate;
import org.springframework.ws.transport.WebServiceMessageSender;

public class WebServiceClient {

    private static final String MESSAGE =
        "<message xmlns=\"http://tempuri.org\">Hello Web Service World</message>";

    private final WebServiceTemplate webServiceTemplate = new WebServiceTemplate();

    public void setDefaultUri(String defaultUri) {
        webServiceTemplate.setDefaultUri(defaultUri);
    }

    // send to the configured default URI
    public void simpleSendAndReceive() {
        StreamSource source = new StreamSource(new StringReader(MESSAGE));
        StreamResult result = new StreamResult(System.out);
        webServiceTemplate.sendSourceAndReceiveToResult(source, result);
    }

    // send to an explicit URI
    public void customSendAndReceive() {
        StreamSource source = new StreamSource(new StringReader(MESSAGE));
        StreamResult result = new StreamResult(System.out);
        webServiceTemplate.sendSourceAndReceiveToResult("http://localhost:8080/AnotherWebService",
            source, result);
    }

}

<beans xmlns="http://www.springframework.org/schema/beans">

    <bean id="webServiceClient" class="WebServiceClient">
        <property name="defaultUri" value="http://localhost:8080/WebService"/>
    </bean>

</beans>

上述示例使用 WebServiceTemplate 向位于 http://localhost:8080/WebService 的 Web 服务发送一个 hello world 消息（在 simpleSendAndReceive() 方法的情况下），并将结果写入控制台。WebServiceTemplate 被注入了默认 URI，该 URI 被使用是因为在 Java 代码中没有显式提供 URI。

请注意，WebServiceTemplate 类一旦配置完成就是线程安全的（假设它的所有依赖项也是线程安全的，Spring-WS 附带的所有依赖项都是如此），因此如果需要，多个对象可以使用同一个共享的 WebServiceTemplate 实例。WebServiceTemplate 暴露了一个无参构造函数和 messageFactory/messageSender bean 属性，可用于构造实例（使用 Spring 容器或普通 Java 代码）。或者，考虑从 Spring-WS 的 WebServiceGatewaySupport 便利基类派生，它暴露了便利的 bean 属性以方便配置。（你不必继承这个基类...它仅作为便利类提供。）

为了方便发送普通 Java 对象，WebServiceTemplate 有许多 send(..) 方法，这些方法接受 Object 作为消息数据内容的参数。WebServiceTemplate 类中的 marshalSendAndReceive(..) 方法将请求对象到 XML 的转换委托给 Marshaller，并将响应 XML 到对象的转换委托给 Unmarshaller。（有关 marshalling 和 unmarshaller 的更多信息，请参考 Spring 文档。）通过使用 marshaller，你的应用程序代码可以专注于正在发送或接收的业务对象，而无需关心它如何表示为 XML 的细节。为了使用 marshalling 功能，你必须使用 WebServiceTemplate 类的 marshaller/unmarshaller 属性设置 marshaller 和 unmarshaller。

为了适应在消息上设置 SOAP 头和其他设置，WebServiceMessageCallback 接口允许你在消息创建之后、发送之前访问消息。下面的示例演示了如何在一个通过 marshalling 对象创建的消息上设置 SOAP Action 头。

public void marshalWithSoapActionHeader(MyObject o) {

    webServiceTemplate.marshalSendAndReceive(o, new WebServiceMessageCallback() {

        public void doWithMessage(WebServiceMessage message) {
            ((SoapMessage)message).setSoapAction("http://tempuri.org/Action");
        }
    });
}

webServiceTemplate.marshalSendAndReceive(o, new ActionCallback("http://samples/RequestOrder"));

WebServiceMessageExtractor 接口是一个低级 callback 接口，允许你完全控制从接收到的 WebServiceMessage 中提取 Object 的过程。WebServiceTemplate 将在所提供的 WebServiceMessageExtractor 上调用 extractData(..) 方法，同时与服务资源的底层连接仍然打开。以下示例说明了 WebServiceMessageExtractor 的实际应用

public void marshalWithSoapActionHeader(final Source s) {
    final Transformer transformer = transformerFactory.newTransformer();
    webServiceTemplate.sendAndReceive(new WebServiceMessageCallback() {
        public void doWithMessage(WebServiceMessage message) {
            transformer.transform(s, message.getPayloadResult());
        },
        new WebServiceMessageExtractor() {
            public Object extractData(WebServiceMessage message) throws IOException
                // do your own transforms with message.getPayloadResult()
                //     or message.getPayloadSource()
            }
        });
}

Spring Web Services 2.0 引入了创建 Web 服务客户端集成测试的支持。在此上下文中，客户端是使用 WebServiceTemplate 访问 Web 服务的类。

集成测试支持位于 org.springframework.ws.test.client 包中。该包中的核心类是 MockWebServiceServer。其基本思想是 Web 服务模板连接到此模拟服务器，向其发送请求消息，然后模拟服务器根据已注册的期望进行验证。如果满足期望，模拟服务器然后准备一个响应消息，并将其发送回模板。

MockWebServiceServer 的典型用法是

例如，考虑这个 Web 服务客户端类

import org.springframework.ws.client.core.support.WebServiceGatewaySupport;

public class CustomerClient extends WebServiceGatewaySupport {                           

  public int getCustomerCount() {
    CustomerCountRequest request = new CustomerCountRequest();                           
    request.setCustomerName("John Doe");

    CustomerCountResponse response =
      (CustomerCountResponse) getWebServiceTemplate().marshalSendAndReceive(request);    
      
    return response.getCustomerCount();
  }

}

CustomerClient 的典型测试如下所示

import javax.xml.transform.Source;
import org.springframework.beans.factory.annotation.Autowired;
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 static org.junit.Assert.assertEquals;

import org.springframework.ws.test.client.MockWebServiceServer;                          
import static org.springframework.ws.test.client.RequestMatchers.*;                      
import static org.springframework.ws.test.client.ResponseCreators.*;                     

@RunWith(SpringJUnit4ClassRunner.class)                                                  
@ContextConfiguration("integration-test.xml")                                            
public class CustomerClientIntegrationTest {

  @Autowired
  private CustomerClient client;                                                         

  private MockWebServiceServer mockServer;                                               

  @Before
  public void createServer() throws Exception {
    mockServer = MockWebServiceServer.createServer(client);
  }

  @Test
  public void customerClient() 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>");

    mockServer.expect(payload(requestPayload)).andRespond(withPayload(responsePayload)); 

    int result = client.getCustomerCount();                                              
    assertEquals(10, result);                                                            

    mockServer.verify();                                                                 
  }

}

为了验证请求消息是否满足某些期望，MockWebServiceServer 使用 RequestMatcher 策略接口。此接口定义的契约非常简单

public interface RequestMatcher {

  void match(URI uri,
             WebServiceMessage request)
    throws IOException,
           AssertionError;

}

你可以编写此接口的自己的实现，在消息不符合你的期望时抛出 AssertionError，但你当然不必这样做。RequestMatchers 类提供了标准的 RequestMatcher 实现供你在测试中使用。你通常会静态导入这个类。

RequestMatchers 类提供以下请求匹配器

你可以通过链式调用 andExpect() 来设置多个请求期望，如下所示

mockServer.expect(connectionTo("http://example.com")).
 andExpect(payload(expectedRequestPayload)).
 andExpect(validPayload(schemaResource)).
 andRespond(...);

有关 RequestMatchers 提供的请求匹配器的更多信息，请参考类级别 Javadoc。

当请求消息已验证并满足定义的期望时，MockWebServiceServer 将创建一个供 WebServiceTemplate 使用的响应消息。服务器为此目的使用 ResponseCreator 策略接口

public interface ResponseCreator {

  WebServiceMessage createResponse(URI uri,
                                   WebServiceMessage request,
                                   WebServiceMessageFactory messageFactory)
    throws IOException;

}

同样，你可以编写此接口的自己的实现，使用消息工厂创建响应消息，但你当然不必这样做，因为 ResponseCreators 类提供了标准的 ResponseCreator 实现供你在测试中使用。你通常会静态导入这个类。

ResponseCreators 类提供以下响应

有关 RequestMatchers 提供的请求匹配器的更多信息，请参考类级别 Javadoc。