User Commands                                        wsdeploy(1M)

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 gen-
     erate 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 gen-
     erated WAR file.

     Generally, you don't have to run wsdeploy because the  func-
     tions  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 ver-
                             sion are: 1.0.1, 1.0.3, 1.1,  1.1.1,
                             and 1.1.2 (the default).

     -verbose                outputs messages about what the com-
                             piler is doing.

     -version                prints version information.

INPUT WAR FILE
     The input WAR file for wsdeploy will typically have the fol-
     lowing 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  Hel-
     loImpl  is  the  class  thatimplements  the  interface.  The
     web.xml file is tghe deployment descriptor  of  a  web  com-
     ponent.

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  end-
     point() elements. The interface and implementation attriutes
     of endpoint() specify the service's interface and iimplemen-
     tation  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  handler-
     Chains() 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)
