Redstream Blog » JAX-WS http://blog.redstream.nl Pragmatic Integrators Mon, 26 Jul 2010 06:09:45 +0000 en hourly 1 http://wordpress.org/?v=5767 Mule2, CXF and serializable classes http://blog.redstream.nl/2009/07/01/mule2-cxf-and-serializable-classes/ http://blog.redstream.nl/2009/07/01/mule2-cxf-and-serializable-classes/#comments Wed, 01 Jul 2009 19:25:17 +0000 Pascal Alma http://www.pascalalma.net/?p=890 This post is one of the series of posts about issues that occurred when we were using Mule2 in a real life project. As I wrote in my last post we were using CXF to call a webservice with Mule. After the issues we ran into as described in that article, we ended up with the folowing issue. The generated classes that are used for the XML to Java mapping has to be serializable. This is possible by using a binding file when generating the classes with Maven as described in the documentation here.
However, I haven’t been able to do this in my situation. And according to this post I am not the only one. So to keep the project moving I decided to make use of Metro JAX-WS instead of CXF, since this CXF thing had cost us enough of our precious time. With the Metro implementation we had it running in no time without any unexpected issues.

]]> http://blog.redstream.nl/2009/07/01/mule2-cxf-and-serializable-classes/feed/ 2 Make Serializable JAX-WS clients with Maven2 http://blog.redstream.nl/2009/03/14/make-serializable-jax-ws-clients-with-maven2/ http://blog.redstream.nl/2009/03/14/make-serializable-jax-ws-clients-with-maven2/#comments Sat, 14 Mar 2009 20:24:30 +0000 Pascal Alma http://www.pascalalma.net/?p=667 As I described here I am using JAXWS' wsimport function to generate a Webservice interface and the JAXB objects for my application. The generated JAXB objects are also used as parameters for some remote EJB calls. Therefore I had to make the JAXB objects serializable. But the question is how to do this since these classes are generated.
Well, in these situations Google is your friend. After a short search I found out to perform the following steps:

  1. Create a binding file and add the xjc:serializable option to it.

    2. It will look like this:

    PLAIN TEXT
    XML:
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
    3. xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
    4. xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
    5. elementFormDefault="qualified" attributeFormDefault="unqualified"
    6. jaxb:extensionBindingPrefixes="xjc" jaxb:version="2.1">
    7.     <xs:annotation>
    8.         <xs:appinfo>
    9.             <jaxb:globalBindings>
    10.                 <xjc:serializable />
    11.             </jaxb:globalBindings>
    12.         </xs:appinfo>
    13.     </xs:annotation>
    14. </xs:schema>

    I name the file 'jaxb-bindings.xml' and added it to the resources directory of my Maven project.

  2. Setup the JAX-WS Maven plugin like this:
    3. PLAIN TEXT
    XML:
    1. ...
    2. <!-- Plugin to generate JAXB classes and webservice interface -->
    3. <plugin>
    4.   <groupId>org.codehaus.mojo</groupId>
    5.   <artifactId>jaxws-maven-plugin</artifactId>
    6.   <version>1.10</version>
    7.   <executions>
    8.     <execution>
    9.       <goals>
    10.         <goal>wsimport</goal>
    11.       </goals>
    12.     </execution>
    13.   </executions>
    14.   <configuration>
    15.     <wsdlDirectory>src/main/resources/wsdl</wsdlDirectory>
    16.     <sourceDestDir>${basedir}/generated/src/main/java</sourceDestDir>
    17.     <bindingFiles>
    18.        <bindingFile>${basedir}/src/main/resources/jaxb/jaxb-bindings.xml</bindingFile>
    19.      </bindingFiles>
    20.    </configuration>
    21.    <dependencies>
    22.      <dependency>
    23.        <groupId>javax.jws</groupId>
    24.        <artifactId>jsr181-api</artifactId>
    25.        <version>1.0-MR1</version>
    26.      </dependency>
    27.    </dependencies>
    28.  </plugin>
    29.  ...

    This configuration looks similar to the one I had except of course the 'bindingFiles' part.

That's it! If you generate the sources again by running 'mvn clean install' and check the generated files you will see that now they implement the Serializable interface.

]]> http://blog.redstream.nl/2009/03/14/make-serializable-jax-ws-clients-with-maven2/feed/ 1 'Hello World' with Glassfish, Metro and Maven http://blog.redstream.nl/2009/03/09/hello-world-with-glassfish-metro-and-maven/ http://blog.redstream.nl/2009/03/09/hello-world-with-glassfish-metro-and-maven/#comments Mon, 09 Mar 2009 11:47:44 +0000 Pascal Alma http://www.pascalalma.net/?p=576 As might be clear by my latest posts I am currently working on a project where we use Glassfish and EJB3 as platform for our JEE application. One thing that we had to decide upon was the WebService framework we were going to use. There are quite some options available but I decided to have a look at Metro, the JAX-WS reference implementation. Also due to the fact that it is integrated with EJB3 and Glassfish.
To create my 'HelloWorld' service with Metro and Maven2 I used this post as a guideline. I am also going to work top-down (WSDL -> Java approach) so I will be starting with an existing WSDL and then generate/create the web service interface for that. Although the post I used as a guideline is very detailed I ran into some issues, mostly the result of using different versions of dependencies and plugins. In this post I show the steps I made to get it working. I am using Glassfish-v2ur2 (comes with Netbeans 6.5) , JDK1.5 and Maven 2.0.9.

  1. Create the Maven2 project

    2. Issue the command: mvn archetype:create -DgroupId=net.pascalalma.ws -DartifactId=echo-service
    This results in a standard Maven project. I removed the generated java files since we don't need them.

  2. Setup the pom

    3. The default pom that was created in the first step has to be modified. I added several things which I explain next:

    PLAIN TEXT
    XML:
    1. <dependencies>
    2.         ...
    3.         <dependency>
    4.             <groupId>com.sun.xml.ws</groupId>
    5.             <artifactId>jaxws-rt</artifactId>
    6.             <version>2.1.4</version>
    7.         </dependency>
    8.         <dependency>
    9.             <groupId>javax.jws</groupId>
    10.             <artifactId>jsr181-api</artifactId>
    11.             <version>1.0-MR1</version>
    12.         </dependency>
    13.     ...
    14.     </dependencies>

    These are dependencies that are used by the JAXWS plugin, which is used to generate the Webservice interface based on the supplied WSDL.

    PLAIN TEXT
    XML:
    1. <dependencies>
    2.    ...
    3.         <dependency>
    4.             <groupId>glassfish</groupId>
    5.             <artifactId>appserv-rt.jar</artifactId>
    6.             <version>LATEST</version>
    7.             <scope>system</scope>
    8.             <systemPath>${glassfish.home}/lib/appserv-rt.jar</systemPath>
    9.         </dependency>
    10.         <dependency>
    11.             <groupId>glassfish</groupId>
    12.             <artifactId>javaee.jar</artifactId>
    13.             <version>LATEST</version>
    14.             <scope>system</scope>
    15.             <systemPath>${glassfish.home}/lib/javaee.jar</systemPath>
    16.         </dependency>
    17.    ...
    18.    </dependencies>

    These dependencies are used to compile the generated code and the WebService implementation class.

    Next there are some plugins to be configured:

    PLAIN TEXT
    XML:
    1. <build>
    2.         <plugins>
    3.         ...
    4.             <!-- Plugin to generate JAXB classes and webservice interface -->
    5.             <plugin>
    6.                 <groupId>org.codehaus.mojo</groupId>
    7.                 <artifactId>jaxws-maven-plugin</artifactId>
    8.                 <version>1.10</version>
    9.                 <executions>
    10.                     <execution>
    11.                         <goals>
    12.                             <goal>wsimport</goal>
    13.                         </goals>
    14.                     </execution>
    15.                 </executions>
    16.                 <configuration>
    17.                     <wsdlDirectory>
    18.                         src/main/resources/wsdl
    19.                     </wsdlDirectory>
    20.                     <sourceDestDir>
    21.                         ${basedir}/generated/src/main/java
    22.                     </sourceDestDir>
    23.                 </configuration>
    24.                 <dependencies>
    25.                     <dependency>
    26.                         <groupId>javax.jws</groupId>
    27.                         <artifactId>jsr181-api</artifactId>
    28.                         <version>1.0-MR1</version>
    29.                     </dependency>
    30.                 </dependencies>
    31.             </plugin>
    32.             ...
    33.         </plugins>
    34.     </build>

    This plugin is used for the actual generation of the Java code. It will put the code in the 'generated' folder.
    The next two plugins are used for compiling and cleaning the code. I have described the use of these plugins here.

    PLAIN TEXT
    XML:
    1. <build>
    2.         <plugins>
    3.         ...
    4.             <!-- Plugin to add delete path to build cycle -->
    5.             <plugin>
    6.                 <artifactId>maven-clean-plugin</artifactId>
    7.                 <version>2.2</version>
    8.                 <configuration>
    9.                     <filesets>
    10.                         <fileset>
    11.                             <directory>generated/src/main/java</directory>
    12.                             <includes>
    13.                                 <include>**/*.java</include>
    14.                             </includes>
    15.                         </fileset>
    16.                     </filesets>
    17.                 </configuration>
    18.             </plugin>
    19.         </plugins>
    20.     </build>
    21.     ...
    22.   </plugins>
    23. </build>

    And finally I add the necessary code to tell the compiler JDK 1.5 has to be used:

    PLAIN TEXT
    XML:
    1. <build>
    2.         <plugins>
    3.         ...
    4.              <!-- plugin to compile Java1.5 code -->
    5.              <plugin>
    6.                 <groupId>org.apache.maven.plugins</groupId>
    7.                 <artifactId>maven-compiler-plugin</artifactId>
    8.                 <version>2.0.2</version>
    9.                 <configuration>
    10.                     <source>1.5</source>
    11.                     <target>1.5</target>
    12.                 </configuration>
    13.             </plugin>
    14.         ...
    15.        </plugins>
    16.   </build>

    The complete pom.xml can be found here.

  3. Create the WSDL

    4. As shown in the plugin configuration I have added a WSDL file to a 'wsdl' folder in the 'resource' folder. The WSDL looks like this:

    PLAIN TEXT
    XML:
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <wsdl:definitions name="DoubleIt"
    3.    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    4.    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    5.    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
    6.    xmlns:tns="http://www.pascalalma.net/EchoIt"
    7.    xmlns:types="http://www.pascalalma.net/EchoIt/types"
    8.    targetNamespace="http://www.pascalalma.net/EchoIt">
    9.     <wsdl:types>
    10.         <xsd:schema targetNamespace="http://www.pascalalma.net/EchoIt/types">
    11.             <xsd:element name="EchoIt">
    12.                 <xsd:complexType>
    13.                     <xsd:sequence>
    14.                         <xsd:element name="textToEcho" type="xsd:string"/>
    15.                     </xsd:sequence>
    16.                 </xsd:complexType>
    17.             </xsd:element>
    18.             <xsd:element name="EchoItResponse">
    19.                 <xsd:complexType>
    20.                     <xsd:sequence>
    21.                         <xsd:element name="echoedText" type="xsd:string" />
    22.                     </xsd:sequence>
    23.                 </xsd:complexType>
    24.             </xsd:element>
    25.         </xsd:schema>
    26.     </wsdl:types>
    27.     <wsdl:message name="EchoItRequest">
    28.         <wsdl:part element="types:EchoIt" name="parameters" />
    29.     </wsdl:message>
    30.     <wsdl:message name="EchoItResponse">
    31.         <wsdl:part element="types:EchoItResponse" name="parameters" />
    32.     </wsdl:message>
    33.     <wsdl:portType name="EchoItPortType">
    34.         <wsdl:operation name="EchoIt">
    35.             <wsdl:input message="tns:EchoItRequest" />
    36.             <wsdl:output message="tns:EchoItResponse" />
    37.         </wsdl:operation>
    38.     </wsdl:portType>
    39.     <wsdl:binding name="EchoItBinding" type="tns:EchoItPortType">
    40.         <soap:binding style="document"
    41.          transport="http://schemas.xmlsoap.org/soap/http" />
    42.         <wsdl:operation name="EchoIt">
    43.             <soap:operation soapAction=""/>
    44.             <wsdl:input>
    45.                 <soap:body use="literal"/>
    46.             </wsdl:input>
    47.             <wsdl:output>
    48.                 <soap:body use="literal"/>
    49.             </wsdl:output>
    50.         </wsdl:operation>
    51.     </wsdl:binding>
    52.     <wsdl:service name="EchoItService">
    53.         <wsdl:port name="EchoItPort" binding="tns:EchoItBinding">
    54.             <soap:address
    55.             location="http://localhost:8080/echoit/echoit"/>
    56.         </wsdl:port>
    57.     </wsdl:service>
    58. </wsdl:definitions>

  4. Generate the code

    5. When all this is in place we can generate the Java code by simply issue the command:
    mvn clean install
    In Netbeans we can see the generated code in our project browser:

  5. Create Web Service implementation

    6. Next step is to create the implementation class for the web service. Please note that I will create a EJB Web Service endpoint. This way I don't need a web container nor any web deployment descriptor.
    Here is the web service implementation:

    PLAIN TEXT
    JAVA:
    1. package net.pascalalma.ws;
    2.  
    3. import javax.ejb.Stateless;
    4. import javax.jws.WebService;
    5.  
    6. /**
    7. * Hello world!
    8. *
    9. */
    10. @WebService(targetNamespace = "http://www.pascalalma.net/EchoIt",
    11.             portName="EchoItPort",
    12.             serviceName="EchoItService",
    13.             endpointInterface="net.pascalalma.echoit.EchoItPortType")
    14. @Stateless
    15. public class EchoServiceImpl
    16. {
    17.     public String echoIt(String it)
    18.     {
    19.         return "Echo " + it +"!";
    20.     }
    21. }

  6. Deploy it to Glassfish

    7. With the implementation in place rebuild the project so a ejb-jar is created. Again issue the command:
    mvn clean install
    The created jar file in the 'target' directory can then be deployed to Glassfish. This can be done by using a Maven plugin as described here or by using the Glassfish Admin Console. I used the last one in this case. It should look similar to this after successful deployment:

  7. Test the service

    8. The easiest way to test it is, if you already have the Glassfish Admin Console open, to click the 'test' button and fill in a text as input parameter. As result you should get something like:

Well, if you did the things as I described you have a big chance it will work in one time, but in my case there were some problems when trying to get this to work. Some of the Issues I ran into while building the projects:

  1. Missing dependencies

    2. Missing:
    ----------
    1) com.sun.xml.ws:jaxws-tools:jar:2.1.5

    I had to use another plugin version then the one that is recommended at the plugin homepage:

    PLAIN TEXT
    XML:
    1. <plugin>
    2.                 <groupId>org.codehaus.mojo</groupId>
    3.                 <artifactId>jaxws-maven-plugin</artifactId>
    4.                 <version>1.10</version>
    5.      ...
    6.    </plugin>

  2. More missing libraries

    3. I then ran into this one:

    org.apache.maven.lifecycle.LifecycleExecutionException: Error executing: wsimport [-s, /Users/pascal/projects/metro-service/echo-service/target/generated, -d, /Users/pascal/projects/metro-service/echo-service/target/classes, /Users/pascal/projects/metro-service/echo-service/src/main/webapp/WEB-INF/wsdl/echo-it.wsdl]
    ...

    See also this thread.

    It appears it has something to do with JDK1.5 instead of JDK1.6. I solved it by adding the dependencies for the JSR181.

I hope that this posts avoids the exceptions which I encountered and make the use of JAXWS with Maven more smoothly because in the end it is a very nice solution!

]]> http://blog.redstream.nl/2009/03/09/hello-world-with-glassfish-metro-and-maven/feed/ 2