Sun Java System Application Server Enterprise Edition 8.1 2005Q2 Reference Manual

## wsdeploy(1M)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | INPUT WAR FILE | jaxrpc-ri.xml FILE | NAMESPACE MAPPINGS | HANDLERS | SEE ALSO

#### NAME

wsdeploy– reads a `WAR` file and the `jaxrpc-ri.xml` file and generates another `WAR` file that is ready for deployment

#### SYNOPSIS

`wsdeploy `-o` input_WAR_file options`

#### DESCRIPTION

Use the `wsdeploy` command to take a WAR file which does not have implementation specific server side tie classes to generate a deployable WAR file that can be deployed on the application server. `wsdeploy` internally runs `wscompile` with the `-gen:server` option. The `wscompile` command generates classes and a WSDL file which `wsdeploy` includes in the generated WAR file.

Generally, you don't have to run `wsdeploy` because the functions it performs are done automatically when you deploy a WAR with `deploytool` or `asadmin`.

#### OPTIONS

`-classpath path`

  location of the input class files.

`-keep`

  keep temporary files.

`-tmpdir directory`

  use the specified directory as a temporary directory

`-o output WAR file`

  required; location of the generated WAR file. This option is required.

`-source` version

  generates code for the specified JAX-RPC SI version. Supported version are: 1.0.1, 1.0.3, 1.1, 1.1.1, and 1.1.2 (the default).

`-verbose`

  outputs messages about what the compiler is doing.

`-version`

  prints version information.

#### INPUT WAR FILE

The input WAR file for `wsdeploy` will typically have the following structure:

    META-INF/MANIFEST.MF
    WEB-INF/classes/hello/HelloIF.class
    WEB-INF/classes/hello/HelloImpl.class
    WEB-INF/jaxrpc-ri.xml
    WEB-INF/web.xml

Where: HelloIF is the service endpoint interface, and HelloImpl is the class thatimplements the interface. The web.xml file is tghe deployment descriptor of a web component.

#### jaxrpc-ri.xml FILE

The following is a simple HelloWorld service.

    <xml version="1.0" encoding="UTF-8"?>
    <webServices>
         xmlns="http://java.sun.com/xml/ns/jax-rpc/ri/dd"
         version="1.0"
         targetNamespaceBase="http://com.test/wsdl"
         typeNamespaceBase="http://com.test/types"
         urlPatternBase="/ws">
         <endpoint
              name="MyHello"
              displayName="HelloWorld Service"
              description="A simple web service"
              wsdl="/WEB-INF/<wsdlname>
              interface="hello.HelloIF"
              implementation="hello.HelloImpl"/>
         <endpointMapping
              endpointName="MyHello"
              urlPattern="/hello"/>
    </webServices>

The `webServices()` element must contain one or more `endpoint()` elements. The interface and implementation attriutes of `endpoint()` specify the service's interface and iimplementation class. The `endpointMapping()` element associates the service port with the part of the endpoint URL path that follows the `urlPatternBase()`.

#### NAMESPACE MAPPINGS

Here is a schema type name example:

    schemaType="ns1:SampleType"
    xmlns:ns1="http://echoservice.org/types"

When generating a Java type from a schema type, wscompile gets the classname from the local part of the schema type name. To specify the package name of the generated Java classes, you define a mapping between the schema type namespace and the package name. You define this mapping by adding a <namespaceMappingRegistry> element to the config.xml file. For example:

    <service>
         ...
         <namespaceMappingRegistry>
              <namespaceMapping
              namespace="http://echoservice.org/types"
              packageName="echoservice.org.types"/>
              </namespaceMappingRegistry>
         .....
    </service>

You can also map namespaces in the oppisite direction, from schema types to Java types. In this case, the generated schema types are taken from the package that the type comes from.

#### HANDLERS

A handler accesses a SOAP message that represents an RPC request or response. A handler class must implement the `javax.xml.rpc.handler` interface. Because it accesses a SOAP message, a handler can manipulate the message with the APIs of the`javax.xml.soap.package()`.

A handler chain is a list of handlers. You may specify one handler chain for the client and one for the server. On the client, you include the `handlerChains()` element in the `jaxrpc-ri.xml` file. On the server, you include this element in the `config.xml` file. Here is an example of the `handlerChains()` element in the `config.xml`:

    <handlerChains>
      <chain runAt="server"
         roles=
           "http://acme.org/auditing
           "http://acme.org/morphing"
           xmlns:ns1="http://foo/foo-1">
         <handler className="acme.MyHandler"
           headers ="ns1:foo ns1:bar"/>
           <property
              name="property" value="xyz"/>
           </handler>
         </chain>
    </handlerChains>

For more information on handlers, see the SOAP message Handlers chapter of the JAX-PRC specifications.

#### SEE ALSO

wscompile(1M)

J2EE SDK 1.4 Last Revised 22 Dec 2004

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | INPUT WAR FILE | jaxrpc-ri.xml FILE | NAMESPACE MAPPINGS | HANDLERS | SEE ALSO

- © 2010, Oracle Corporation and/or its affiliates