<?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 xmlns="http://www.w3.org/1999/xhtml">
<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/"
  />
</head>

<body>
<h1>Apache Axis2 Archived News</h1>

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

<h2>Content</h2>
<h3>Apache Axis2 Releases:</h3>
<ul>
  <li><a href="#0_94">11 January 2006- Version0.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 name="0_94"></a>
<h2>11 January 2006 - Apache Axis2 Version 0.94 Released! (<a
href="http://ws.apache.org/axis2/download.cgi">Download 0.94</a>)</h2>

<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>Content 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 name="0_93"></a>
<h2>02 December 2005 - Apache Axis2 Version 0.93 Released! ( <a
href="http://ws.apache.org/axis2/download.cgi">Download 0.93</a>)</h2>

<p>Axis2 is becoming more and more stable. <a
href="http://ws.apache.org/axis2/download.cgi">Download it!.</a>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 name="0_92"></a>
<h2>26 September 2005 - Apache Axis2 Version 0.92 Released! <a
href="http://ws.apache.org/axis2/download.cgi">(Download 0.92)</a></h2>

<p>Axis2 is becoming more and more stable. <a
href="releases.html#0.9">Download it!</a> This 0.92 release is a glimpse of
1.0 that should be coming soon. 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 name="0_91"></a>
<h2>12 August 2005 - Apache Axis2 Version 0.91 Released! <a
href="http://ws.apache.org/axis2/download.cgi">(Download 0.91)</a></h2>

<p>Axis2 is becoming more and more stable. <a
href="http://ws.apache.org/axis2/download.cgi">Download it!</a> 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 name="0_90"></a>
<h2>02 July 2005 - Apache Axis2 Version 0.9 Released! <a
href="releases.html#0.9">(Download 0.9)</a></h2>

<p>Axis2 is taking shape. <a href="releases.html#0.9">Download it!</a> 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 name="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 name="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>
