<html>
<head>
  <meta http-equiv="content-type" content="">
  <title>Apache Axis2/Java - Next Generation Web Services</title>
  <link href="css/axis-docs.css" rel="stylesheet" type="text/css" media="all">
</head>

<body lang="en">
<h1>Welcome to Apache Axis2/Java</h1>

<h2>27th April 2007 - Apache Axis2/Java Version @axis2_version@ Released!</h2>

<p>[ <a
href="http://ws.apache.org/axis2/download.cgi"><strong>Download</strong></a>
] | [ <a href="@axis2_version_dir@/index.html"><strong>Documents
Home</strong></a> ]</p>

<p>Apache Axis2 is the core engine for Web services. It is a complete
re-design and re-write of the widely used <a
href="http://ws.apache.org/axis/">Apache Axis</a> SOAP stack, built on the
lessons learnt from Apache Axis.</p>

<h3><em>Apache Axis Project in a Nutshell:</em></h3>

<p>Apache Axis is an implementation of the SOAP ("Simple Object Access
Protocol") <a href="http://www.w3.org/TR/SOAP">submission</a> to W3C.</p>

<p>Extract from the draft W3C specification:</p>

<blockquote>
  "SOAP is a lightweight protocol for exchanging structured information in a
  decentralized, distributed environment. It is an XML based protocol that
  consists of three parts: an envelope that defines a framework for
  describing what is in a message and how to process it, a set of encoding
  rules for expressing instances of application-defined datatypes, and a
  convention for representing remote procedure calls and
responses."</blockquote>

<p>This project is a follow-on to the <a
href="http://ws.apache.org/soap">Apache SOAP project</a>.</p>

<p>Please see the <a href="http://ws.apache.org/axis/ref.html">Axis Reference
Library</a> for a list of technical resources that should prove useful on
this project.</p>

<h3><em>Why Apache Axis2:</em></h3>

<p>A new architecture for Axis was introduced during the August 2004 Summit
in Colombo, Sri Lanka. The new architecture on which Axis2 is based on is
more flexible, efficient and configurable in comparison to <a
href="http://ws.apache.org/axis/java/architecture-guide.html">Axis1.x
architecture</a>. Some well established concepts from Axis 1.x, like handlers
etc., have been preserved in the new architecture.</p>

<p>Apache Axis2 not only supports SOAP 1.1 and SOAP 1.2, but it also has
integrated support for the widely popular <a
href="http://www.xfront.com/REST-Web-Services.html">REST style of Web
services</a>. The same business logic implementation can offer both a WS-*
style interface as well as a REST style interface simultaneously.</p>

<p>Apache Axis2 is more efficient, more modular and more XML-oriented than
the older version. It is carefully designed to support the easy addition of
plug-in "modules" that extend their functionality for features such as
security and reliability. The <a
href="http://ws.apache.org/axis2/modules/index.html">Modules</a> currently
available or under development include:</p>
<ul>
  <li><a
    href="http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wsrm"
    target="_blank">WS-ReliableMessaging</a> - Supported by <a
    href="http://ws.apache.org/sandesha/sandesha2/">Apache Sandesha2</a></li>
  <li><a
    href="http://www-128.ibm.com/developerworks/library/specification/ws-tx/#coor"
    target="_blank">WS-Coordination</a>  and <a
    href="http://www-128.ibm.com/developerworks/library/specification/ws-tx/#atom"
    target="_blank">WS-AtomicTransaction</a> - Supported by <a
    href="http://ws.apache.org/kandula/">Apache Kandula2</a></li>
  <li><a
    href="http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wss"
    target="_blank">WS-Security</a> - Supported by <a
    href="http://ws.apache.org/axis2/modules/rampart/@axis2_version_dir@/security-module.html">Apache
    Rampart</a></li>
  <li><a href="http://www.w3.org/Submission/ws-addressing/"
    target="_blank">WS-Addressing</a> -Module included as part of Axis2
  core</li>
</ul>

<p>Apache Axis2 is built on <a
href="http://ws.apache.org/commons/axiom/index.html">Apache AXIOM</a>, a new
high performant, pull-based XML object model.</p>

<p>Axis2 comes with many new features, enhancements and industry
specification implementations. The key features offered are as follows:</p>
<ul>
  <li><p style="margin-bottom: 0in"><strong>Speed</strong> - Axis2 uses its
    own object model and StAX (Streaming API for XML) parsing to achieve
    significantly greater speed than earlier versions of Apache Axis.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Low memory foot print</strong>-
    Axis2 was designed ground-up keeping low memory foot print in mind.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>AXIOM</strong> - Axis2 comes with
    its own light-weight object model, AXIOM, for message processing which is
    extensible, highly performant and is developer convenient.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong><a name="Hot_Deployment"></a>Hot
    Deployment</strong> - Axis2 is equipped with the capability of deploying
    Web services and handlers while the system is up and running. In other
    words, new services can be added to the system without having to shut
    down the server. Simply drop the required Web service archive into the
    services directory in the repository, and the deployment model will
    automatically deploy the service and make it available for use.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Asynchronous Web
    services</strong> - Axis2 now supports asynchronous Web services and
    asynchronous Web services invocation using non-blocking clients and
    transports.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>MEP Support</strong> - Axis2 now
    comes handy with the flexibility to support Message Exchange Patterns
    (MEPs) with in-built support for basic MEPs defined in WSDL 2.0.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Flexibility</strong> - The Axis2
    architecture gives the developer complete freedom to insert extensions
    into the engine for custom header processing, system management, and
    <em>anything else you can imagine</em>.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Stability</strong> - Axis2
    defines a set of published interfaces which change relatively slowly
    compared to the rest of Axis.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Component-oriented
    Deployment</strong> - You can easily define reusable networks of Handlers
    to implement common patterns of processing for your applications, or to
    distribute to partners.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Transport Framework</strong> - We
    have a clean and simple abstraction for integrating and using Transports
    (i.e., senders and listeners for SOAP over various protocols such as
    SMTP, FTP, message-oriented middleware, etc), and the core of the engine
    is completely transport-independent.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>WSDL support</strong> - Axis2
    supports the Web Service Description Language, version <a
    href="http://www.w3.org/TR/wsdl">1.1</a> and <a
    href="http://www.w3.org/TR/wsdl20/">2.0</a>, which allows you to easily
    build stubs to access remote services, and also to automatically export
    machine-readable descriptions of your deployed services from Axis2.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Add-ons</strong> - Several Web
    services specifications have been incorporated including <a
    href="http://ws.apache.org/wss4j/" target="_blank">WSS4J</a> for security
    (Apache Rampart), <a href="http://ws.apache.org/sandesha/"
    target="_blank">Sandesha</a> for reliable messaging, <a
    href="http://ws.apache.org/kandula/" target="_blank">Kandula</a> which is
    an encapsulation of WS-Coordination, WS-AtomicTransaction and
    WS-BusinessActivity.</p>
  </li>
  <li><p style="margin-bottom: 0in"><strong>Composition and
    Extensibility</strong> - Modules and phases improve support for
    composability and extensibility. Modules support composability and can
    also support new WS-* specifications in a simple and clean manner. They
    are however not <a href="#Hot_Deployment">hot deployable</a> as they
    change the overall behavior of the system.</p>
  </li>
</ul>

<p>We hope you enjoy using Axis2. Please note that this is an open-source
effort. If you feel the code could use new features or fixes, or the
documentation can be improved, please get involved and lend us a hand! The
Axis developer community welcomes your participation.</p>

<p>Let us know what you think! Send your feedback on Axis2 to "<a
href="mailto:axis-user@ws.apache.org">axis-user@ws.apache.org</a>". Make sure
to prefix the subject of the mail with [Axis2].</p>

<h2>Features of Axis2 Latest Version</h2>

<p>Apache Axis2 Version @axis2_version@ comes with performance improvements
and bug fixes over the 1.1.1 release. Check out the complete list of features
below.</p>

<h3>Programming Model</h3>
<ul>
  <li>Improved, XML-centric client API including full WSDL and policy
  support</li>
  <li>Support for POJO and Spring services and clients</li>
  <li>Support for any message exchange pattern</li>
  <li>Synchronous and asynchronous calls</li>
  <li>Archived service deployment model supporting full service
     encapsulation with versioning support</li>
  <li>Archived module deployment model supporting controlled extensibility
    with versioning support</li>
  <li><a href="#Hot_Deployment">Hot deployment</a></li>
  <li>WS-Policy driven code generation extensions</li>
  <li>Flexible service life cycle model</li>
  <li>Automatic support for POX (REST) style invocation of services</li>
  <li>Support for querying a service's WSDL (using ?wsdl), schema (using
    ?xsd) and policies (using ?policy)</li>
  <li>WSDL 2.0</li>
  <li>POJO annotation (<a href="http://jcp.org/en/jsr/detail?id=181">JSR
    181</a>)</li>
  <li>JAX-WS intregration</li>
  <li>Custom Deployers</li>
  <li>Binary serialization (Fast Infoset)</li>
  <li>JSON support</li>
  <li>EJB Provider support</li>
</ul>

<h3>Supported Specifications</h3>
<ul>
  <li>SOAP 1.1 and 1.2</li>
  <li>Message Transmission Optimization Mechanism (MTOM), XML Optimized
    Packaging (XOP) and SOAP with Attachments</li>
  <li>WSDL 1.1, including both SOAP and HTTP bindings</li>
  <li>WS-Addressing (submission and final)</li>
  <li>WS-Policy</li>
  <li>SAAJ 1.1</li>
</ul>

<h3>Transports</h3>
<ul>
  <li>HTTP</li>
  <li>SMTP</li>
  <li>JMS</li>
  <li>TCP</li>
</ul>

<h3>Supported Data Bindings</h3>
<ul>
  <li>Axis Data Binding (ADB)</li>
  <li>XMLBeans</li>
  <li>JibX</li>
  <li>JaxMe (Experimental)</li>
  <li>JaxBRI (Experimental)</li>
</ul>

<h2><a name="Tools_included_in this_Release">Tools Included in This
Release</a></h2>

<p>[<a href="http://ws.apache.org/axis2/tools/index.html"
target="_blank">Download Tool Plug-ins</a>]</p>
<ol type="1">
  <li>Axis2 Web Application (Web App)</li>
  <li>WSDL2WS- <a
    href="tools/@axis2_version_dir@/eclipse/wsdl2java-plugin.html"
    target="_blank">eclipse plug-in</a><a>/</a> <a
    href="tools/@axis2_version_dir@/CodegenToolReference.html"
    target="_blank">Command line version</a><a>/</a><a
    href="tools/@axis2_version_dir@/idea/Idea_plug-in_userguide.html#WSDL2Java_Code_Generation"
    target="_blank">IntelliJ IDEA plug-in</a><a>/</a><a
    href="tools/@axis2_version_dir@/maven-plugins/maven-wsdl2code-plugin.html"
    target="_blank">Maven2 WSDL2Code Plug-in</a></li>
  <li>Service Archive Wizard- <a
    href="tools/@axis2_version_dir@/eclipse/servicearchiver-plugin.html"
    target="_blank">eclipse plug-in</a>/ <a
    href="tools/@axis2_version_dir@/idea/Idea_plug-in_userguide.html#Create_Service_Archive"
    target="_blank">IntelliJ IDEA plug-in</a>/ <a
    href="tools/@axis2_version_dir@/maven-plugins/maven-aar-plugin.html"
    target="_blank">Maven2 AAR Plug-in</a></li>
  <li>Java2WSDL- <a
    href="tools/@axis2_version_dir@/maven-plugins/maven-java2wsdl-plugin.html"
    target="_blank">Maven2 Java2WSDL Plug-in</a></li>
</ol>

<h2>Extension Modules</h2>
<ul>
  <li>Apache Rampart: Supporting WS-Security (and soon WS-Policy)</li>
  <li>Apache Sandesha2: Supporting WS-Reliable Messaging</li>
</ul>
(Apache Axis2 comes built in with a module that supports WS-Addressing.)

<h2>Known Issues and Limitations</h2>
<ul>
  <li>Xml-beans databinding does not support response unwrapping</li>
  <li>ADB databinding does not support minOccurs and maxOccurs attributes in
    sequence and choice elements (i.e., <code>&lt;sequence minOccurs="0"
    maxOccurs="unbounded"&gt;&lt;/sequence&gt;</code>)</li>
  <li>Unable to produce original WSDL in the case of WSDL 2.0, therefore the
    AxisService is serialized to produce ?wsdl2.</li>
</ul>

<h2>Archived News</h2>

<p>For information on previous Axis2 releases running up to the current
release see the <a href="archived_news.html" target="_blank">'Axis2 Archived
News'</a> page.</p>
For other news items from Apache Software Foundation see:
<ul>
  <li><a
    href="http://www.apachenews.org/archives/cat_apache_webservices_index.html">Web
    services related news on the Apache News Blog Online</a></li>
  <li><a href="http://www.apachenews.org/">The Apache News Blog
  Online</a></li>
</ul>
</body>
</html>
