Where to use wsgen?

Question

Don't seem to know where (what directory - source or classes) to properly use wsgen against my WebService class...

Create a sample document literal based WebService:

package hello;

import javax.jws.WebService;

@WebService
public class HelloWorld {

public void sayHello() {
        System.out.println("Welcome to JAX-WS 2!");
    }
}

Created the Publisher like this:

package hello;

import javax.xml.ws.Endpoint;

public class Publisher {
    public static void main(String[] args) {
        Endpoint.publish("http://localhost:8080/jaxws/hello", new HelloWorld());
    }
}

Using Eclipse Helios, I automatically build both of these files as *.classes underneath the corresponding classes directory.

So, from the filesystem, my project looks like this:

/code/jws_sample
          |
          src
             |
              hello
                  |
                  HelloWorld.java
                  Publisher.java
          |
           classes
                    |
                    HelloWorld.class
                    Publisher.class

In which directory would I run wsgen?

When I tried it inside:

/code/jaxws_sample/src/wsgen -cp . hello.HelloWorld

Received:

  Class not found: "hello.HelloWorld"

  Usage: WSGEN [options] <SEI>

  where [options] include:

  -classpath <path>          specify where to find input class files

  -cp <path>                 same as -classpath &lt;path&gt;

  -d <directory>             specify where to place generated output files

  -extension                       
                             allow vendor extensions - functionality not specified
                             by the specification.  Use of extensions may
                             result in applications that are not portable or
                             may not interoperate with other implementations
   -help                     display help

   -keep                     keep generated files

   -r <directory>            resource destination directory, specify where to
                             place resouce files such as WSDLs

   -s <directory>            specify where to place generated source files

   -verbose                  output messages about what the compiler is doing

   -version                  print version information

   -wsdl[:protocol]          generate a WSDL file. The protocol is optional.
                             Valid protocols are [soap1.1, Xsoap1.2],
                             the default is soap1.1.
                             The non stanadard protocols [Xsoap1.2]
                             can only be used in conjunction with the
                             -extension option.

   -servicename <name>       specify the Service name to use in the generated WSDL
                             Used in conjunction with the -wsdl option.

   -portname <name>          specify the Port name to use in the generated WSDL
                             Used in conjunction with the -wsdl option.

   Examples:

   wsgen -cp . example.Stock
   wsgen -cp . example.Stock -wsdl -servicename {http://mynamespace}MyService

It actually does show me the WSDL in a browser and also when I tried to issue the wsgen command from $MyProject/classes it actually did create a jaxws folder with the SayHelloResponse.class files but not the SayHelloResponse.java files?

Thank you for taking the time to read this.

Answer 1

It looks like you have to compile the files into class files first and then feed them to wsgen.

classpath <path>          specify where to find input **class files**

I could be wrong, but I believe I had to do the same in the past.

Thanks,

Jeffrey Kevin Pry

Answer 2

You need to enable '-keep' and you can optionally specify '-s /path/to/src' to save the JAXWS generated files. Since these are generated files, best practice typically guides you to not keep the files around and to only generate them for packaging. The downside of keeping the files and perhaps editing them is that if you regenerate the files your changes could be lost.

For example, I have a JAX-WS endpoint that is defined in a Maven project and the WSGEN goal is called each time the service is being packaged.