<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="(C) Copyright 2005" />
<meta name="DC.rights.owner" content="(C) Copyright 2005" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="task" name="DC.Type" />
<meta name="DC.Title" content="Generating a Java client proxy and a sample application from a WSDL document using the Axis run-time environment" />
<meta name="abstract" content="The Web Service Client wizard assists you in generating a Java bean proxy and a sample application. The sample Web application demonstrates how to code a proxy file." />
<meta name="description" content="The Web Service Client wizard assists you in generating a Java bean proxy and a sample application. The sample Web application demonstrates how to code a proxy file." />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.doc.user/concepts/cwsinwsa.html" />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.doc.user/concepts/cws.html" />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.consumption.ui.doc.user/tasks/tuddiexp.html" />
<meta scheme="URI" name="DC.Relation" content="../../org.eclipse.jst.ws.doc.user/ref/rwsdl.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="tsampappa" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/commonltr.css" type="text/css" rel="stylesheet" />
<title>Generating a Java client proxy and a sample application from
a WSDL document using the Axis run-time environment</title>
</head>
<body id="tsampappa"><a name="tsampappa"><!-- --></a>


<h1 class="topictitle1">Generating a Java client proxy and a sample application
from a WSDL document using the Axis run-time environment</h1>



<div><p>The Web Service Client wizard assists you in generating a Java™ bean
proxy and a sample application. The sample Web application demonstrates how
to code a proxy file.</p>

<div class="p"><p>Prerequisites:</p>
<ol>
<li>If you are using the Apache Jakarta Tomcat servlet
container as your server, you must install it, configure an instance of it,
and create a Web project targeted to it as described in <a href="ttomcatserv.html">Creating an Apache Tomcat server and Web project</a></li>

<li>Discover and import a WSDL document into the Web project. You can only
use a WSDL file that contains a service element.</li>

</ol>
</div>

<div class="section">To generate a Java client proxy and a sample application
from a discovered WSDL document:</div>

<ol>
<li><span>Switch to the J2EE perspective (<span class="uicontrol">Window &gt; Open Perspective
&gt; J2EE</span>).</span></li>

<li><span>In the Navigator view, select the Web project in which you want
to generate a sample application.</span></li>

<li><span>Click  <span class="uicontrol">File &gt; New &gt; Other</span>. Select  <span class="uicontrol">Web
Services</span> in order to display the various Web service wizards.
Select the  <span class="uicontrol">Web Service Client</span> wizard. Click  <span class="uicontrol">Next</span>.</span>
</li>

<li><span>Web Services page: Select the type of proxy to be generated, and
whether or not it will be tested.</span></li>

<li><span>Client Environment Configuration page: Select the run-time environment
and the server for your Web service client.</span>
<ol type="a">
<li class="substepexpand"><span>Click  <span class="uicontrol">Explore Options</span> and select the
Apache Axis run-time environment and select the server on which you want to
run your Web service client.</span></li>

<li class="substepexpand"><span>Select the type and name of project in which you want the Web
service client created.</span> <ul>
<li> If you enter the name of an existing project, the project type field
must match that of the existing project. Ensure that the project selected
as the Client Web Project is different from the Service Web Project, or the
service will be overwritten by the client's generated artifacts.</li>

<li>If you enter a name of a project that does not already exist, the wizard
will create the project for you.</li>

<li>Note that the only project type supported for Axis clients is a Web project.
If you want the client to be created in a Java, EJB, or Application Client project,
you must select the WebSphere<sup>®</sup> run-time environment for your client.</li>

</ul>
</li>

</ol>

</li>

<li><span>Web Service Selection page: Enter the URI to the WSDL, WSIL, or
HTML file that will be used to generate the client. You can optionally generate
a WSIL file from this file as well.</span></li>

<li><span>Web Service Proxy page: This panel shows the options for the proxy.
It lists the folder where the proxy will be generated, and you can optionally
create custom mappings between namespaces and packages.</span></li>

<li><span>Web Service Namespace to Package Mappings page: if you selected
 <span class="uicontrol">Define custom mapping for namespace to package</span> on
the previous page, you can enter your custom mapping pairs on this page by
clicking  <span class="uicontrol">Add</span>.</span></li>

<li><span>Web Service Client Test page: Select the test facility that you
will use to test the proxy, and the methods that you want included in the
proxy. Note that the Universal Test Client (UTC) is only compatible with Web
service clients deployed on WebSphere servers.</span></li>

<li><span>Click  <span class="uicontrol">Finish</span>. If you have selected to test
the proxy, the test client will open in a browser window.</span></li>

</ol>

<div class="section"><p>The generated Java bean proxy provides a remote procedure
call interface to the Web service. The sample Web application demonstrates
how to code the proxy file.</p>
<p>Once you have generated your Java client
proxy, you may test the methods of the Web service through the proxy using
Web Services sample JSPs or the Universal test client.</p>
<ul>
<li>If you have selected to test the generated proxy using Web service JSPs,
the proxy is launched in a Web browser at the following URL: <samp class="codeph">http://localhost: <var class="varname">port</var>/ <var class="varname">WebProject</var>Client/sample<em>BeanName</em>/ <var class="varname">WebServiceName</var>/TestClient.jsp</samp> You
can use this sample application to test the Web service by selecting a method,
entering a value for the method, and clicking  <span class="uicontrol">Invoke</span>.
The result of the method will display in the results pane.</li>

<li>If you have selected to test the generated proxy using the Universal Test
Client, it will be launched in a browser window at the following URL:  <tt class="sysout">http://localhost:9080/UTC/preload?object= <var class="varname">BeanPackage</var>. <var class="varname">BeanServiceProxy</var></tt>. In the Reference pane,
under Object References, expand the proxy stub to display the methods of the
Web service. Click the method you want to test, enter a value in the Parameters
pane, and click  <span class="uicontrol">Invoke</span>. The result will be generated
below.</li>

<li>If you have selected to test the Web service using the Web Services Explorer,
the Explorer will open. Select the operation you want to test, enter the required
information, and click  <strong>Go</strong>. The result will display in the Status pane.</li>

</ul>
<p>For more information on creating a Web project, refer to the Web application
development documentation.</p>
</div>

</div>

<div>
<div class="linklist"><strong>Related Concepts</strong><br />

<div><a href="../../org.eclipse.jst.ws.doc.user/concepts/cwsinwsa.html"> Tools for Web services development</a></div>
<div><a href="../../org.eclipse.jst.ws.doc.user/concepts/cws.html">Web services development</a></div></div>

<div class="linklist"><strong>Related Tasks</strong><br />

<div><a href="../../org.eclipse.jst.ws.consumption.ui.doc.user/tasks/tuddiexp.html"> Using the Web Services Explorer</a></div></div>

<div class="linklist"><strong>Related Reference</strong><br />

<div><a href="../../org.eclipse.jst.ws.doc.user/ref/rwsdl.html">WSDL documents</a></div></div>
</div>

</body>
</html>