<!--
  ~ 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>Apache Axis2 1.5.3 Release Notes</title>
</head>

<body lang="en">
<h1>Apache Axis2 1.5.3 Release Notes</h1>

<h2>About this version</h2>

<p>1.5.3 is a maintenance release that contains the following improvements:</p>
<ul>
<li>Improved support for SSL when using the servlet transport: Axis2 can now be configured
so that generated WSDLs contain https endpoints (<a href="https://issues.apache.org/jira/browse/AXIS2-4465">AXIS2-4465</a>).</li>
<li>Improved compatibility with Rampart (<a href="https://issues.apache.org/jira/browse/AXIS2-3213">AXIS2-3213</a>
and <a href="https://issues.apache.org/jira/browse/AXIS2-4870">AXIS2-4870</a>) and Sandesha2 (potential HTTP connection pool starvation).</li>
<li>Axiom has been upgraded to 1.2.10. This version contains performance improvements relevant for Rampart.</li>
<li>Application (business) faults are no longer logged at level ERROR (<a href="https://issues.apache.org/jira/browse/AXIS2-4280">AXIS2-4280</a>).</li>
<li>Improved conformance to the SAAJ specifications. The 1.5.3 release contains a set of fixes and improvements for the SAAJ
implementation developed on the trunk and not included in previous releases from the 1.5 branch.</li>
<li>Axis2 now relies exclusively on dependencies available from the Maven central repository, and no other Maven
repositories are required. This in particular fixes a build problem that appeared after the 1.5.2 release.</li>
<li>The Eclipse and IntelliJ IDEA plugins are again available for <a href="http://axis.apache.org/axis2/java/core/tools/index.html">download</a> via the Axis2 Web site
(previous 1.5.x versions could only be downloaded from the Maven repository).</li>
</ul>

<h2>About Axis2</h2>

<p>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.</p>

<p>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.</p>

<h2>Feedback</h2>

<p>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:</p>
<ul>
  <li><a href="mailto:java-user@axis.apache.org">java-user@axis.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="mailto:java-dev@axis.apache.org">java-dev@axis.apache.org</a> (please include "[axis2]" in the subject)</li>
  <li><a href="http://issues.apache.org/jira/browse/AXIS2">http://issues.apache.org/jira/browse/AXIS2</a></li>
</ul>

<p>Thank you for your interest in Apache Axis2!</p>

<p><i>The Axis2 Development Team<br>
<a href="http://axis.apache.org/axis2/java/core/">http://axis.apache.org/axis2/java/core/</a></i></p>
</body>
</html>
