Saturday, August 29, 2009

Spring Web Services - How to - Article contributed to Javalobby -

Spring Webservices encourages a contract first, message oriented approach to creating Webservices. The underlying details are completely under developer control starting from the contract to the marshalling/unmarshalling details to the endpoint handling the request.

Let us start by an example of a simple service to expose as a webservice - call it the MemberService. MemberService exposes one operation “Get Member Details” which returns the details of a member/person, given an identifier.

Creating the contract:

The Contract/WSDL for this service is fairly simple. Let us start by defining the messages and type :

01.<xsd:schema targetNamespace="" elementFormDefault="qualified">
02. <xsd:complexType name="MemberDetailType">
03. <xsd:sequence>
04. <xsd:element name="name" type="xsd:string" />
05. <xsd:element name="phone" type="xsd:string" />
06. <xsd:element name="city" type="xsd:string" />
07. <xsd:element name="state" type="xsd:string" />
08. xsd:sequence>
09. xsd:complexType>
10. <xsd:element name="MemberDetailsRequest">
11. <xsd:complexType>
12. <xsd:sequence>
13. <xsd:element name="id" type="xsd:string" />
14. xsd:sequence>
15. xsd:complexType>
16. xsd:element>
17. <xsd:element name="MemberDetailsResponse">
18. <xsd:complexType>
19. <xsd:sequence>
20. <xsd:element name="memberdetail" type="ms:MemberDetailType" />
21. xsd:sequence>
22. xsd:complexType>
23. xsd:element>

MemberRequest message comprises of an id to represent the requested members identifier

MemberResponse message comprises of MemberDetail type to represent the details of a member.

A sample payload over the wire would look like this:

1.xml version="1.0"?>
2.<ms:MemberDetailsRequest xmlns:ms="">
3. <ms:id>SAMPLEms:id>>

and a sample response:

1.<ms:MemberDetailsResponse xmlns:ms="">
2. <ms:memberdetail>
3. <ms:name>testnamems:name>
4. <ms:city>testcityms:city>
5. <ms:phone>testphonems:phone>
6. <ms:state>teststatems:state>
7. ms:memberdetail>>

The sample request and response can be easily generated by using a tool like SOAP UI –


Creating an Endpoint:

A Spring-WS endpoint processes the XML message and produces the XML response. Spring provides different Endpoints based on how the XML is to be handled. If you wish to handle raw xml you have the option of implementing AbstractDom4jPayloadEndpoint, AbstractDomPayloadEndpoint, AbstractJDomPayloadEndpoint etc, based on how the raw xml needs to be handled. If you wish to handle the XML message as an object representation then you can implement the AbstractMarshallingPayloadEndpoint, which is what I will be using for this example along with JIBX as the XML binding framework for its ease of use and performance.

01.package org.bk.memberservice.endpoint;
03.import org.bk.memberservice.message.MemberDetailsRequest;
04.import org.bk.memberservice.message.MemberDetailsResponse;
05.import org.bk.memberservice.service.MemberManager;
06.import org.bk.memberservice.types.MemberDetail;
09.public class GetMemberDetailsEndpoint extends
10. AbstractMarshallingPayloadEndpoint {
12. private MemberManager memberManager;
14. protected Object invokeInternal(Object requestObject) throws Exception {
15. MemberDetailsRequest request = (MemberDetailsRequest) requestObject;
16. MemberDetail memberDetail = memberManager.getMemberDetails(request
17. .getId());
18. MemberDetailsResponse response = new MemberDetailsResponse(memberDetail);
19. return response;
21. }
23. public void setMemberManager(MemberManager memberManager) {
24. this.memberManager = memberManager;
25. }
The structure of the Endpoint is very simple, it takes an Object which can be cast to MemberDetailsRequest a holder for the request, and the response is returned as an instance of MemberDetailsResponse, a holder for the response details.

Writing the Object/XML binding:

So we now have the endpoint to process the take in the request Message, process it and respond. The only missing piece is how to transform the raw request xml over the wire to the MemberDetailsRequest object, and on the way back to transform the MemberDetailsResponse object back to XML. This is where Springs Object/XML mapping support comes in. Spring Object/XML mapper provides a simple abstraction over the popular Java XML binding stacks like JAXB, Castor, JiBX, Xstream. In the current example, we will start by defining the binding file for JiBX:

01.xml version="1.0" encoding="UTF-8"?>
03. <mapping name="MemberDetailsRequest"
04. class="org.bk.memberservice.message.MemberDetailsRequest">
05. <namespace prefix="ms" uri="" default="all"/>
06. <value name="id" field="id" />
07. mapping>
09. <mapping name="MemberDetailsResponse"
10. class="org.bk.memberservice.message.MemberDetailsResponse">
11. <namespace prefix="ms" uri="" default="all"/>
12. <structure name="memberdetail" field="memberDetail"
13. class="org.bk.memberservice.types.MemberDetail">
14. <value name="name" field="name" />
15. <value name="city" field="city" />
16. <value name="phone" field="phone" />
17. <value name="state" field="state" />
18. structure>
19. mapping>

JiBX requires a compile step with the above binding file, this is very easily wired using Maven as the build tool.

Putting it together:

So now all the pieces are in place -

To direct the request to the appropriate endpoint, Spring-WS requires a custom servlet to be set up:

02. <servlet-name>memberserviceservlet-name>
03. <servlet-class>>
04. <init-param>
05. <param-name>contextConfigLocationparam-name>
06. <param-value>classpath:/applicationContext-memberservice.xmlparam-value>
07. init-param>
11. <servlet-name>memberserviceservlet-name>
12. <url-pattern>/services/*url-pattern>

This would direct all requests starting with serivces/* to be handled by Spring-WS.

The MessageDispatcherServlet would look for a Spring bean with id of “payloadMapping” to direct the incoming XML to an appropriate endpoint, for the example the bean entry is the following:

01.<bean id="payloadMapping"
02. class="">
03. <property name="endpointMap">
04. <map>
05. <entry key="{}MemberDetailsRequest"
06. value-ref="getMemberDetailsEndpoint" />
07. map>
08. property>

Essentially a request with MemberDetailsRequest as the element will be directed to getMemberDetailsEndpoint which is :

1. <bean id="getMemberDetailsEndpoint" class="org.bk.memberservice.endpoint.GetMemberDetailsEndpoint">
2. <property name="marshaller" ref="marshaller" />
3. <property name="unmarshaller" ref="unmarshaller" />
4. <property name="memberManager" ref="memberManager" />

The Endpoint needs the marshaller and unmarshaller to be injected to transform the request XML to request object and the response object to response XML. These are created as follows:

01. "marshaller" class="org.springframework.oxm.jibx.JibxMarshaller">
02. name="targetClass"
03. value="org.bk.memberservice.message.MemberDetailsResponse" />
06. "unmarshaller" class="org.springframework.oxm.jibx.JibxMarshaller">
07. name="targetClass"
08. value="org.bk.memberservice.message.MemberDetailsRequest" />

Exposing the Webservice WSDL:

Since the WSDL was created from scratch, to expose this pre-canned wsdl requires a bit more configuration with Spring:

1.<bean id="MemberDetailsRequest"
2. class="">
3. <property name="wsdl" value="classpath:/memberservice.wsdl" />

Now, when the request comes in for the URI /memberservice/MemberDetailsRequest.wsdl, Spring-WS would serve out the static memberservice.wsdl.

This completes the Webservice implementation. It can be further enhanced to handle the Exception scenarios, Security etc which is an exercise for another day.

The complete example can be run using the attached maven enabled code, which will download all dependencies, and can be run using the following command:

mvn jetty:run


Spring-WS provides a compelling way to create a webservice with a contract first approach. The amount of code appears extensive, however there is clean separation of the contract defined by the WSDL and the implementation, thus being able to change underlying implementation without affecting the contract.