<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License. You may obtain a copy of the License at
  ~
  ~ http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied. See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

<html>
<head>
  <meta http-equiv="content-type" content="">
  <title>Welcome to Apache Axis2 version @axisVersion@</title>
</head>

<body lang="en">
<h1>Welcome to Apache Axis2 version @axisVersion@</h1>

<h3>@TODAY@</h3>

<pre>We are pleased to announce the release of Apache Axis2 version @axisVersion@.

Downloads are available at:
    http://ws.apache.org/axis2/download.cgi

Apache Axis2 is a complete re-design and re-write of the widely used
Apache Axis engine and is a more efficient, more scalable, more modular
and more XML-oriented Web services framework. 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 supporting WS-Security/Secure-Conversation (Apache Rampart),
WS-Trust (Apache Rahas), WS-Reliable Messaging (Apache Sandesha) and
WS-Eventing (Apache Savan) are available via the Apache Web Services
project. Please see the individual subproject sites for further information.

Major Changes Since 1.4.1:
- Refactored, pluggable transports (separate jars, with deployer)
- Clustering improvements (works with EC2)
- Over 100 JIRA issues resolved (please see JIRA)

Known Issues and Limitations in @axisVersion@ Release:
- Please see JIRA

We are striving for a simple and happy first time user experience as well as a
satisfying experienced user experience with this release. We welcome any
and all feedback at:
    axis-user@ws.apache.org (please include "[axis2]" in the subject)
    axis-dev@ws.apache.org (please include "[axis2]" in the subject)
    http://issues.apache.org/jira/browse/AXIS2

Thank you for your interest in Apache Axis2!

The Axis2 Development Team
http://ws.apache.org/axis2/

------------------------------------------------------------------------------------

Features of Apache Axis2:

Programming Model
   - Simple XML-centric client API with full WSDL and policy support
   - Support for POJO and Spring services and clients
   - Support for any message exchange pattern (MEP)
   - Synchronous and asynchronous programming model
   - Archived service deployment model supporting full service
     encapsulation with versioning support
   - Archived module deployment model supporting controlled
     extensibility with versioning support
   - Hot deployment
   - Pluggable extensions and transports
   - WS-Policy driven code generation extensions
   - Flexible service life cycle model
   - Automatic support for POX (REST) style invocation of services
   - Support for querying service's WSDL (with ?wsdl), schema (with
     ?xsd) and policies (with ?policy)

Supported Specifications
   - SOAP 1.1 and 1.2
   - Message Transmission Optimization Mechanism (MTOM)
   - XML Optimized Packaging (XOP)
   - SOAP with Attachments
   - WSDL 1.1, including both SOAP and HTTP bindings
   - WS-Addressing submission and 1.0
   - WS-Policy
   - SAAJ 1.1

Transports
   - HTTP
   - SMTP
   - JMS
   - TCP

Supported Data Bindings
   - Axis Data Binding (ADB)
   - XMLBeans
   - JibX
   - JaxBRI (Experimental)

Tools
   - WSDL2Java: Generate Java stubs and skeletons from a WSDL document.
   - Java2WSDL: Generate a WSDL document from a Java class.
   - Eclipse Plugins
   - IntelliJ Idea Plugins
   - Maven2 Plugins
   - Web application for administering Apache Axis2

<a href="http://issues.apache.org/jira/sr/jira.issueviews:searchrequest-printable/temp/SearchRequest.html?&pid=10611&updated%3Aafter=24%2FAug%2F08&status=5&status=6&resolution=1&sorter/field=issuekey&sorter/order=DESC&tempMax=1000">Bugs marked as Resolved/Fixed after 1.4.1 Release</a> (link to JIRA)

    </pre>
</body>
</html>
