<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
       "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
<head>
  <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
  <title>Apache Axis2 Archived News</title>
  <meta name="generator" content="amaya 9.2.1, see http://www.w3.org/Amaya/"
  />
  <link href="css/axis-docs.css" rel="stylesheet" type="text/css" media="all"
  />
</head>

<body xml:lang="en">
<h1>Apache Axis2 Archived News</h1>

<p>This document will contain details on each of the Axis2 versions that were
released up to the current version.</p>

<h2>Content</h2>

<h3>Apache Axis2 Releases:</h3>
<ul>
  <li><a href="#1_1">13th November 2006- Version 1.1</a></li>
  <li><a href="#1_0">04 May 2006- Version 1.0</a></li>
  <li><a href="#0_95">23 March 2006- Version 0.95</a></li>
  <li><a href="#0_94">11 January 2006- Version 0.94</a></li>
  <li><a href="#0_93">02 December 2005 - Version 0.93</a></li>
  <li><a href="#0_92">26 September 2005 - Version 0.92</a></li>
  <li><a href="#0_91">12 August 2005 - Version 0.91</a></li>
  <li><a href="#0_90">02 July 2005 - Version 0.9</a></li>
  <li><a href="#M2">07 June 2005 - Milestone 2</a></li>
  <li><a href="#M1">24 February 2005 - Milestone 1</a></li>
</ul>
<a></a>

<h2>13th November 2006 - Apache Axis2/Java Version 1.1 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download/1_1/download.cgi">Download
1.1</a>]</p>

<p>Apache Axis2 Version 1.1 comes to you with better Axis2 Databinding
Framework (ADB) support, <a
href="http://www.w3.org/TR/SOAP-attachments">attachments API</a>, Spring and
complete support for SOAP with Attachments (SwA). Check out the complete
features list below.</p>

<h3>Programming Model</h3>
<ul>
  <li>Improved, XML-centric client API including full WSDL and policy
  support</li>
  <li>Support for any message exchange pattern</li>
  <li>Synchronous and asynchronous calls</li>
  <li>Archived service deployment model</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>Support for querying service's WSDL (using ?wsdl), schema (using ?xsd)
    and policies (using ?policy)</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</li>
</ul>
<a></a>

<h2>Tools Included In This Release</h2>

<p>[<a href="http://ws.apache.org/axis2/tools/index.html">Download Tool
Plug-ins</a>]</p>
<ol type="1">
  <li>Axis2 Web Application (Web App)</li>
  <li>WSDL2WS- <a href="tools/1_1/eclipse/wsdl2java-plugin.html">eclipse
    plug-in</a><a>/</a> <a href="tools/1_1/CodegenToolReference.html">Command
    line version</a><a>/</a><a
    href="tools/1_1/idea/Idea_plug-in_userguide.html#WSDL2Java_Code_Generation">IntelliJ
    IDEA plug-in</a><a>/</a><a
    href="tools/1_1/maven-plugins/maven-wsdl2code-plugin.html">Maven2
    WSDL2Code Plug-in</a></li>
  <li>Service Archive Wizard- <a
    href="tools/1_1/eclipse/servicearchiver-plugin.html">eclipse plug-in</a>/
    <a
    href="tools/1_1/idea/Idea_plug-in_userguide.html#Create_Service_Archive">IntelliJ
    IDEA plug-in</a>/ <a
    href="tools/1_1/maven-plugins/maven-aar-plugin.html">Maven2 AAR
    Plug-in</a></li>
  <li>Java2WSDL- <a
    href="tools/1_1/maven-plugins/maven-java2wsdl-plugin.html">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>JaxMe and JAXBRI data binding support is experimental</li>
  <li>AXIS2-595: Hot re-deployment in Apache Tomcat has problems</li>
  <li>Axis Data Binding (ADB) does not support the following construct(s):
    <ol>
      <li>AXIS2-983: Support for Simple Type Union and Simple Type List</li>
      <li>AXIS2-1092: Support for xs:list inside an xs:simpleType</li>
      <li>AXIS2-1093: Support for xs:union inside xs:simpleType</li>
    </ol>
  </li>
  <li>No support yet for unwrapping of doc/lit WSDL files (in stub
  generation)</li>
  <li>No support yet for rpc/encoded style WSDL documents (in stub
  generation)</li>
  <li>Idea plugin shows random behavior when XMLBeans is used</li>
</ul>
<a></a>

<h2>04 May 2006 - Apache Axis2 Version 1.0 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 1.0</a>]</p>

<p>Apache Axis2 is a complete re-design and re-write of the widely used
Apache Axis SOAP stack to build on the lessons learnt from Apache Axis.</p>

<p>Apache Axis2 not only supports SOAP 1.1 and SOAP 1.2, but it also has
integrated support for the widely popular REST style of Web services: 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 its functionality for features such as security
and reliability. Modules currently available or under development include:</p>
<ul>
  <li><a
    href="http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=wsrm">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">WS-Coordination</a>
    and <a
    href="http://www-128.ibm.com/developerworks/library/specification/ws-tx/#atom">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">WS-Security</a>
    - Supported by <a
    href="http://ws.apache.org/axis2/modules/index.html">Apache
  Rampart</a></li>
  <li><a href="http://www.w3.org/Submission/ws-addressing/">WS-Addressing</a>
    - <a href="http://ws.apache.org/axis2/modules/index.html">Module</a>
    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 that was released two days
ago.</p>

<h2>Features</h2>

<h3>Programming Model</h3>
<ul>
  <li>Improved, XML-centric client API including full WSDL and policy
  support</li>
  <li>Support for any message exchange pattern</li>
  <li>Synchronous and asynchronous calls</li>
  <li>Archived service deployment model</li>
  <li>Archived module deployment model supporting controlled extensibility
    with versioning support</li>
  <li><a href="1_1/installationguide.html#hot_deployment">Hot
  deployment</a></li>
  <li>WS-Policy driven code generation extensions</li>
  <li>Flexible service lifecyle model</li>
  <li>Support for querying service's WSDL (using ?wsdl), schema (using ?xsd)
    and policies (using ?policy)</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</li>
</ul>

<h2><a>Tools Included In This Release</a></h2>

<p><a href="http://ws.apache.org/axis2/tools/index.html">[Download
plug-ins]</a></p>
<ol type="1">
  <li>Axis2 Web Application (Web App)</li>
  <li>WSDL2WS- <a href="../tools/1_0/eclipse/wsdl2java-plugin.html">eclipse
    plug-in</a><a>/</a> <a
    href="../tools/1_0/CodegenToolReference.html">Command line
    version</a><a>/</a><a
    href="../tools/1_0/idea/Idea_plug-in_userguide.html#WSDL2Java_Code_Generation">IntelliJ
    IDEA plug-in</a></li>
  <li>Service Archive Wizard- <a
    href="../tools/1_0/eclipse/servicearchiver-plugin.html">eclipse
    plug-in</a>/ <a
    href="../tools/1_0/idea/Idea_plug-in_userguide.html#Create_Service_Archive">IntelliJ
    IDEA 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>Recursive schemas (A includes B which includes A) may cause
  problems</li>
  <li>JaxMe data binding support is experimental</li>
  <li>Axis2-595: Hot re-deployment in Apache Tomcat has problems</li>
  <li>Axis2-666: AddressingSubmissionInHandler does not deserialize EPR
    extensibility attributes and elements</li>
  <li>AXIS2-667: Operation dispatch based on message body has a known
  issue</li>
  <li>Axis Data Binding (ADB) does not cover all of XML Schema; its an 80-20
    design point. Unsupported XML Schema features include:
    <ol>
      <li>Simple content extension and restriction</li>
      <li>Complex content restriction</li>
    </ol>
  </li>
  <li>ADB does not support xsi:type based deserialization at runtime</li>
  <li>No support yet for unwrapping of doc/lit WSDL files (in stub
  generation)</li>
  <li>No support yet for rpc/encoded style WSDL documents (in stub
  generation)</li>
</ul>
<a id="_0_95"></a>

<h2>23 March 2006 - Apache Axis2 Version 0.95 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.95</a>]</p>

<p>This release includes the following features:</p>

<h3 id="head-215f3945a40558f9ad055ed5b6601e8f93706558">Axis2 Complete
Features List</h3>
<ol type="1">
  <li>AXIOM, an XML object model working on StAX (Streaming API for XML)
    parsing optimized for SOAP 1.1/1.2 Messages. This has complete XML
    infoset support.</li>
  <li>Support for One-Way Messaging (In-Only) and Request Response Messaging
    (In-Out)</li>
  <li>Module Architecture, mechanism to extend the SOAP Processing Model</li>
  <li>Module version support , can have multiple versions of the same module
    and use them depending on the requirement.</li>
  <li>Context hierarchy</li>
  <li>Archive based deployment Model and Directory based deployment model</li>
  <li>JWS like deployment (making Java class into Web service)</li>
  <li>WSDL Code Generation Tool for Stub and skeletons</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>WSS4J module for security</li>
  <li>Improved and user friendly Client API</li>
  <li>WSDL2Java and Java2WSDL</li>
  <li>REST (REpresentational State Transfer) Support</li>
  <li>Transports supports: HTTP, SMTP, TCP, JMS</li>
  <li>Raw XML providers</li>
  <li>Support for MTOM/ MIME/ SwA</li>
  <li>SAAJ implementation</li>
  <li>DOOM</li>
  <li>Pack/Unpack capability for the generated code</li>
  <li>Axis Data Binding - ADB (Framework and Schema Compiler)</li>
  <li>Numerous bug fixes since last release</li>
  <li>Transport framework improvements (ListenerManager)-<span
    style="color: #FF0000">New</span></li>
  <li>AxisServlet auto start when application server get start up-<span
    style="color: #FF0000">New</span></li>
  <li>Module disengagement support-<span
  style="color: #FF0000">New</span></li>
  <li>Loading module (.mar) from classpath-<span
    style="color: #FF0000">New</span></li>
  <li>Sessions scoping for Application, SOAP, Transport and Request
    levels-<span style="color: #FF0000">New</span></li>
</ol>

<p id="head-5bb5aa099717d1d49642f7ae2d63ce5cf94487ad"><strong><em>Axis2
Experimental Features List</em></strong></p>
<ol type="1">
  <li>Server side &amp; client side Web Service Policy support</li>
  <li>?wsdl and ?xsd support</li>
  <li>Generating ServiceClient for a given WSDL and invoke the corresponding
    service using generated client.</li>
</ol>

<h3 id="head-7dd8e783bb9e22fb00f88748855bb6e500111e12">Major Changes Since
Last Release</h3>
<ol type="1">
  <li>Transport framework improvements (ListenerManager)</li>
  <li>Changed the way of adding action to mapping (wsamapping) from parameter
    to child element so with this version onward the way of adding mapping is
    as follows:</li>
  <pre>   &lt;actionMapping&gt;MyMapping&lt;/actionMapping&gt;
   </pre>
  <li>Refactored following packages in Axiom.
    <ul>
      <li>org.apache.axiom.om.impl.llom.builder to
        org.apache.axiom.om.impl.builder</li>
      <li>org.apache.axiom.om.impl.llom.mtom to
      org.apache.axiom.om.impl.mtom</li>
      <li>org.apache.axiom.om.impl.llom.serialize to
        org.apache.axiom.om.impl.serialize</li>
      <li>org.apache.axiom.om.impl.llom.traverse to
        org.apache.axiom.om.impl.traverse</li>
    </ul>
  </li>
</ol>

<h3 id="head-83371cc3d6961295be042f584c7b74d81cca23c4">Tools Included In This
Release</h3>
<ol type="1">
  <li>Axis2 Web Application (Web App)</li>
  <li>WSDL2WS- Command line version</li>
  <!--<li>Service Archive Wizard- eclipse Plugin</li>-->
</ol>

<h3 id="head-599c5a50552f02ebdeb5f58ef8da289234812ca4">What's Still To
Do?</h3>

<p>See list of what we think needs to be done, and consider helping out if
you're interested &amp; able!</p>
<ol type="1">
  <li>JAX-RPC 1.1 and/or JAX-WS compliance</li>
  <li>SOAP Encoding</li>
  <li>Binary serialization and de-serialization support</li>
  <li>Management Interface for Axis2</li>
  <li>Implementation of other Transports.</li>
  <li>Resource framework implementation (WS-RF) and Enterprise web services
    such as JSR 109 support</li>
  <li>Completion of Interop tests</li>
</ol>
<a id="_0_94"></a>

<h2>11 January 2006 - Apache Axis2 Version 0.94 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.94</a>]</p>

<p>This release includes the following features:</p>

<h3 id="head-215f3945a40558f9ad055ed5b6601e8f93706558">Complete Features
List</h3>
<ol type="1">
  <li>AXIOM, an XML object model working on StAX (Streaming API for XML)
    parsing optimized for SOAP 1.1/1.2 Messages. This has complete XML
    infoset support.</li>
  <li>Support for One-Way Messaging (In-Only) and Request Response Messaging
    (In-Out)</li>
  <li>Module Architecture, mechanism to extend the SOAP Processing Model</li>
  <li>Module version support , can have multiple versions of the same module
    and use them depending on the requirement.</li>
  <li>Context hierarchy</li>
  <li>Archive based deployment Model and Directory based deployment model</li>
  <li>JWS like deployment (making Java class into Web service)</li>
  <li>WSDL Code Generation Tool for Stub and skeletons</li>
  <li>WS-Addressing, both the submission (2004/08) and final (2005/08)
    versions</li>
  <li>WSS4J module for security</li>
  <li>Improved and user friendly Client API</li>
  <li>WSDL2Java</li>
  <li>REST (REpresentational State Transfer) Support</li>
  <li>Transports supports: HTTP, SMTP, TCP, JMS</li>
  <li>Raw XML providers</li>
  <li>Support for MTOM/ MIME/ SwA</li>
  <li>SAAJ implementation</li>
  <li>DOOM - <span style="color: #FF0000">New</span></li>
  <li>Pack/Unpack capability for the generated code- <span
    style="color: #FF0000">New</span></li>
  <li>Axis Data Binding - ADB (Framework and Schema Compiler)</li>
  <li>Numerous bug fixes since last release</li>
</ol>

<h4 id="head-5bb5aa099717d1d49642f7ae2d63ce5cf94487ad">Axis2 Experimental
Features List</h4>
<ol type="1">
  <li>Sessions scoping for Application, SOAP, Transport and Request
  levels</li>
  <li>Server side Web Service Policy support</li>
  <li>?wsdl and ?xsd support</li>
  <li>Java2WSDL</li>
  <li>Generating ServiceClient for a given WSDL and invoke the corresponding
    service using generated client.</li>
</ol>

<h3 id="head-7dd8e783bb9e22fb00f88748855bb6e500111e12">Major Changes Since
Last Release</h3>
<ol type="1">
  <li>Fixing of memory leaks</li>
  <li>Client API changes , Introducing ServiceClient instead of MEPClient,
    InOnlyMEPClient, InOutMEPClient, Call. (Please note that the above
    classes will be deprecated in this release.)</li>
  <li>Module versioning support , can have multiple versions of the same
    module and use them depending on the requirement.</li>
  <li>Code generator improved to process multi-port WSDL's properly</li>
  <li>Packing and unpacking options for the code generated classes</li>
</ol>

<h3 id="head-83371cc3d6961295be042f584c7b74d81cca23c4">Tools Included In This
Release</h3>
<ol type="1">
  <li>Axis2 Web Application (Web App)</li>
  <li>WSDL2WS- Eclipse plugin/ Command line version/ IntelliJ IDEA plugin</li>
  <li>Service Archive Wizard- Eclipse plugin/ IntelliJ IDEA plugin</li>
</ol>

<h3 id="head-599c5a50552f02ebdeb5f58ef8da289234812ca4">What's Still To
Do?</h3>
<ol type="1">
  <li>JAX-RPC 1.1 and/or JAX-WS compliance</li>
  <li>SOAP Encoding</li>
  <li>Binary serialization and de-serialization support</li>
  <li>Management Interface for Axis2</li>
  <li>Implementation of other Transports.</li>
  <li>Resource framework implementation (WS-RF) and Enterprise web services
    such as JSR 109 support</li>
  <li>Completion of interop tests</li>
</ol>
<a id="_0_93"></a>

<h2>02 December 2005 - Apache Axis2 Version 0.93 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.93</a>]</p>

<p>Axis2 is becoming more and more stable. This 0.93 release contains the
following additional features:</p>
<ul>
  <li>JDK 1.5 compatibility</li>
  <li>Configurable handler chains using axis2.xml</li>
  <li>Improved class loader hierarchy</li>
  <li>Improved security module with dynamic configurability</li>
  <li>ADB (Axis Data Binding) with complete simple types support and limited
    complex type support</li>
  <li>Jalopy based code formatting of generated code</li>
  <li>Proxy support and NTLM authentication</li>
  <li>support for rpc/literal</li>
  <li>And numerous bug fixes after 0.92 release</li>
</ul>

<h3>Experimental Features List</h3>
<ol type="1">
  <li>DOOM - DOM implementation over OM</li>
  <li>Java2WSDL</li>
  <li>RPC Support</li>
</ol>

<h3>Major Changes Since Last Release</h3>
<ol>
  <li>Refactored org.apache.axis2.clientapi to org.apache.axis2.client</li>
  <li>Introduction of Options to configure clients</li>
  <li>Renaming of descriptors. OperationDescription -&gt; AxisOperation,
    ServiceDescription -&gt; AxisService, ServiceGroupDescription -&gt;
    AxisServiceGroup</li>
</ol>
We are getting closer to a 1.0 release, the remaining tasks to be completed
before a 1.0 release include: SOAP 1.1 and 1.2 validation, Our own data
binding implementation, WSDL Generation. <a id="_0_92"></a>

<h2>26 September 2005 - Apache Axis2 Version 0.92 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.92</a>]</p>

<p>This 0.92 release contains the following additional features:</p>
<ul>
  <li>WS-Security support using WSS4J</li>
  <li>Support for context hierarchy serialization</li>
  <li>Service Groups</li>
  <li>and numerous bug fixes after 0.91 release</li>
</ul>

<h3>The Release Includes Following Tools</h3>
<ul>
  <li>Admin Web App</li>
  <li>WSDL2Java, eclipse Plugin/Command line version</li>
  <li>Service Archive Wizard, eclipse Plugin</li>
  <li>Module Archive Wizard, eclipse Plugin</li>
  <li>Service Archive Wizard, IntelliJ IDEA Plugin</li>
</ul>

<p><em>We are getting closer to a 1.0 release, the remaining tasks to be
completed before a 1.0 release include: SOAP 1.1 and 1.2 validation, Our own
data binding implementation, WSDL Generation.</em></p>
<a id="_0_91"></a>

<h2>12 August 2005 - Apache Axis2 Version 0.91 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.91</a>]</p>

<p>This 0.91 release is a glimpse of 1.0 that should be coming soon. This
0.91 release contains the following additional features:</p>
<ul>
  <li>File Caching for MTOM</li>
  <li>SOAP Faults based on the SOAP version and better fault handling</li>
  <li>Different character encoding support</li>
  <li>Improved infoset support in AXIOM</li>
  <li>Improved code generation templates</li>
  <li>Numerous bug fixes</li>
</ul>
<a id="_0_90"></a>

<h2>02 July 2005 - Apache Axis2 Version 0.9 Released!</h2>

<p>[<a href="http://ws.apache.org/axis2/download.cgi">Download 0.9</a>]</p>

<p>Axis2 is taking shape. This 0.9 release is a glimpse of 1.0 that should be
coming soon. This 0.9 release contains the following additional features:</p>
<ul>
  <li>XML Beans based data binding support</li>
  <li>Support for WS-Addressing, both the submission and final versions</li>
  <li>REST Web Service Support</li>
  <li>MTOM/SWA attachments support</li>
  <li>SAAJ implementation</li>
</ul>
<a id="M2"></a>

<h2>07 June 2005 - Apache Axis2 Milestone 2 (M2) Released</h2>

<p>Apache Axis2 is starting to take shape, features implemented in this
second milestone release are:</p>
<ul>
  <li>Modules - a mechanism to extend the SOAP Processing Model</li>
  <li>Support for WS-Addressing</li>
  <li>Axis2 Client API - Blocking and Non-Blocking API</li>
  <li>Support for One-Way Messaging and Request Response Messaging</li>
  <li>WSDL Code Generation Tool.</li>
  <li>HTTP, SMTP, and TCP transport Support</li>
</ul>
<b>This release also includes following tools:</b>
<ul>
  <li>Administration web application,</li>
  <li>WSDL2WS-Eclipse plug-in</li>
  <li>Service Archive Wizard- Eclipse plug-in</li>
  <li>Module Archive Wizard-Eclipse plug-in</li>
</ul>
<a id="M1"></a>

<h2>24 February 2005 - Apache Axis2 Milestone 1 (M1) Released</h2>

<p>This first milestone release of Axis2 includes the following features:</p>
<ul>
  <li>AXIOM, a SOAP specific streaming XML infoset model for SOAP 1.1/1.2
    Messages</li>
  <li>WSDL Object Model built based on the proposed WSDL 2.0 Component
  Model.</li>
  <li>Handler framework with the support to specify the location of the
    Handler in a specific Phase</li>
  <li>Support to bundle and enable the Handlers as Modules</li>
  <li>Support for the Synchronous and Asynchronous IN-OUT messaging over HTTP
    transport</li>
  <li>Hot deployment of Web Services</li>
</ul>
</body>
</html>
