Redstream Blog » Spring WS http://blog.redstream.nl Pragmatic Integrators Mon, 26 Jul 2010 06:09:45 +0000 en hourly 1 http://wordpress.org/?v=8682 Using StAX Parsing with JBoss4.0.5.GA http://blog.redstream.nl/2008/06/18/using-stax-parsing-with-jboss405ga/ http://blog.redstream.nl/2008/06/18/using-stax-parsing-with-jboss405ga/#comments Wed, 18 Jun 2008 12:45:12 +0000 Pascal Alma http://www.pascalalma.net/?p=137 In my former post (here) I described how to combine Spring WS with StAX parsing the SOAP messages. I ended with generating the WSDL as a test and said you could use Soap UI for testing the web service.
Well, I did. And I was running into the following error when I had deployed my web service at JBoss4.0.5.GA:

PLAIN TEXT
XML:
  1. <env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
  2.    <env:Header/>
  3.    <env:Body>
  4.       <env:Fault>
  5.          <faultcode>env:Server</faultcode>
  6.          <faultstring>Operation only supported for javax.xml.soap.Node, this is a [#comment: Test comment]</faultstring>
  7.       </env:Fault>
  8.    </env:Body>
  9. </env:Envelope>


I fixed the issue by adding the following dependencies to the project's pom.xml:

PLAIN TEXT
XML:
  1. <dependency>
  2.     <groupId>com.sun.xml.messaging.saaj</groupId>
  3.     <artifactId>saaj-impl</artifactId>
  4.     <version>1.3</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>javax.activation</groupId>
  8.     <artifactId>activation</artifactId>
  9.     <version>1.1</version>
  10.     <scope>provided</scope>
  11. </dependency>

If I don't add this dependencies, apparently Spring WS is using the JBossWS libraries as default, and these libraries can't handle the StAX parsing/writing abilities of Spring WS.
So, after adding the necessary dependencies and redeploying the web service I got the expected response:

PLAIN TEXT
XML:
  1. <soap-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">
  2.    <soap-ENV:Header/>
  3.    <soap-ENV:Body>
  4.       <hr:HolidayResponse xmlns:hr="http://www.pascalalma.net/hr/schemas">
  5.          <!--Test comment-->
  6.          <hr:Status>APPROVED</hr:Status>
  7.       </hr:HolidayResponse>
  8.    </soap-ENV:Body>
  9. </soap-ENV:Envelope>

I don't know about other J(2)EE Servers but for this JBoss version you need these dependencies to get it working.

]]> http://blog.redstream.nl/2008/06/18/using-stax-parsing-with-jboss405ga/feed/ 0 Using StAX with Spring WS http://blog.redstream.nl/2008/06/14/using-stax-with-spring-ws/ http://blog.redstream.nl/2008/06/14/using-stax-with-spring-ws/#comments Sat, 14 Jun 2008 06:35:12 +0000 Pascal Alma http://www.pascalalma.net/?p=130 As I have posted before we are using XFire to implement our web service. Unfortunately, we are running into some serious issues with the framework, so we decided to look after another implementation. Since XFire is no longer supported by the community (or at least at a very low profile) and 'replaced' by CXF, we decided to have a look at Spring WS. We also have used the Spring Framework throughout our application elsewhere, so this would be a logical choice. After a quick look at the framework it convinced us that this would be the framework to use for our web services. It was easy to set up and well documented.
In this post I will show you how to use StAX to parse and write the SOAP request and response in combination with Spring WS, Maven2 and JBoss.

  1. Setup maven

    2. First thing to do is to setup Maven2. I assume this won't be a problem, so I only show the settings.xml which I use for my Maven2 installation (you can also check out this post and this one):

    PLAIN TEXT
    XML:
    1. <settings>
    2.   <localRepository>d:/maven2/repo/</localRepository>
    3.   <profiles>
    4.     <profile>
    5.       <id>default-repositories</id>
    6.       <repositories>
    7.         <repository>
    8.           <id>global</id>
    9.           <name>External Mirror of Central Repository</name>
    10.           <url>http://repo1.maven.org/maven2</url>
    11.         </repository>
    12.         <repository>
    13.           <id>repo.maven</id>
    14.           <url>http://repo1.maven.org/maven2-repoclean-java.net</url>
    15.         </repository>
    16.         <repository>
    17.           <id>jboss.maven</id>
    18.           <url>http://repository.jboss.com/maven2/</url>
    19.         </repository>
    20.       </repositories>
    21.       <pluginRepositories>
    22.         <pluginRepository>
    23.           <id>repo1org</id>
    24.           <name>External Plugin Repository</name>
    25.           <url>http://repo1.maven.org/maven2/</url>
    26.         </pluginRepository>
    27.       </pluginRepositories>
    28.     </profile>
    29.     <profile>
    30.         <id>dev-environment</id>
    31.         <activation>
    32.         <activeByDefault>true</activeByDefault>
    33.           <property>
    34.             <name>env</name>
    35.             <value>dev</value>
    36.           </property>
    37.         </activation>
    38.         <properties>
    39.           <appserver.home>d:/java/jboss-4.0.5</appserver.home>
    40.           <server.name>default</server.name>
    41.         </properties>
    42.     </profile>
    43.   </profiles>
    44.   <activeProfiles>
    45.     <activeProfile>dev-environment</activeProfile>
    46.     <activeProfile>default-repositories</activeProfile>
    47.   </activeProfiles>
    48. </settings>

  2. Create a Maven2 web project

    3. You can do this with this command (as described in more detail here):
    mvn archetype:create -DgroupId=net.pascalalma -DartifactId=spring-ws-test
    -DarchetypeArtifactId=maven-archetype-webapp

  3. Create the XML Schema's (XSD) for the request and response SOAP messages

    4. As an example I take the schema of the Spring WS reference documentation. The request is described there and I have added a response myself. Here is the xsd:

    PLAIN TEXT
    XML:
    1. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
    2.         xmlns:hr="http://www.pascalalma.net/hr/schemas"
    3.         elementFormDefault="qualified"
    4.         targetNamespace="http://www.pascalalma.net/hr/schemas">
    5.     <xs:element name="HolidayRequest">
    6.         <xs:complexType>
    7.             <xs:all>
    8.                 <xs:element name="Holiday" type="hr:HolidayType"/>
    9.                 <xs:element name="Employee" type="hr:EmployeeType"/>
    10.             </xs:all>
    11.         </xs:complexType>
    12.     </xs:element>
    13.     <xs:complexType name="HolidayType">
    14.         <xs:sequence>
    15.             <xs:element name="StartDate" type="xs:date"/>
    16.             <xs:element name="EndDate" type="xs:date"/>
    17.         </xs:sequence>
    18.     </xs:complexType>
    19.     <xs:complexType name="EmployeeType">
    20.         <xs:sequence>
    21.             <xs:element name="Number" type="xs:integer"/>
    22.             <xs:element name="FirstName" type="xs:string"/>
    23.             <xs:element name="LastName" type="xs:string"/>
    24.         </xs:sequence>
    25.     </xs:complexType>
    26.     <xs:element name="HolidayResponse" type="hr:Status" />
    27.     <xs:simpleType name="Status">
    28.       <xs:restriction base="xs:string">
    29.         <xs:enumeration value="DENIED"/>
    30.         <xs:enumeration value="PENDING"/>
    31.         <xs:enumeration value="APPROVED"/>
    32.       </xs:restriction>
    33.     </xs:simpleType>
    34. </xs:schema>

    I have stored this schema as 'hr.xsd' in the directory '$PROJECT_HOME$/WEB-INF/schema'.

  4. Configure the web application

    5. We have to reroot the incoming HTTP request to the Spring WS servlet. TO do this we define the Spring WS servlet in the web.xml, like this:

    PLAIN TEXT
    XML:
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    3.   "http://java.sun.com/dtd/web-app_2_3.dtd">
    4. <web-app>
    5.     <!-- === Servlets === -->
    6.     <servlet>
    7.         <servlet-name>spring-ws</servlet-name>
    8.         <display-name>Spring-WS Servlet</display-name>
    9.         <servlet-class>
    10.             org.springframework.ws.transport.http.MessageDispatcherServlet
    11.         </servlet-class>
    12.         <init-param>
    13.             <param-name>transformWsdlLocations</param-name>
    14.             <param-value>true</param-value>
    15.         </init-param>
    16.     </servlet>
    17.     <servlet-mapping>
    18.         <servlet-name>spring-ws</servlet-name>
    19.         <url-pattern>/services/*</url-pattern>
    20.     </servlet-mapping>
    21.     <welcome-file-list id="WelcomeFileList">
    22.         <welcome-file>index.html</welcome-file>
    23.     </welcome-file-list>
    24. </web-app>

  5. Create model classes

    6. Now it's time to start some Java coding. First I create the model classes that will represent the Objects as described by the xsd. We will have the following classes:
    The Employee.java
    The Holiday.java
    And the HolidayRequest.java

  6. Create the StAX parser and writer classes

    7. To get from the incoming XML to our Java model classes we make use of StAX parsing and writing. Here are the two classes that do the XML-Object translation and back:
    HolidayRequestReader.java
    HolidayResponseWriter.java

  7. Implement endpoint/webservice

    8. The last Java class we have to make is the Webservice implementation itself. Since we want to use StAX parsing, I simply extend the Spring class 'AbstractStaxStreamPayloadEndpoint':

    PLAIN TEXT
    JAVA:
    1. package net.pascalalma.ws;
    2.  
    3. import javax.xml.stream.XMLStreamReader;
    4. import javax.xml.stream.XMLStreamWriter;
    5.  
    6. import net.pascalalma.model.HolidayRequest;
    7. import net.pascalalma.xml.HolidayRequestReader;
    8. import net.pascalalma.xml.HolidayResponseWriter;
    9.  
    10. import org.apache.commons.logging.Log;
    11. import org.apache.commons.logging.LogFactory;
    12. import org.springframework.ws.server.endpoint.AbstractStaxStreamPayloadEndpoint;
    13.  
    14. public class HolidayRequestService extends AbstractStaxStreamPayloadEndpoint
    15. {
    16.  
    17.   private static final Log LOG = LogFactory.getLog(HolidayRequestService.class);
    18.  
    19.   @Override
    20.   protected void invokeInternal(XMLStreamReader streamreader,
    21.       XMLStreamWriter streamwriter) throws Exception
    22.   {
    23.     try
    24.     {
    25.       HolidayRequest hr = HolidayRequestReader.parseMessage(streamreader);
    26.  
    27.       LOG.info("Result = " + hr);
    28.  
    29.       HolidayResponseWriter.writeResponse(hr, streamwriter);
    30.     } catch (Throwable t)
    31.     {
    32.       LOG.error("Catched exception", t);
    33.     }
    34.   }
    35. }

  8. Setup the SpringWS context

    9. Now that we have all the Java classes in place we have to configure the Spring context that is used by our webservice implementation. In our case it looks like the following XML file that is stored under the name 'spring-ws-servlet' in the '$PROJECT_HOME$/webapp/WEB-INF' directory:

    PLAIN TEXT
    XML:
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    5.     <bean
    6.         class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
    7.         <property name="mappings">
    8.             <props>
    9.                 <prop
    10.                     key="{http://www.pascalalma.net/hr/schemas}HolidayRequest">
    11.                     myEndPoint
    12.                 </prop>
    13.             </props>
    14.         </property>
    15.     </bean>
    16.     <bean id="myEndPoint"
    17.         class="net.pascalalma.ws.HolidayRequestService">
    18.     </bean>
    19.     <bean id="holiday"
    20.         class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
    21.         <property name="schema" ref="schema" />
    22.         <property name="portTypeName" value="HumanResource" />
    23.         <property name="locationUri"
    24.             value="http://localhost:8080/spring-ws-test/services/holidayService/" />
    25.         <property name="targetNamespace"
    26.             value="http://www.pascalalma.net/hr/definitions" />
    27.     </bean>
    28.     <bean id="schema"
    29.         class="org.springframework.xml.xsd.SimpleXsdSchema">
    30.         <property name="xsd" value="/WEB-INF/schemas/hr.xsd" />
    31.     </bean>
    32. </beans>

  9. Build and deploy to jboss

    10. With this file as the project's POM file we can simply build, package and deploy our webservice to JBoss with the command in the command prompt:
    mvn clean package jboss:harddeploy

  10. Access wsdl in browser to test

    11. If everything went well and JBoss is started, you can access the dynamically generated WSDL with the following url:
    http://localhost:8080/spring-ws-test/services/holiday.wsdl
    This should give the following WSDL in your browser:

    PLAIN TEXT
    XML:
    1. <wsdl:definitions targetNamespace="http://www.pascalalma.net/hr/definitions">
    2.   <wsdl:types>
    3.     <xs:schema elementFormDefault="qualified" targetNamespace="http://www.pascalalma.net/hr/schemas">
    4.       <xs:element name="HolidayRequest">
    5.         <xs:complexType>
    6.           <xs:all>
    7.             <xs:element name="Holiday" type="hr:HolidayType"/>
    8.             <xs:element name="Employee" type="hr:EmployeeType"/>
    9.           </xs:all>
    10.         </xs:complexType>
    11.       </xs:element>
    12.       <xs:complexType name="HolidayType">
    13.         <xs:sequence>
    14.           <xs:element name="StartDate" type="xs:date"/>
    15.           <xs:element name="EndDate" type="xs:date"/>
    16.         </xs:sequence>
    17.       </xs:complexType>
    18.       <xs:complexType name="EmployeeType">
    19.         <xs:sequence>
    20.           <xs:element name="Number" type="xs:integer"/>
    21.           <xs:element name="FirstName" type="xs:string"/>
    22.           <xs:element name="LastName" type="xs:string"/>
    23.         </xs:sequence>
    24.       </xs:complexType>
    25.       <xs:element name="HolidayResponse" type="hr:Status"/>
    26.       <xs:simpleType name="Status">
    27.         <xs:restriction base="xs:string">
    28.           <xs:enumeration value="DENIED"/>
    29.           <xs:enumeration value="PENDING"/>
    30.           <xs:enumeration value="APPROVED"/>
    31.         </xs:restriction>
    32.       </xs:simpleType>
    33.     </xs:schema>
    34.   </wsdl:types>
    35.   <wsdl:message name="HolidayResponse">
    36.     <wsdl:part element="sch:HolidayResponse" name="HolidayResponse">
    37.     </wsdl:part>
    38.   </wsdl:message>
    39.   <wsdl:message name="HolidayRequest">
    40.     <wsdl:part element="sch:HolidayRequest" name="HolidayRequest">
    41.     </wsdl:part>
    42.   </wsdl:message>
    43.   <wsdl:portType name="HumanResource">
    44.     <wsdl:operation name="Holiday">
    45.       <wsdl:input message="tns:HolidayRequest" name="HolidayRequest">
    46.       </wsdl:input>
    47.       <wsdl:output message="tns:HolidayResponse" name="HolidayResponse">
    48.       </wsdl:output>
    49.     </wsdl:operation>
    50.   </wsdl:portType>
    51.   <wsdl:binding name="HumanResourceSoap11" type="tns:HumanResource">
    52.     <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
    53.     <wsdl:operation name="Holiday">
    54.       <soap:operation soapAction=""/>
    55.       <wsdl:input name="HolidayRequest">
    56.         <soap:body use="literal"/>
    57.       </wsdl:input>
    58.       <wsdl:output name="HolidayResponse">
    59.         <soap:body use="literal"/>
    60.       </wsdl:output>
    61.     </wsdl:operation>
    62.   </wsdl:binding>
    63.   <wsdl:service name="HumanResourceService">
    64.     <wsdl:port binding="tns:HumanResourceSoap11" name="HumanResourceSoap11">
    65.       <soap:address location="http://localhost:8080/spring-ws-test/services/holidayService/"/>
    66.     </wsdl:port>
    67.   </wsdl:service>
    68. </wsdl:definitions>

    That's it. You can test your web service with a tool like SoapUI and create test cases based on the generated WSDL like I described here.

    ]]> http://blog.redstream.nl/2008/06/14/using-stax-with-spring-ws/feed/ 6