<!DOCTYPE html>
<!--
 | Generated by Apache Maven Doxia Site Renderer 1.9.2 at 2021-08-01 
 | Rendered using Apache Maven Fluido Skin 1.6
-->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta name="Date-Revision-yyyymmdd" content="20210801" />
    <meta http-equiv="Content-Language" content="en" />
    <title>Apache Axis2 &#x2013; Generating a Web Service Client using Axis2 and JiBX</title>
    <link rel="stylesheet" href="../css/apache-maven-fluido-1.6.min.css" />
    <link rel="stylesheet" href="../css/site.css" />
    <link rel="stylesheet" href="../css/print.css" media="print" />
      <script type="text/javascript" src="../js/apache-maven-fluido-1.6.min.js"></script>
<meta name="generator" content="HTML Tidy for Windows (vers 14 June 2007), see www.w3.org" /><meta http-equiv="content-type" content="" />      </head>
    <body class="topBarDisabled">
      <div class="container-fluid">
      <div id="banner">
        <div class="pull-left"><a href="http://www.apache.org/" id="bannerLeft"><img src="http://www.apache.org/images/asf_logo_wide.png"  alt="Apache Axis2"/></a></div>
        <div class="pull-right"><a href=".././" id="bannerRight"><img src="../images/axis.jpg" /></a></div>
        <div class="clear"><hr/></div>
      </div>

      <div id="breadcrumbs">
        <ul class="breadcrumb">
        <li id="publishDate">Last Published: 2021-08-01<span class="divider">|</span>
</li>
          <li id="projectVersion">Version: 1.8.0<span class="divider">|</span></li>
        <li class=""><a href="http://www.apache.org" class="externalLink" title="Apache">Apache</a><span class="divider">/</span></li>
      <li class=""><a href="../index.html" title="Axis2/Java">Axis2/Java</a><span class="divider">/</span></li>
    <li class="active ">Generating a Web Service Client using Axis2 and JiBX</li>
        </ul>
      </div>
      <div class="row-fluid">
        <div id="leftColumn" class="span2">
          <div class="well sidebar-nav">
<ul class="nav nav-list">
          <li class="nav-header">Axis2/Java</li>
    <li><a href="../index.html" title="Home"><span class="none"></span>Home</a>  </li>
    <li><a href="../download.html" title="Downloads"><span class="none"></span>Downloads</a>  </li>
    <li><a href="javascript:void(0)" title="Release Notes"><span class="icon-chevron-down"></span>Release Notes</a>
      <ul class="nav nav-list">
    <li><a href="../release-notes/1.6.1.html" title="1.6.1"><span class="none"></span>1.6.1</a>  </li>
    <li><a href="../release-notes/1.6.2.html" title="1.6.2"><span class="none"></span>1.6.2</a>  </li>
    <li><a href="../release-notes/1.6.3.html" title="1.6.3"><span class="none"></span>1.6.3</a>  </li>
    <li><a href="../release-notes/1.6.4.html" title="1.6.4"><span class="none"></span>1.6.4</a>  </li>
    <li><a href="../release-notes/1.7.0.html" title="1.7.0"><span class="none"></span>1.7.0</a>  </li>
    <li><a href="../release-notes/1.8.0.html" title="1.8.0"><span class="none"></span>1.8.0</a>  </li>
      </ul>
  </li>
    <li><a href="../modules/index.html" title="Modules"><span class="none"></span>Modules</a>  </li>
    <li><a href="../tools/index.html" title="Tools"><span class="none"></span>Tools</a>  </li>
          <li class="nav-header">Documentation</li>
    <li><a href="../docs/toc.html" title="Table of Contents"><span class="none"></span>Table of Contents</a>  </li>
    <li><a href="../docs/installationguide.html" title="Installation Guide"><span class="none"></span>Installation Guide</a>  </li>
    <li><a href="../docs/quickstartguide.html" title="QuickStart Guide"><span class="none"></span>QuickStart Guide</a>  </li>
    <li><a href="../docs/userguide.html" title="User Guide"><span class="none"></span>User Guide</a>  </li>
    <li><a href="../docs/jaxws-guide.html" title="JAXWS Guide"><span class="none"></span>JAXWS Guide</a>  </li>
    <li><a href="../docs/pojoguide.html" title="POJO Guide"><span class="none"></span>POJO Guide</a>  </li>
    <li><a href="../docs/spring.html" title="Spring Guide"><span class="none"></span>Spring Guide</a>  </li>
    <li><a href="../docs/webadminguide.html" title="Web Administrator's Guide"><span class="none"></span>Web Administrator's Guide</a>  </li>
    <li><a href="../docs/migration.html" title="Migration Guide (from Axis1)"><span class="none"></span>Migration Guide (from Axis1)</a>  </li>
          <li class="nav-header">Resources</li>
    <li><a href="../faq.html" title="FAQ"><span class="none"></span>FAQ</a>  </li>
    <li><a href="../articles.html" title="Articles"><span class="none"></span>Articles</a>  </li>
    <li><a href="http://wiki.apache.org/ws/FrontPage/Axis2/" class="externalLink" title="Wiki"><span class="none"></span>Wiki</a>  </li>
    <li><a href="../refLib.html" title="Reference Library"><span class="none"></span>Reference Library</a>  </li>
    <li><a href="../apidocs/index.html" title="Online Java Docs"><span class="none"></span>Online Java Docs</a>  </li>
          <li class="nav-header">Get Involved</li>
    <li><a href="../overview.html" title="Overview"><span class="none"></span>Overview</a>  </li>
    <li><a href="../svn.html" title="Checkout the Source"><span class="none"></span>Checkout the Source</a>  </li>
    <li><a href="../mail-lists.html" title="Mailing Lists"><span class="none"></span>Mailing Lists</a>  </li>
    <li><a href="../release-process.html" title="Release Process"><span class="none"></span>Release Process</a>  </li>
    <li><a href="../guidelines.html" title="Developer Guidelines"><span class="none"></span>Developer Guidelines</a>  </li>
    <li><a href="../siteHowTo.html" title="Build the Site"><span class="none"></span>Build the Site</a>  </li>
          <li class="nav-header">Project Information</li>
    <li><a href="../team-list.html" title="Project Team"><span class="none"></span>Project Team</a>  </li>
    <li><a href="../issue-tracking.html" title="Issue Tracking"><span class="none"></span>Issue Tracking</a>  </li>
    <li><a href="http://svn.apache.org/viewvc/axis/axis2/java/core/trunk/" class="externalLink" title="Source Code"><span class="none"></span>Source Code</a>  </li>
    <li><a href="../thanks.html" title="Acknowledgements"><span class="none"></span>Acknowledgements</a>  </li>
          <li class="nav-header">Apache</li>
    <li><a href="http://www.apache.org/licenses/LICENSE-2.0.html" class="externalLink" title="License"><span class="none"></span>License</a>  </li>
    <li><a href="http://www.apache.org/foundation/sponsorship.html" class="externalLink" title="Sponsorship"><span class="none"></span>Sponsorship</a>  </li>
    <li><a href="http://www.apache.org/foundation/thanks.html" class="externalLink" title="Thanks"><span class="none"></span>Thanks</a>  </li>
    <li><a href="http://www.apache.org/security/" class="externalLink" title="Security"><span class="none"></span>Security</a>  </li>
  </ul>
          <hr />
          <div id="poweredBy">
              <div class="clear"></div>
              <div class="clear"></div>
              <div class="clear"></div>
              <div class="clear"></div>
  <a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy"><img class="builtBy" alt="Built by Maven" src="../images/logos/maven-feather.png" /></a>
              </div>
          </div>
        </div>
        <div id="bodyColumn"  class="span10" >
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">


<h1 class="title">Generating a Web Service Client using Axis2 and
JiBX</h1>

<p>This document explains how to generate a Web service client
using Axis2 and JiBX data binding. The service has the following
WSDL:</p>

<p><b>Code Listing 1: The WSDL file</b></p>

<div>
<pre>
&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
&lt;wsdl:definitions
   xmlns:apachesoap=&quot;http://xml.apache.org/xml-soap&quot;
   xmlns:impl=&quot;http://apache.org/axis2/Axis2UserGuide&quot;
   xmlns:intf=&quot;http://apache.org/axis2/Axis2UserGuide&quot;
   xmlns:wsdl=&quot;http://schemas.xmlsoap.org/wsdl/&quot;
   xmlns:wsdlsoap=&quot;http://schemas.xmlsoap.org/wsdl/soap/&quot;
   xmlns:xsd=&quot;http://www.w3.org/2001/XMLSchema&quot;
   targetNamespace=&quot;http://apache.org/axis2/Axis2UserGuide&quot;&gt;

  &lt;wsdl:types&gt;
    &lt;schema
       elementFormDefault=&quot;qualified&quot;
       targetNamespace=&quot;http://apache.org/axis2/Axis2UserGuide&quot;
       xmlns=&quot;http://www.w3.org/2001/XMLSchema&quot;&gt;
      
      &lt;!-- ELEMENTS --&gt;
      
      &lt;element name=&quot;DoInOnlyRequest&quot;&gt;
        &lt;complexType&gt;
          &lt;sequence&gt;
            &lt;element name=&quot;messageString&quot; type=&quot;xsd:string&quot;/&gt;
          &lt;/sequence&gt;
        &lt;/complexType&gt;
      &lt;/element&gt;
      
      &lt;element name=&quot;TwoWayOneParameterEchoRequest&quot;&gt;
        &lt;complexType&gt;
          &lt;sequence&gt;
            &lt;element name=&quot;echoString&quot; type=&quot;xsd:string&quot;/&gt;
          &lt;/sequence&gt;
        &lt;/complexType&gt;
      &lt;/element&gt;
      &lt;element name=&quot;TwoWayOneParameterEchoResponse&quot;&gt;
        &lt;complexType&gt;
          &lt;sequence&gt;
            &lt;element name=&quot;echoString&quot; type=&quot;xsd:string&quot;/&gt;
          &lt;/sequence&gt;
        &lt;/complexType&gt;
      &lt;/element&gt;
      
      &lt;element name=&quot;NoParametersRequest&quot;&gt;
        &lt;complexType/&gt;
      &lt;/element&gt;
      &lt;element name=&quot;NoParametersResponse&quot;&gt;
        &lt;complexType/&gt;
      &lt;/element&gt;
      
      &lt;element name=&quot;MultipleParametersAddItemRequest&quot;&gt;
        &lt;complexType&gt;
          &lt;sequence&gt;
            &lt;element name=&quot;itemId&quot; type=&quot;xsd:int&quot;/&gt;
            &lt;element name=&quot;itemName&quot; type=&quot;xsd:string&quot;/&gt;
            &lt;element name=&quot;price&quot; type=&quot;xsd:float&quot;/&gt;
            &lt;element name=&quot;description&quot; type=&quot;xsd:string&quot;/&gt;
          &lt;/sequence&gt;
        &lt;/complexType&gt;
      &lt;/element&gt;

      &lt;element name=&quot;MultipleParametersAddItemResponse&quot;&gt;
        &lt;complexType&gt;
          &lt;sequence&gt;
          &lt;element name=&quot;itemId&quot; type=&quot;xsd:int&quot;/&gt;
          &lt;element name=&quot;successfulAdd&quot; type=&quot;xsd:boolean&quot;/&gt;
          &lt;/sequence&gt;
        &lt;/complexType&gt;
      &lt;/element&gt;

    &lt;/schema&gt;
  &lt;/wsdl:types&gt;

  
  &lt;!-- MESSAGES --&gt;

  &lt;wsdl:message name=&quot;DoInOnlyRequestMessage&quot;&gt;
    &lt;wsdl:part name=&quot;input&quot; element=&quot;impl:DoInOnlyRequest&quot;/&gt;
  &lt;/wsdl:message&gt;

  &lt;wsdl:message name=&quot;TwoWayOneParameterEchoRequestMessage&quot;&gt;
    &lt;wsdl:part name=&quot;input&quot; element=&quot;impl:TwoWayOneParameterEchoRequest&quot;/&gt;
  &lt;/wsdl:message&gt;
  &lt;wsdl:message name=&quot;TwoWayOneParameterEchoResponseMessage&quot;&gt;
    &lt;wsdl:part name=&quot;output&quot; element=&quot;impl:TwoWayOneParameterEchoResponse&quot;/&gt;
  &lt;/wsdl:message&gt;

  &lt;wsdl:message name=&quot;NoParametersRequestMessage&quot;&gt;
    &lt;wsdl:part name=&quot;input&quot; element=&quot;impl:NoParametersRequest&quot;/&gt;
  &lt;/wsdl:message&gt;
  &lt;wsdl:message name=&quot;NoParametersResponseMessage&quot;&gt;
    &lt;wsdl:part name=&quot;output&quot; element=&quot;impl:NoParametersResponse&quot;/&gt;
  &lt;/wsdl:message&gt;

  &lt;wsdl:message name=&quot;MultipleParametersAddItemRequestMessage&quot;&gt;
    &lt;wsdl:part name=&quot;input&quot; element=&quot;impl:MultipleParametersAddItemRequest&quot;/&gt;
  &lt;/wsdl:message&gt;
  &lt;wsdl:message name=&quot;MultipleParametersAddItemResponseMessage&quot;&gt;
    &lt;wsdl:part name=&quot;output&quot; element=&quot;impl:MultipleParametersAddItemResponse&quot;/&gt;
  &lt;/wsdl:message&gt;


  &lt;!-- Port type (operations) --&gt;

  &lt;wsdl:portType name=&quot;Axis2UserGuidePortType&quot;&gt;

    &lt;wsdl:operation name=&quot;DoInOnly&quot; parameterOrder=&quot;input&quot;&gt;
      &lt;wsdl:input name=&quot;DoInOnlyRequestMessage&quot;
                  message=&quot;impl:DoInOnlyRequestMessage&quot;/&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;TwoWayOneParameterEcho&quot; parameterOrder=&quot;input&quot;&gt;
      &lt;wsdl:input name=&quot;TwoWayOneParameterEchoRequestMessage&quot;
                  message=&quot;impl:TwoWayOneParameterEchoRequestMessage&quot;/&gt;
      &lt;wsdl:output name=&quot;TwoWayOneParameterEchoResponseMessage&quot;
                  message=&quot;impl:TwoWayOneParameterEchoResponseMessage&quot;/&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;NoParameters&quot; parameterOrder=&quot;input&quot;&gt;
      &lt;wsdl:input name=&quot;NoParametersRequestMessage&quot;
                  message=&quot;impl:NoParametersRequestMessage&quot;/&gt;
      &lt;wsdl:output name=&quot;NoParametersResponseMessage&quot;
                   message=&quot;impl:NoParametersResponseMessage&quot;/&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;MultipleParametersAddItem&quot; parameterOrder=&quot;input&quot;&gt;
      &lt;wsdl:input name=&quot;MultipleParametersAddItemRequestMessage&quot;
                  message=&quot;impl:MultipleParametersAddItemRequestMessage&quot;/&gt;
      &lt;wsdl:output name=&quot;MultipleParametersAddItemResponseMessage&quot;
                  message=&quot;impl:MultipleParametersAddItemResponseMessage&quot;/&gt;
    &lt;/wsdl:operation&gt;

  &lt;/wsdl:portType&gt;


  &lt;!-- BINDING (bind operations) --&gt;
  &lt;wsdl:binding
     name=&quot;Axis2UserGuideSoapBinding&quot;
     type=&quot;impl:Axis2UserGuidePortType&quot;&gt;
    &lt;wsdlsoap:binding style=&quot;document&quot; transport=&quot;http://schemas.xmlsoap.org/soap/http&quot;/&gt;

    &lt;wsdl:operation name=&quot;DoInOnly&quot;&gt;
      &lt;wsdlsoap:operation soapAction=&quot;DoInOnly&quot;/&gt;
      &lt;wsdl:input&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:input&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;TwoWayOneParameterEcho&quot;&gt;
      &lt;wsdlsoap:operation soapAction=&quot;TwoWayOneParameterEcho&quot;/&gt;
      &lt;wsdl:input&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:input&gt;
      &lt;wsdl:output&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:output&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;NoParameters&quot;&gt;
      &lt;wsdlsoap:operation soapAction=&quot;NoParameters&quot;/&gt;
      &lt;wsdl:input&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:input&gt;
      &lt;wsdl:output&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:output&gt;
    &lt;/wsdl:operation&gt;

    &lt;wsdl:operation name=&quot;MultipleParametersAddItem&quot;&gt;
      &lt;wsdlsoap:operation soapAction=&quot;MultipleParametersAddItem&quot;/&gt;
      &lt;wsdl:input&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:input&gt;
      &lt;wsdl:output&gt;
        &lt;wsdlsoap:body use=&quot;literal&quot;/&gt;
      &lt;/wsdl:output&gt;
    &lt;/wsdl:operation&gt;
  &lt;/wsdl:binding&gt;


  &lt;!-- SERVICE --&gt;

  &lt;wsdl:service name=&quot;Axis2UserGuideService&quot;&gt;
    &lt;wsdl:port binding=&quot;impl:Axis2UserGuideSoapBinding&quot;
               name=&quot;Axis2UserGuide&quot;&gt;
      &lt;wsdlsoap:address location=&quot;http://localhost:8080/axis2/services/Axis2UserGuide&quot;/&gt;
    &lt;/wsdl:port&gt;
  &lt;/wsdl:service&gt;
&lt;/wsdl:definitions&gt;
</pre></div>

<p>Note that the document defines four operations, DoInOnly,
NoParameters, TwoWayOneParameterEcho, and
MultipleParametersAddItem. Each client will include methods for
calling each of these operations.</p>

<p>(You can get more information on WSDL at <a class="externalLink" href="http://www.w3.org/2002/ws/desc/">http://www.w3.org/2002/ws/desc/</a>
.)</p>
<a name="jibx" id="jibx"></a>
<section>
<h2><a name="JiBX"></a>JiBX</h2>

<p>JiBX is not part of the Apache project, so in order to use it to
generate your clients, you will need to do some setting up to start
with. To generate your client, execute the following steps:</p>

<p><b>The short story</b>:</p>

<ol style="list-style-type: decimal">

<li>Download the latest JiBX package (tested with JiBX v1.1) from
<a class="externalLink" href="http://sourceforge.net/projects/jibx/">http://sourceforge.net/projects/jibx/</a>
. Extract the zip file, and copy the JARs in the lib directory to
the AXIS2_HOME/lib directory. (Delete the stax-api.jar file; it's
superseded by the version that comes with Axis2.)</li>

<li>Download <a class="externalLink" href="http://sourceforge.net/project/showfiles.php?group_id=69358&amp;package_id=122897">
xsd2jibx version beta2a</a> from SourceForge. Create a directory
called xsd2jibx in your working directory and extract the files
into it. This utility does not work with the latest release (v1.1)
of JiBX, so download <a class="externalLink" href="http://sourceforge.net/project/showfiles.php?group_id=69358&amp;package_id=68290">
jibx-1.0RC1</a> from SourceForge. Extract the files from this
archive and copy the *.jar files in the lib directory into the
xsd2jibx/lib directory.</li>

<li>Create a schema based on the data structures of your WSDL file
and save it in your working directory.</li>

<li>Make sure that only the xsd2jibx jar files are in the classpath
and execute the following command to create the basic binding file:
java -jar xsd2jibx\lib\xsd2jibx.jar Axis2UserGuide.xsd</li>

<li>Copy the org directory to the src directory to place the
generated classes into the project so that the compiler will see
them.</li>

<li>Remove the xsd2jibx-related *.jar files from your CLASSPATH and
add the Axis2 .jar files back into it. Execute the following
command to generate the stubs:

<div>
<pre>
%AXIS2_HOME%\bin\WSDL2Java -uri Axis2UserGuide.wsdl -p org.apache.axis2.axis2userguide -d jibx -Ebindingfile org\apache\axis2\axis2userguide\binding.xml -s
</pre></div></li>

<li>Create the client file in the org/apache/axis2/axis2userguide
directory.</li>

<li>Copy the org directory and all its contents to the src
directory.</li>

<li>Compile the first set of classes by typing:<code>ant
jar.client</code></li>

<li>Go to the build/classes directory and run the JiBX compiler:

<div>
<pre>
java -jar C:\apps\axis2\lib\jibx-bind.jar 
..\..\org\apache\axis2\axis2userguide\binding.xml
</pre></div></li>

<li>Run Ant again to package the new auto-generated JiBX classes
into the client jar by typing: <code>ant jar.client</code></li>

<li>Add the build/lib/Axis2UserGuideService-test-client.jar file to
the CLASSPATH and run the client by typing:

<div>
<pre>
java org.apache.axis2.axis2userguide.Client
</pre></div></li>
</ol>

<p><b>The long story:</b></p>

<p>To use JiBX to generate your client, you first need to use it in
two different functions. You have to generate a binding file that
maps objects to the XML elements, and then use JiBX to generate the
stubs that your client will use. To generate a binding file, you'll
need the xsd2jibx utility, which creates a binding file from an XML
Schema document. Once you have the binding file, you can run JiBX
to create the actual object. In order to do all that you'll need to
have the appropriate versions of the JiBX software.</p>

<p>Download the latest JiBX package (tested with JiBX v1.1) from
<a class="externalLink" href="http://sourceforge.net/projects/jibx/">http://sourceforge.net/projects/jibx/</a>.
Extract the zip file, and copy the JARs in the lib directory to the
AXIS2_HOME/lib directory. (Delete the stax-api.jar file; it's
superseded by the version that comes with Axis2.) These files
pertain to the main JiBX application.</p>

<p>Download <a class="externalLink" href="http://sourceforge.net/project/showfiles.php?group_id=69358&amp;package_id=122897">
xsd2jibx version beta2a</a> from Sourceforge. Create a directory
called xsd2jibx in your working directory and extract the files
into it. Unfortunately, this utility does not work with the latest
release of JiBX, so you will need to download <a class="externalLink" href="http://sourceforge.net/project/showfiles.php?group_id=69358&amp;package_id=68290">
jibx-1.0RC1</a> from Sourceforge. Extract the files from this
archive and place the *.jar files in the lib directory into the
xsd2jibx/lib directory. This way, you can use them exclusively with
the xsd2jibx utility.</p>

<p>You'll need an XML schema from which to generate the binding
file, which links XML elements to the Java classes. As defined in
the sample WSDL file, its content should be as shown in Code
Listing 2.</p>

<p><b>Code Listing 2: XML Schema</b></p>

<div>
<pre>
&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
&lt;xsd:schema
   elementFormDefault=&quot;qualified&quot;
   targetNamespace=&quot;http://apache.org/axis2/Axis2UserGuide&quot;
   xmlns=&quot;http://www.w3.org/2001/XMLSchema&quot;
   xmlns:xsd=&quot;http://www.w3.org/2001/XMLSchema&quot;&gt;
  
  &lt;!-- ELEMENTS --&gt;
  &lt;xsd:element name=&quot;DoInOnlyRequest&quot;&gt;
    &lt;xsd:complexType&gt;
      &lt;xsd:sequence&gt;
        &lt;xsd:element name=&quot;messageString&quot; type=&quot;xsd:string&quot;/&gt;
      &lt;/xsd:sequence&gt;
    &lt;/xsd:complexType&gt;
  &lt;/xsd:element&gt;
  
  &lt;xsd:element name=&quot;TwoWayOneParameterEchoRequest&quot;&gt;
    &lt;xsd:complexType&gt;
      &lt;xsd:sequence&gt;
        &lt;xsd:element name=&quot;echoString&quot; type=&quot;xsd:string&quot;/&gt;
      &lt;/xsd:sequence&gt;
    &lt;/xsd:complexType&gt;
  &lt;/xsd:element&gt;
  &lt;xsd:element name=&quot;TwoWayOneParameterEchoResponse&quot;&gt;
    &lt;xsd:complexType&gt;
      &lt;xsd:sequence&gt;
        &lt;xsd:element name=&quot;echoString&quot; type=&quot;xsd:string&quot;/&gt;
      &lt;/xsd:sequence&gt;
    &lt;/xsd:complexType&gt;
  &lt;/xsd:element&gt;
  
  &lt;xsd:element name=&quot;NoParametersRequest&quot;&gt;
    &lt;xsd:complexType/&gt;
  &lt;/xsd:element&gt;
  &lt;xsd:element name=&quot;NoParametersResponse&quot;&gt;
    &lt;xsd:complexType/&gt;
  &lt;/xsd:element&gt;
  
  &lt;xsd:element name=&quot;MultipleParametersAddItemRequest&quot;&gt;
    &lt;xsd:complexType&gt;
      &lt;xsd:sequence&gt;
        &lt;xsd:element name=&quot;itemId&quot; type=&quot;xsd:int&quot;/&gt;
        &lt;xsd:element name=&quot;itemName&quot; type=&quot;xsd:string&quot;/&gt;
        &lt;xsd:element name=&quot;price&quot; type=&quot;xsd:float&quot;/&gt;
        &lt;xsd:element name=&quot;description&quot; type=&quot;xsd:string&quot;/&gt;
      &lt;/xsd:sequence&gt;
    &lt;/xsd:complexType&gt;
  &lt;/xsd:element&gt;

  &lt;xsd:element name=&quot;MultipleParametersAddItemResponse&quot;&gt;
    &lt;xsd:complexType&gt;
      &lt;xsd:sequence&gt;
        &lt;xsd:element name=&quot;itemId&quot; type=&quot;xsd:int&quot;/&gt;
        &lt;xsd:element name=&quot;successfulAdd&quot; type=&quot;xsd:boolean&quot;/&gt;
      &lt;/xsd:sequence&gt;
    &lt;/xsd:complexType&gt;
  &lt;/xsd:element&gt;

&lt;/xsd:schema&gt;
</pre></div>

<p>Save the above XML schema file as Axis2UserGuide.xsd.</p>

<p>In order to map this schema into a JiBX binding file, you'll
need to use the xsd2jibx utility. Clear your CLASSPATH and add only
the .jar files in the xsd2jibx/lib directory. Execute the following
command to create the basic binding file:</p>

<div>
<pre>
java -jar xsd2jibx\lib\xsd2jibx.jar Axis2UserGuide.xsd
</pre></div>

<p>This operation creates the basic class files, as well as the
mapping file, called binding.xml. You'll use this file to do the
actual WSDL-to-Java conversion.</p>

<p>Remove the xsd2jibx .jar files from your CLASSPATH and add the
Axis2 .jar files back into it. Execute the command in Code Listing
3 to generate the stubs.</p>

<p><b>Code Listing 3: Generating the stubs</b></p>

<div>
<pre>
%AXIS2_HOME%\bin\WSDL2Java -uri Axis2UserGuide.wsdl -p org.apache.axis2.axis2userguide -d jibx -Ebindingfile org\apache\axis2\axis2userguide\binding.xml -s
</pre></div>

<p>Create the client file, Client.java, in the
org/apache/axis2/axis2userguide directory. Add the following code
in Code Listing 4.</p>

<p><b>Code Listing 4: Creating Client.java</b></p>

<div>
<pre>
package org.apache.axis2.axis2userguide;

public class Client{
    public static void main(java.lang.String args[]){
        try{
            Axis2UserGuideServiceStub stub =
                new Axis2UserGuideServiceStub
              (&quot;http://localhost:8080/axis2/services/Axis2UserGuideService&quot;);

            doInOnly(stub);
            twoWayOneParameterEcho(stub);
            noParameters(stub);
            multipleParameters(stub);
        } catch(Exception e){
            e.printStackTrace();
            System.out.println(&quot;\n\n\n&quot;);
        }
    }

    public static void doInOnly(Axis2UserGuideServiceStub stub){
        try{
            DoInOnlyRequest req = 
                new DoInOnlyRequest();

            req.setMessageString(&quot;fire and forget it!&quot;);

            stub.DoInOnly(req);
        } catch(Exception e){
            e.printStackTrace();
            System.out.println(&quot;\n\n\n&quot;);
        }
    }

    public static void twoWayOneParameterEcho(Axis2UserGuideServiceStub stub){
        try{
            TwoWayOneParameterEchoRequest req = 
                new TwoWayOneParameterEchoRequest();

            req.setEchoString(&quot;echo! ... echo!&quot;);
        System.out.println(stub.TwoWayOneParameterEcho(req).getEchoString());
        } catch(Exception e){
            e.printStackTrace();
            System.out.println(&quot;\n\n\n&quot;);
        }
    }

    public static void noParameters(Axis2UserGuideServiceStub stub){
        try{
            NoParametersRequest req =
                new NoParametersRequest();

            System.out.println(stub.NoParameters(req));
        } catch(Exception e){
            e.printStackTrace();
            System.out.println(&quot;\n\n\n&quot;);
        }
    }

    public static void multipleParameters(Axis2UserGuideServiceStub stub){
        try{
            MultipleParametersAddItemRequest req =
                new MultipleParametersAddItemRequest();

            req.setPrice((float)1.99);
            req.setItemId((int)23872983);
            req.setDescription(&quot;Must have for cooking&quot;);
            req.setItemName(&quot;flour&quot;);

            MultipleParametersAddItemResponse res =
                stub.MultipleParametersAddItem(req);

            System.out.println(res.getItemId());
            System.out.println(res.getSuccessfulAdd());
        } catch(Exception e){
            e.printStackTrace();
            System.out.println(&quot;\n\n\n&quot;);
        }
    }
}
</pre></div>

<p>Now it's time to compile the client. For the generated files to
be found, they need to be in the source directory, so copy the org
file to the src directory.</p>

<p>Compile the first set of classes by typing: <code>ant
jar.client</code></p>

<p>This action compiles most of the available classes, but not
everything. Fortunately, it does compile the classes needed by the
JiBX compiler, so you can now generate the actual JiBX resources.
Change to the build/classes directory and run the JiBX
compiler:</p>

<div>
<pre>
java -jar C:\apps\axis2\lib\jibx-bind.jar ..\..\org\apache\axis2\axis2userguide\binding.xml
</pre></div>

<p>Now that you have the new files in place, re-run the Ant task to
generate the client: <code>ant jar.client</code></p>

<p>This action adds all the appropriate files to the
build/lib/Axis2UserGuideService-test-client.jar file, so add that
.jar file to your CLASSPATH and run the client by typing: java
org.apache.axis2.axis2userguide.Client</p>

</html>
        </div>
      </div>
    </div>
    <hr/>
    <footer>
      <div class="container-fluid">
        <div class="row-fluid">
            <p>Copyright &copy;2004&#x2013;2021
<a href="https://www.apache.org/">The Apache Software Foundation</a>.
All rights reserved.</p>
        </div>
        </div>
    </footer>
    </body>
</html>