Google Git
Sign in
apache / axis-axis2-java-core / 235edbf06a55a4c090568958f242512054c8ec37 / . / src / site / xdoc / tools / CodegenToolReference.xml
blob: 47d3b6da0c01e2b2b4b236ac6c1048c32e5280ed [file] [log] [blame]
<!--
~ Licensed to the Apache Software Foundation (ASF) under one
~ or more contributor license agreements. See the NOTICE file
~ distributed with this work for additional information
~ regarding copyright ownership. The ASF licenses this file
~ to you under the Apache License, Version 2.0 (the
~ "License"); you may not use this file except in compliance
~ with the License. You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 14 June 2007), see www.w3.org" />
<meta http-equiv="content-type" content="" />
<title>Code Generator Tool Guide for Command Line and Ant
Task</title>
</head>
<body lang="en" xml:lang="en">
<h1>Code Generator Tool Guide for Command Line and Ant Task</h1>
<p>The Code Generator tool consists of a command line version and
an Ant Task. This document will list the command line references
and Ant task references. Also in detail, this document shows how to
build file using custom Ant task and invoking the Code Generator
from Ant.</p>
<p>This tool is bundled with the <a href="../download.cgi#std-bin">Axis2 Binary
Distribution</a>.</p>
<h2>Content</h2>
<ul>
<li><a href="#intro">Introduction</a></li>
<li><a href="#cmdline">Command Line Version</a>
<ul>
<li><a href="#cmdref">Option Reference</a></li>
</ul>
</li>
<li><a href="#ant">Ant Task</a>
<ul>
<li><a href="#antref">Ant Task Reference</a></li>
<li><a href="#example">Example Build File Using the Custom Ant
Task</a></li>
<li><a href="#invoking">Invoking the Code Generator From
Ant</a></li>
</ul>
</li>
<li><a href="#appendix">Appendix</a></li>
</ul>
<a name="intro" id="intro"></a>
<h2>Introduction</h2>
<p>This basic tool is implemented by the WSDL2Code class and just
for the convenience in the case of Java (which would be the
majority) there is another WSDL2Java class. One can choose to run
the main classes directly or use one of the scripts to run the
WSDL2Code and WSDL2Java appropriately. (the scripts are found in
the bin directory of the <a href=
"../download.cgi#std-bin">Standard Binary
Distribution</a>)</p>
<a name="cmdline" id="cmdline"></a>
<h2>Command Line Version</h2>
<p>For those users who wish to use the command line version of the
tool, this section will be of value.</p>
<a name="cmdref" id="cmdref"></a>
<h3>Option Reference</h3>
<p>Usage WSDL2Code &lt;option_reference&gt;</p>
<p><b>E.g. :- WSDL2Code -uri &lt;Location of WSDL&gt;</b></p>
<table>
<tbody>
<tr>
<td width="20%"><strong>Short Option</strong></td>
<td width="20%"><strong>Long Option</strong></td>
<td width="60%"><strong>Description</strong></td>
<td></td>
</tr>
<tr>
<td width="20%">-uri &lt;Location of WSDL&gt;</td>
<td width="20%">None</td>
<td width="60%">WSDL file location. This should point to a WSDL
file in the local file system.</td>
<td></td>
</tr>
<tr>
<td width="20%">-o &lt;output Location&gt;</td>
<td width="20%">--output &lt;output Location&gt;</td>
<td width="60%">Output file location. This is where the files would
be copied once the code generation is done. If this option is
omitted the generated files would be copied to the working
directory.</td>
<td></td>
</tr>
<tr>
<td width="20%">-l &lt;language&gt;</td>
<td width="20%">--language &lt;language&gt;</td>
<td width="60%">Output language. Currently the code generator can
generate code in Java but it has the ability to be extended to
support other languages.</td>
<td></td>
</tr>
<tr>
<td width="20%">-p &lt;package name&gt;</td>
<td width="20%">--package &lt;package name&gt;</td>
<td width="60%">The target package name. If omitted, a default
package (formed using the target namespace of the WSDL) will be
used.</td>
<td></td>
</tr>
<tr>
<td width="20%">-a</td>
<td width="20%">--async</td>
<td width="60%">Generate code only for async style. When this
option is used the generated stubs will have only the asynchronous
invocation methods. Switched off by default.</td>
<td></td>
</tr>
<tr>
<td width="20%">-s</td>
<td width="20%">--sync</td>
<td width="60%">Generate code only for sync style . When this
option is used the generated stubs will have only the synchronous
invocation methods. Switched off by default. When used with the -a
option, this takes precedence.</td>
<td></td>
</tr>
<tr>
<td width="20%">-t</td>
<td width="20%">--test-case</td>
<td width="60%">Generates a test case. In the case of Java it would
be a JUnit test case.</td>
<td></td>
</tr>
<tr>
<td width="20%">-ss</td>
<td width="20%">--server-side</td>
<td width="60%">Generates server side code (i.e. skeletons).
Default is off.</td>
<td></td>
</tr>
<tr>
<td width="20%">-sd</td>
<td width="20%">--service-description</td>
<td width="60%">Generates the service descriptor (i.e. server.xml).
Default is off. Only valid with -ss, the server side code
generation option.</td>
<td></td>
</tr>
<tr>
<td width="20%">-d &lt;databinding&gt;</td>
<td width="20%">--databinding-method &lt;databinding&gt;</td>
<td width="60%">Specifies the Databinding framework. Valid values
are xmlbeans, adb, jibx, and none. Default is adb.</td>
<td></td>
</tr>
<tr>
<td width="20%">-g</td>
<td width="20%">--generate-all</td>
<td width="60%">Generates all the classes. This option is valid
only with the -ss (server side code generation) option. When on,
the client code (stubs) will also be generated along with the
skeleton.</td>
<td></td>
</tr>
<tr>
<td width="20%">-u</td>
<td width="20%">--unpack-classes</td>
<td width="60%">Unpack classes. This option specifies whether to
unpack the classes and generate separate classes for the
databinders.</td>
<td></td>
</tr>
<tr>
<td width="20%">-sn &lt;service name&gt;</td>
<td width="20%">--service-name &lt;service name&gt;</td>
<td width="60%">Specifies the service name to be code generated. If
the service name is not specified, then the first service will be
picked.</td>
<td></td>
</tr>
<tr>
<td width="20%">-pn &lt;port name&gt;</td>
<td width="20%">--port-name &lt;port name&gt;</td>
<td width="60%">Specifies the port name to be code generated. If
the port name is not specified, then the first port (of the
selected service) will be picked.</td>
<td></td>
</tr>
<tr>
<td width="20%">-ns2p</td>
<td width="20%">--namespace2package</td>
<td width="60%">Specifies a comma separated list of namespaces and
packages where the given package will be used in the place of the
auto generated package for the relevant namespace. The list will be
the format of ns1=pkg1,ns2=pkg2.</td>
<td></td>
</tr>
<tr>
<td width="20%">-ssi</td>
<td width="20%">--serverside-interface</td>
<td width="60%">Generate an interface for the service
skeleton.</td>
<td></td>
</tr>
<tr>
<td width="20%">-wv</td>
<td width="20%">--wsdl-version</td>
<td width="60%">WSDL Version. Valid Options : 2, 2.0, 1.1</td>
<td></td>
</tr>
<tr>
<td width="20%">-S</td>
<td width="20%">--source-folder</td>
<td width="60%">Specify a directory path for generated source</td>
<td></td>
</tr>
<tr>
<td width="20%">-R</td>
<td width="20%">--resource-folder</td>
<td width="60%">Specify a directory path for generated resources</td>
<td></td>
</tr>
<tr>
<td width="20%">-em</td>
<td width="20%">--external-mapping</td>
<td width="60%">Specify an external mapping file</td>
<td></td>
</tr>
<tr>
<td width="20%">-f</td>
<td width="20%">--flatten-files</td>
<td width="60%">Flattens the generated files</td>
<td></td>
</tr>
<tr>
<td width="20%">-uw</td>
<td width="20%">--unwrap-params</td>
<td width="60%">Switch on un-wrapping</td>
<td></td>
</tr>
<tr>
<td width="20%">-xsdconfig</td>
<td width="20%"></td>
<td width="60%">Use XMLBeans .xsdconfig file. Valid only with -d xmlbeans</td>
<td></td>
</tr>
<tr>
<td width="20%">-ap</td>
<td width="20%">--all-ports</td>
<td width="60%">Generate code for all ports</td>
<td></td>
</tr>
<tr>
<td width="20%">-or</td>
<td width="20%">--over-ride</td>
<td width="60%">Overwrite the existing classes</td>
<td></td>
</tr>
<tr>
<td width="20%">-b</td>
<td width="20%">--backword-compatible</td>
<td width="60%">Generate Axis 1.x backword compatible code</td>
<td></td>
</tr>
<tr>
<td width="20%">-sp</td>
<td width="20%">--suppress-prefixes</td>
<td width="60%">Suppress namespace prefixes (Optimzation that reduces size of soap request/response)</td>
<td></td>
</tr>
<tr>
<td width="20%"></td>
<td width="20%">--noBuildXML</td>
<td width="60%">Don't generate the build.xml in the output directory</td>
<td></td>
</tr>
<tr>
<td width="20%"></td>
<td width="20%">--noWSDL</td>
<td width="60%">Don't generate WSDL's in the resources directory</td>
<td></td>
</tr>
<tr>
<td width="20%"></td>
<td width="20%">--noMessageReceiver</td>
<td width="60%">Don't generate a MessageReceiver in the generated sources</td>
<td></td>
</tr>
</tbody>
</table>
<p>Apart from these mentioned options one can pass extra options by
prefixing them with -E (uppercase). These extra options will be
processed by the extensions. The extra options that can be passed
are documented separately with the extensions documentation (For
example with ADB).</p>
<a name="ant" id="ant"></a>
<h2>Ant Task</h2>
<p>The code generator also comes bundled with an Ant task. The ant
task is implemented by the org.apache.axis2.tool.ant.AntCodegenTask
class. Following are the ant task attributes.</p>
<a name="antref" id="antref"></a>
<h3>Ant Task Reference</h3>
<table>
<tbody>
<tr>
<td>wsdlfilename</td>
<td>WSDL file location. Maps to the -uri option of the command line
tool.</td>
</tr>
<tr>
<td>output</td>
<td>Output file location. This is where the files would be copied
once the code generation is done. If this option is omitted the
generated files would be copied to the working directory. Maps to
the -o option of the command line tool.</td>
</tr>
<tr>
<td>language</td>
<td>Output language. Currently the code generator can generate code
in Java. Maps to the -l option of the command line tool.</td>
</tr>
<tr>
<td>packageName</td>
<td>The target package name. If omitted, a default package (formed
using the target namespace of the WSDL) will be used. Maps to the
-p option of the command line tool.</td>
</tr>
<tr>
<td>databindingName</td>
<td>Data binding framework name. Maps to the -d option of the
command line tool. Possible values include "adb", "xmlbeans",
"jibx","jaxbri".</td>
</tr>
<tr>
<td>serviceName</td>
<td>The name of the service in the case of multiple services. Maps
to -sn options of the command line tool.</td>
</tr>
<tr>
<td>portName</td>
<td>The name of the port in the presence of multiple ports. Maps to
-pn options of the command line tool.</td>
</tr>
<tr>
<td>asyncOnly</td>
<td>Generate code only for async style. When this option is used
the generated stubs will have only the asynchronous invocation
methods. Defaults to false if omitted. Only true and false are
applicable as values. Maps to the -a option of the command line
tool.</td>
</tr>
<tr>
<td>syncOnly</td>
<td>Generate code only for sync style. When this option is used the
generated stubs will have only the synchronous invocation methods.
Defaults to false if omitted. Only true and false are applicable as
values. Maps to the -s option of the command line tool.</td>
</tr>
<tr>
<td>serverSide</td>
<td>Generates server side code (i.e. skeletons). Only true and
false are applicable as values. Default is false. Maps to the -ss
option of the command line tool.</td>
</tr>
<tr>
<td>testcase</td>
<td>Generates a test case. Possible values are true and false. Maps
to the -t options of the command line tool.</td>
</tr>
<tr>
<td>generateServiceXml</td>
<td>Generates server side code (i.e. skeletons). Only true and
false are applicable as values. Default is false. Maps to the -sd
option of the command line tool.</td>
</tr>
<tr>
<td>unpackClasses</td>
<td>Unpacks the generated classes. This forces the databinding
classes to be generated separately, which otherwise would have been
generated as inner classes.</td>
</tr>
<tr>
<td>generateAllClasses</td>
<td>Generates all the classes including client and server side
code. Maps to the -g option of the command line tool.</td>
</tr>
<tr>
<td>namespaceToPackages</td>
<td>A list of namespace to package mappings.</td>
</tr>
<tr>
<td>serverSideInterface</td>
<td>Flag stating whether to generate an interface for the server
side skeleton.</td>
</tr>
<tr>
<td>repositoryPath</td>
<td>Sets the repository path to be used. Maps to the -r option of
the command line tool.</td>
</tr>
<tr>
<td>wsdlVersion</td>
<td>Sets the version of the wsdl that is being used during
codegeneration. This deafults to 1.1 and one can set this to 2,
when trying to work with a WSDL 2.0 document. Maps to the -wv
option of the command line tool.</td>
</tr>
<tr>
<td>externalMapping</td>
<td>Location of the external mapping file to be used. Maps to the
-em option of the command line tool.</td>
</tr>
<tr>
<td>targetSourceFolderLocation</td>
<td>Rather than dumping all the code in the same location, one has
the option to make the sources to be generated in a different
location, given using this option. Maps to the -S option of the
command line tool.</td>
</tr>
<tr>
<td>targetResourcesFolderLocation</td>
<td>Rather than dumping all the code in the same location, one has
the option to make the resources to be generated in a different
location, given using this option. Maps to the -R option of the
command line tool.</td>
</tr>
<tr>
<td>unwrap</td>
<td>This will select between wrapped and unwrapped during code
generation. Default is set to false. Maps to the -uw option of the
command line tool.</td>
</tr>
</tbody>
</table>
<a name="example" id="example"></a>
<h3>Example Build File Using the Custom Ant Task</h3>
<p>Following is an example ant build file that uses the custom Ant
task. You can use any wsdl file to test the example. Replace the
"CombinedService.wsdl" with the name of your wsdl file in the
following script.</p>
<pre>
1 &lt;?xml version="1.0"?&gt;
2 &lt;project name="CodegenExample" default="main" basedir="."&gt;
3
4 &lt;path id="example.classpath"&gt;
5 &lt;fileset dir="classes"&gt;
6 &lt;include name="**/*.jar" /&gt;
7 &lt;/fileset&gt;
8 &lt;/path&gt;
9
10 &lt;target name="declare" &gt;
11 &lt;taskdef name="codegen"
12 classname="org.apache.axis2.tool.ant.AntCodegenTask"
13 classpathref="example.classpath"/&gt;
15 &lt;/target&gt;
16
17 &lt;target name="main" depends="declare"&gt;
18 &lt;codegen
19 wsdlfilename="C:\test\wsdl\CombinedService.wsdl"
20 output="C:\output"
21 serverside="true"
22 generateservicexml="true"/&gt;
23 &lt;/target&gt;
24
25 &lt;/project&gt;
</pre>
<p>In the above build script, from line 4 to 8 it sets the
classpath and includes all the .jar files (which are listed below)
into the classpath. From line 10 to 15 it creates a target to
declare a task called "codegen" and sets the appropriate class
(org.apache.axis2.tool.ant.AntCodegenTask) within the classpath in
line 12. From line 17 to 23 it creates the "main" target to
generate the code from the given wsdl. There are some arguments set
form line 19 to 22. Here in line 19 it sets the location of the
wsdl. In line 20 it sets the output directory in which the code is
generated. Line 21 indicates that this build generates the server
side code(skeleton) and line 22 indicates that the services.xml is
also generated.</p>
<p>Notice the main target that uses the "codegen" task which will
use the org.apache.axis2.tool.ant.AntCodegenTask class and run the
code generation tool internally while passing the relevant
arguments and do the proper generation. If a user types</p>
<p><code>&gt;ant</code> or <code>&gt;ant main</code></p>
<p>it will generate the server side code and services.xml for the
given WSDL file (C:\test\wsdl\CombinedService.wsdl -in the above
instance) and the generated code will be written to the specified
output path (C:\output - in the above instance).</p>
<p>For this Ant task to work the following jars need to be in the
class path.</p>
<ul>
<li>axis2-*.jar (from the Axis2 distribution)</li>
<li>wsdl4j-1.6.2.jar or higher (The WSDL4J implementation jar.
Bundled with the Axis2 distribution)</li>
<li>stax-api-1.0.1.jar (The StAX API's that contain the
javax.xml.namespace.QName class. This jar may be replaced by any
other jar that contains the javax.xml.namespace.QName
implementation. However Axis2 uses this class from the
stax-api-1.0.1.jar which comes bundled with the Axis2
distribution)</li>
<li>commons-logging-1.1.jar, neethi-2.0.jar and XmlSchema-1.2.jar
(from the Axis2 distribution)</li>
<li>axiom-api-1.2.1.jar and axiom-impl-1.2.1.jar (from the Axis2
distribution)</li>
<li>activation-1.1.jar (from the Axis2 distribution)</li>
<li>wstx-asl-3.1.0.jar (from the Axis2 distribution)</li>
</ul>
<a name="invoking" id="invoking"></a>
<h3>Invoking the Code Generator From Ant</h3>
<p>Since the users may find altering their ant class path a bit
daunting they can also follow an easier technique. The code
generator main class can be invoked directly through the build
file.</p>
<p>Below is an example of a full build.xml needed to run WSDL2Java
and generate the Java source files, compile the sources, and build
an AAR file ready for deployment (These are done one by one, by
calling the targets in the build file separately):</p>
<pre class="code">
&lt;!DOCTYPE project&gt;
&lt;project name="wsdl2java-example" default="usage" basedir="."&gt;
&lt;property name="project-name" value="wsdl2java-example"/&gt;
&lt;property file="build.properties"/&gt;
&lt;property name="build" value="build"/&gt;
&lt;property name="src" value="src"/&gt;
&lt;property name="build.classes" value="build/classes" /&gt;
&lt;path id="axis.classpath"&gt;
&lt;pathelement location="build/classes" /&gt;
&lt;fileset dir="${axis.home}/lib"&gt;
&lt;include name="**/*.jar" /&gt;
&lt;/fileset&gt;
&lt;pathelement location="${build.classes}" /&gt;
&lt;/path&gt;
&lt;path id="axis_client.classpath"&gt;
&lt;pathelement location="build/classes" /&gt;
&lt;fileset dir="${axis.home}"&gt;
&lt;include name="**/*.jar" /&gt;
&lt;/fileset&gt;
&lt;fileset dir="lib"&gt;
&lt;include name="*.jar" /&gt;
&lt;/fileset&gt;
&lt;pathelement location="${build.classes}" /&gt;
&lt;/path&gt;
&lt;target name="usage" description="Build file usage info (default task)"&gt;
&lt;echo message=" " /&gt;
&lt;echo message="${project-name} " /&gt;
&lt;echo message="-------------------------------------------------------" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message="Available Targets:" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" Compiling:" /&gt;
&lt;echo message=" compile - Compiles the WSDL2Java source code" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" Compiling client:" /&gt;
&lt;echo message=" compile_client - Compiles the client source code" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" Cleaning up:" /&gt;
&lt;echo message=" clean - Delete class files" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" WSDL:" /&gt;
&lt;echo message=" wsdl2java - Generate source from WSDL" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" AAR:" /&gt;
&lt;echo message=" aar - Generate an .aar for deployment into WEB-INF/services" /&gt;
&lt;echo message=" " /&gt;
&lt;echo message=" Executing:" /&gt;
&lt;echo message=" runLogin - Execute the runLogin client" /&gt;
&lt;/target&gt;
&lt;target name="prepare" &gt;
&lt;mkdir dir="${build.classes}" /&gt;
&lt;/target&gt;
&lt;target name="clean" &gt;
&lt;delete dir="${build}" /&gt;
&lt;delete dir="${dist}" /&gt;
&lt;/target&gt;
&lt;target name="compile"&gt;
&lt;echo message="Compiling wsdl2 files"/&gt;
&lt;javac
srcdir="output"
destdir="${build.classes}"
deprecation="true"
failonerror="true" debug="true"&gt;
&lt;classpath refid="axis.classpath"/&gt;
&lt;/javac&gt;
&lt;/target&gt;
&lt;target name="wsdl2java" depends="clean,prepare"&gt;
&lt;delete dir="output" /&gt;
&lt;java classname="org.apache.axis2.wsdl.WSDL2Java" fork="true"&gt;
&lt;classpath refid="axis.classpath"/&gt;
&lt;arg value="-d"/&gt;
&lt;arg value="xmlbeans"/&gt;
&lt;arg value="-uri"/&gt;
&lt;arg file="wsdl/LoginEndpoint.wsdl"/&gt;
&lt;arg value="-ss"/&gt;
&lt;arg value="-g"/&gt;
&lt;arg value="-sd"/&gt;
&lt;arg value="-o"/&gt;
&lt;arg file="output"/&gt;
&lt;arg value="-p"/&gt;
&lt;arg value="org.example.types"/&gt;
&lt;/java&gt;
&lt;!-- Move the schema folder to classpath--&gt;
&lt;move todir="${build.classes}"&gt;
&lt;fileset dir="output/resources"&gt;
&lt;include name="**/*schema*/**/*.class"/&gt;
&lt;include name="**/*schema*/**/*.xsb"/&gt;
&lt;/fileset&gt;
&lt;/move&gt;
&lt;/target&gt;
&lt;target name="jar_wsdl" depends="compile"&gt;
&lt;jar jarfile="lib/axis2_example_wsdl.jar" &gt;
&lt;fileset dir="${build.classes}" /&gt;
&lt;/jar&gt;
&lt;/target&gt;
&lt;!-- build an .aar file for axis2 web services --&gt;
&lt;target name="aar" depends="compile"&gt;
&lt;delete dir="${build.classes}/META-INF" /&gt;
&lt;mkdir dir="${build.classes}/META-INF" /&gt;
&lt;copy todir="${build.classes}/META-INF" &gt;
&lt;fileset dir="output/resources" &gt;
&lt;!-- axis2 web services definitions file --&gt;
&lt;include name="services.xml"/&gt;
&lt;/fileset&gt;
&lt;fileset dir="wsdl" &gt;
&lt;include name="LoginEndpoint.wsdl"/&gt;
&lt;/fileset&gt;
&lt;/copy&gt;
&lt;jar jarfile="dist/LoginEndpoint.aar" &gt;
&lt;fileset dir="${build.classes}" /&gt;
&lt;/jar&gt;
&lt;/target&gt;
&lt;target name="compile_client"&gt;
&lt;echo message="Compiling client files"/&gt;
&lt;javac
srcdir="src"
destdir="${build.classes}"
deprecation="true"
failonerror="true" debug="true"&gt;
&lt;classpath refid="axis.classpath"/&gt;
&lt;/javac&gt;
&lt;/target&gt;
&lt;target name="runLogin" depends="prepare,compile_client" description="run simple Login client"&gt;
&lt;java classname="org.client.LoginClient" &gt;
&lt;classpath refid="axis_client.classpath"/&gt;
&lt;/java&gt;
&lt;/target&gt;
&lt;/project&gt;
</pre>
<p>Place the above build.xml file in the 'bin' directory of the
axis2 binary distribution. Then create a build.properties file in
the same directory and specify the axis.home path pointing to the
axis2 binary distribution</p>
<p>E.g. :- axis.home=C://Axis2//axis2-1.1-bin</p>
<p>The above build.xml example also assumes three empty directories
exist, 'dist', 'lib', and 'src'.</p>
<p>Below is a validated WSDL Document following the
Document/Literal Style. The name of this file matches the name used
in the WSDL2Java ant task above, LoginEndpoint.wsdl.</p>
<pre class="code">
&lt;?xml version="1.0" encoding="UTF-8"?&gt;
&lt;definitions name="LoginService" targetNamespace="http://login" xmlns:tns="http://login"
xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:ns2="http://login/types"&gt;
&lt;types&gt;
&lt;schema targetNamespace="http://login/types" xmlns:tns="http://login/types"
xmlns:soap11-enc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns="http://www.w3.org/2001/XMLSchema"&gt;
&lt;import namespace="http://schemas.xmlsoap.org/soap/encoding/"/&gt;
&lt;element name="returnWebLoginElement"&gt;
&lt;complexType&gt;
&lt;sequence&gt;
&lt;element ref="tns:soap_session_idElement"/&gt;
&lt;element ref="tns:web_user_nameElement"/&gt;
&lt;/sequence&gt;
&lt;/complexType&gt;
&lt;/element&gt;
&lt;element name="webLoginElement"&gt;
&lt;complexType&gt;
&lt;sequence&gt;
&lt;element ref="tns:user_nameElement"/&gt;
&lt;element ref="tns:user_passwordElement"/&gt;
&lt;/sequence&gt;
&lt;/complexType&gt;
&lt;/element&gt;
&lt;element name="user_nameElement" type="xsd:string"/&gt;
&lt;element name="user_passwordElement" type="xsd:string"/&gt;
&lt;element name="soap_session_idElement" type="xsd:string"/&gt;
&lt;element name="web_user_nameElement" type="xsd:string"/&gt;
&lt;/schema&gt;&lt;/types&gt;
&lt;message name="LoginEndpoint_webLogin"&gt;
&lt;part name="parameters" element="ns2:webLoginElement"/&gt;
&lt;/message&gt;
&lt;message name="LoginEndpoint_webLoginResponse"&gt;
&lt;part name="result" element="ns2:returnWebLoginElement"/&gt;
&lt;/message&gt;
&lt;portType name="LoginEndpoint"&gt;
&lt;operation name="webLogin"&gt;
&lt;input message="tns:LoginEndpoint_webLogin" name="LoginEndpoint_webLogin"/&gt;
&lt;output message="tns:LoginEndpoint_webLoginResponse" name="LoginEndpoint_webLoginResponse"/&gt;
&lt;/operation&gt;
&lt;/portType&gt;
&lt;binding name="LoginEndpointBinding" type="tns:LoginEndpoint"&gt;
&lt;soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="document"/&gt;
&lt;operation name="webLogin"&gt;
&lt;soap:operation soapAction="webLogin"/&gt;
&lt;input name="LoginEndpoint_webLogin"&gt;
&lt;soap:body use="literal"/&gt;
&lt;/input&gt;
&lt;output name="LoginEndpoint_webLoginResponse"&gt;
&lt;soap:body use="literal"/&gt;
&lt;/output&gt;
&lt;/operation&gt;
&lt;/binding&gt;
&lt;service name="LoginService"&gt;
&lt;port name="LoginEndpointPort" binding="tns:LoginEndpointBinding"&gt;
&lt;soap:address location="http://localhost:8080/axis2/services/LoginService"/&gt;&lt;/port&gt;
&lt;/service&gt;&lt;/definitions&gt;
</pre>
<p>Place the above file, named LoginEndpoint.wsdl, in the directory
'wsdl' which is also inside the 'bin' directory. Run the wsdl2java
command via the ant task defined above (&gt;ant wsdl2java), and
there will be a directory called 'output' created. This directory
contains the WSDL2Java generated source.</p>
<p>An important detail is that an XMLBean class file is also
generated by WSDL2Java, TypeSystemHolder.class. That file is placed
into build/classes by the above ant task and will be needed to
compile the generated sources. A frequent problem is users get an
error such as:</p>
<p><em><b>ClassNotFoundException : Cannot load SchemaTypeSystem.
Unable to load class with name
schemaorg_apache_xmlbeans.system.s68C41DB812F52C975439BA10FE4FEE54.TypeSystemHolder.
Make sure the generated binary files are on the
classpath.</b></em></p>
<p>The TypeSystemHolder.class generated by WSDL2Java must be placed
in your classpath in order to avoid this error.</p>
<p>The next step is to modify the generated Skeleton Java Source
file - the Web service. This file as generated returns null and
needs to be updated to contain the business logic.</p>
<p>After the WSDL2Java command runs the file LoginEndpoint.wsdl,
edit the following file:</p>
<p>output/src/org/example/types/LoginServiceSkeleton.java. You
should see the following code:</p>
<pre class="code">
/**
* LoginServiceSkeleton.java
*
* This file was auto-generated from WSDL
* by the Apache Axis2 version: 1.0-RC4 Apr 28, 2006 (05:23:23 IST)
*/
package org.example.types;
/**
* LoginServiceSkeleton java skeleton for the axisService
*/
public class LoginServiceSkeleton {
/**
* Auto generated method signature
* @param param0
*/
public login.types.ReturnWebLoginElementDocument webLogin
(login.types.WebLoginElementDocument param0 )
{
//Todo fill this with the necessary business logic
throw new java.lang.UnsupportedOperationException();
}
}
</pre>
<p>Replace the contents of this file with the following, which uses
the complex types generated by WSDL2Java and the example wsdl
file:</p>
<pre class="code">
/**
* LoginServiceSkeleton.java
*
* This file was auto-generated from WSDL
* by the Apache Axis2 version: 1.0-RC4 Apr 28, 2006 (05:23:23 IST)
*/
package org.example.types;
import login.types.ReturnWebLoginElementDocument;
import login.types.ReturnWebLoginElementDocument.*;
import login.types.WebLoginElementDocument;
import login.types.WebLoginElementDocument.*;
/**
* Auto generated java skeleton for the service by the Axis code generator
*/
public class LoginServiceSkeleton {
/**
* Auto generated method signature
* @param webLoginElementDocument changed from param0
*/
public ReturnWebLoginElementDocument webLogin
(WebLoginElementDocument webLoginElementDocument ){
//Todo fill this with the necessary business logic
System.out.println("LoginServiceSkeleton.webLogin reached successfully!");
// Get parameters passed in
WebLoginElement webLoginElement = webLoginElementDocument.getWebLoginElement();
String userName = webLoginElement.getUserNameElement();
String password = webLoginElement.getUserPasswordElement();
System.out.println("LoginServiceSkeleton.webLogin userName: " + userName);
System.out.println("LoginServiceSkeleton.webLogin password: " + password);
// input paramaters would be used here
// prepare output
ReturnWebLoginElementDocument retDoc =
ReturnWebLoginElementDocument.Factory.newInstance();
ReturnWebLoginElement retElement = ReturnWebLoginElement.Factory.newInstance();
retElement.setWebUserNameElement("joe sixpack");
retElement.setSoapSessionIdElement("some_random_string");
System.out.println("validate retElement: " + retElement.validate());
retDoc.setReturnWebLoginElement(retElement);
System.out.println("validate retDoc: " + retDoc.validate());
System.out.println("LoginServiceSkeleton.webLogin returning...");
return retDoc;
}
}
</pre>
<p>The next steps assume the axis2.war has been deployed and has
expanded in a servlet container.</p>
<p>Run the 'jar_wsdl' ant task from the example build.xml (&gt;ant
jar_wsdl), which generates a jar file axis2_example_wsdl.jar in the
'bin/lib' directory. This jar will be used to compile the client,
and also will be placed in the servlet container.</p>
<p>Next, run the 'aar' ant task from the example build.xml (&gt;ant
aar), which generates the deployable axis2 Web service. Place
dist/LoginEndpoint.aar into axis2/WEB-INF/services . Place
lib/axis2_example_wsdl.jar into axis2/WEB-INF/lib . Verify the
happy axis page loaded the services correctly - there should be the
service 'LoginEndpoint' with the available operation 'webLogin'
displayed.</p>
<p>The last step is to create and run the client. In the src
directory create the file org.client.LoginClient.java, with the
contents below:</p>
<pre class="code">
package org.client;
import org.apache.axis2.AxisFault;
import login.types.ReturnWebLoginElementDocument;
import login.types.ReturnWebLoginElementDocument.*;
import login.types.WebLoginElementDocument;
import login.types.WebLoginElementDocument.*;
import org.example.types.LoginServiceStub;
/**
* Login.
*
*/
public class LoginClient {
public static void main(String[] args) {
try {
System.out.println("webLogin, firing...");
LoginServiceStub stub = new LoginServiceStub();
WebLoginElementDocument webLoginElementDocument
= WebLoginElementDocument.Factory.newInstance();
WebLoginElement webLoginElement =
WebLoginElement.Factory.newInstance();
webLoginElement.setUserNameElement("joe");
webLoginElement.setUserPasswordElement("sixpack");
webLoginElementDocument.setWebLoginElement(webLoginElement);
System.out.println("validate: " + webLoginElement.validate());
stub.webLogin(webLoginElementDocument);
ReturnWebLoginElementDocument returnWebLoginElementDocument =
stub.webLogin(webLoginElementDocument);
System.out.println("Client returned");
ReturnWebLoginElementDocument.ReturnWebLoginElement
retElement = returnWebLoginElementDocument.getReturnWebLoginElement();
System.out.println("WebUserName: " + retElement.getWebUserNameElement());
System.out.println("SOAPSessionId: " + retElement.getSoapSessionIdElement());
System.out.println("webLogin, completed!!!");
} catch (AxisFault axisFault) {
axisFault.printStackTrace();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
</pre>
<p>Now run the ant task 'runLogin' (&gt;ant runLogin). The
following output should appear:</p>
<pre class="code">
runLogin:
[echo] running the webLogin client
[java] webLogin, firing...
[java] validate: true
[java] Client returned
[java] WebUserName: joe sixpack
[java] SOAPSessionId: some_random_string
[java] webLogin, completed!!!
</pre>
<a name="appendix" id="appendix"></a>
<h2>Appendix</h2>
<ul>
<li>Eclipse reference - <a href=
"http://www.eclipse.org/">http://www.eclipse.org/</a></li>
<li>Custom Ant Tasks - <a href=
"http://ant.apache.org/manual/develop.html">http://ant.apache.org/manual/develop.html</a></li>
</ul>
</body>
</html>