Update JavaScriptUtils

Add escaping for <, >, and PS/LS line terminators Issue: SPR-9983
Increment version to 3.1.5.BUILD-SNAPSHOT
2026-06-08 17:33:33 +00:00 · 2013-02-15 06:45:54 -05:00 · 2013-01-23 15:00:13 +01:00 · 2013-01-23 14:58:18 +01:00 · 2013-01-23 12:53:25 +01:00 · 2013-01-23 12:47:49 +01:00
12040 changed files with 649289 additions and 978228 deletions
@@ -1,10 +0,0 @@
-root = true
-
-[*.{adoc,bat,groovy,html,java,js,jsp,kt,kts,md,properties,py,rb,sh,sql,svg,txt,xml,xsd}]
-charset = utf-8
-
-[*.{groovy,java,kt,kts,xml,xsd}]
-indent_style = tab
-indent_size = 4
-continuation_indent_size = 8
-end_of_line = lf
@@ -10,31 +10,17 @@ integration-repo
 ivy-cache
 jxl.log
 jmx.log
-derby.log
-spring-test/test-output/
-.gradle
-argfile*
-pom.xml
-activemq-data/
+org.springframework.jdbc/derby.log
+org.springframework.spring-parent/.classpath
+org.springframework.spring-parent/.project
+org.springframework.test/test-output/
+target
+spring-build/lib/docbook

-classes/
+# ignore files and directories related to gradle build
+/.classpath
+/.project
+/.gradle
 /build
-buildSrc/build
-/spring-*/build
-/src/asciidoc/build
-target/
-
-# Eclipse artifacts, including WTP generated manifests
-.classpath
-.project
-spring-*/src/main/java/META-INF/MANIFEST.MF
-
-# IDEA artifacts and output dirs
-*.iml
-*.ipr
-*.iws
-.idea
-out
-test-output
-atlassian-ide-plugin.xml
-.gradletasknamecache
+/spring-*
+!/spring-framework-reference
@@ -1,23 +0,0 @@
-Juergen Hoeller <jhoeller@pivotal.io> jhoeller <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@vmware.com>
-<jhoeller@pivotal.io> <jhoeller@gopivotal.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@vmware.com>
-<rstoyanchev@pivotal.io> <rstoyanchev@gopivotal.com>
-<pwebb@pivotal.io> <pwebb@vmware.com>
-<pwebb@pivotal.io> <pwebb@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@vmware.com>
-<cbeams@pivotal.io> <cbeams@gopivotal.com>
-<cbeams@pivotal.io> <cbeams@gmail.com>
-<apoutsma@pivotal.io> <apoutsma@vmware.com>
-<apoutsma@pivotal.io> <apoutsma@gopivotal.com>
-<apoutsma@pivotal.io> <poutsma@mac.com>
-<ogierke@pivotal.io> <ogierke@vmware.com>
-<ogierke@pivotal.io> <ogierke@gopivotal.com>
-<dsyer@pivotal.io> <dsyer@vmware.com>
-<dsyer@pivotal.io> <dsyer@gopivotal.com>
-<dsyer@pivotal.io> <david_syer@hotmail.com>
-<aclement@pivotal.io> <aclement@vmware.com>
-<aclement@pivotal.io> <aclement@gopivotal.com>
-<aclement@pivotal.io> <andrew.clement@gmail.com>
-<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
-Nick Williams <nicholas@nicholaswilliams.net> Nicholas Williams <nicholas@nicholaswilliams.net>
@@ -1,9 +0,0 @@
-#com.springsource.sts.gradle.core.preferences.GradleImportPreferences
-#Thu Aug  9 11:34:43 CEST 2012
-enableAfterTasks=true
-afterTasks=afterEclipseImport;
-enableDependendencyManagement=false
-enableBeforeTasks=true
-projects=;spring-aop;spring-aspects;spring-beans;spring-context;spring-context-support;spring-core;spring-expression;spring-instrument;spring-instrument-tomcat;spring-jdbc;spring-jms;spring-orm;spring-oxm;spring-struts;spring-test;spring-tx;spring-web;spring-webmvc;spring-webmvc-portlet;
-enableDSLD=false
-beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;
@@ -1,5 +0,0 @@
-#com.springsource.sts.gradle.core.preferences.GradleProjectPreferences
-#Tue Feb 21 14:38:31 CET 2012
-com.springsource.sts.gradle.classpath.enableSorting=false
-com.springsource.sts.gradle.rootprojectloc=
-com.springsource.sts.gradle.linkedresources=
@@ -1,9 +0,0 @@
-#com.springsource.sts.gradle.core.actions.GradleRefreshPreferences
-#Thu Aug  9 11:34:43 CEST 2012
-enableAfterTasks=true
-afterTasks=afterEclipseImport;
-useHierarchicalNames=false
-enableBeforeTasks=true
-addResourceFilters=false
-enableDSLD=false
-beforeTasks=cleanEclipse;eclipse;\:spring-oxm\:compileTestJava;
@@ -1,44 +0,0 @@
-= Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of fostering an open
-and welcoming community, we pledge to respect all people who contribute through reporting
-issues, posting feature requests, updating documentation, submitting pull requests or
-patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for
-everyone, regardless of level of experience, gender, gender identity and expression,
-sexual orientation, disability, personal appearance, body size, race, ethnicity, age,
-religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic addresses,
-  without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments,
-commits, code, wiki edits, issues, and other contributions that are not aligned to this
-Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors
-that they deem inappropriate, threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to fairly and
-consistently applying these principles to every aspect of managing this project. Project
-maintainers who do not follow or enforce the Code of Conduct may be permanently removed
-from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces when an
-individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by
-contacting a project maintainer at spring-code-of-conduct@pivotal.io . All complaints will
-be reviewed and investigated and will result in a response that is deemed necessary and
-appropriate to the circumstances. Maintainers are obligated to maintain confidentiality
-with regard to the reporter of an incident.
-
-This Code of Conduct is adapted from the
-https://contributor-covenant.org[Contributor Covenant], version 1.3.0, available at
-https://contributor-covenant.org/version/1/3/0/[contributor-covenant.org/version/1/3/0/]
@@ -1,128 +0,0 @@
-# Contributing  to the Spring Framework
-
-First off, thank you for taking the time to contribute! :+1: :tada: 
-
-### Table of Contents
-
-* [Code of Conduct](#code-of-conduct)
-* [How to Contribute](#how-to-contribute)
-  * [Discuss](#discuss)
-  * [Create a Ticket](#create-a-ticket)
-  * [Ticket Lifecycle](#ticket-lifecycle)
-  * [Submit a Pull Request](#submit-a-pull-request)
-* [Build from Source](#build-from-source)
-* [Source Code Style](#source-code-style)
-* [Reference Docs](#reference-docs)
-
-### Code of Conduct
-
-This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc).
-By participating you are expected to uphold this code.
-Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
-
-### How to Contribute
-
-#### Discuss
-
-If you have a question, check StackOverflow using
-[this list of tags](https://spring.io/questions), organized by Spring project.
-Find an existing discussion or start a new one if necessary.
-
-If you suspect an issue, perform a search in the
-[JIRA issue tracker](https://jira.spring.io/browse/SPR), using a few different keywords.
-When you find related issues and discussions, prior or current, it helps you to learn and
-it helps us to make a decision.
-
-#### Create a Ticket
-
-Reporting an issue or making a feature request is a great way to contribute. Your feedback
-and the conversations that result from it provide a continuous flow of ideas. 
-
-Before you create a ticket, please take the time to [research first](#discuss).
-
-If creating a ticket after a discussion on StackOverflow, please provide a self-sufficient description in the ticket, independent of the details on StackOverview. We understand this is extra work but the issue tracker is an important place of record for design discussions and decisions that can often be referenced long after the fix version, for example to revisit decisions, to understand the origin of a feature, and so on.
-
-When ready create a ticket in the [JIRA issue tracker](https://jira.spring.io/browse/SPR).
-
-#### Ticket Lifecycle
-
-When an issue is first created, it may not be assigned and will not have a fix version.
-Within a day or two, the issue is assigned to a specific committer and the target
-version is set to "Waiting for Triage". The committer will then review the issue, ask for
-further information if needed, and based on the findings, the issue is either assigned a fix
-version or rejected.
-
-When a fix is ready, the issue is marked "Resolved" and may still be re-opened. Once a fix
-is released, the issue is permanently "Closed". If necessary, you will need to create a new,
-related ticket with a fresh description.
-
-#### Submit a Pull Request
-
-You can contribute a source code change by submitting a pull request.
-
-1. If you have not previously done so, please sign the
-[Contributor License Agreement](https://cla.pivotal.io/sign/spring). You will also be reminded
-automatically when you submit a pull request.
-
-1. For all but the most trivial of contributions, please [create a ticket](#create-a-ticket).
-The purpose of the ticket is to understand and discuss the underlying issue or feature.
-We use the JIRA issue tracker as the preferred place of record for conversations and
-conclusions. In that sense discussions directly under a PR are more implementation detail
-oriented and transient in nature.
-
-1. Always check out the `master` branch and submit pull requests against it
-(for target version see [settings.gradle](settings.gradle)).
-Backports to prior versions will be considered on a case-by-case basis and reflected as
-the fix version in the issue tracker.
-
-1. Use short branch names, preferably based on the JIRA issue (e.g. `SPR-1234`), or
-otherwise using succinct, lower-case, dash (-) delimited names, such as `fix-warnings'.
-
-1. Choose the granularity of your commits consciously and squash commits that represent
-multiple edits or corrections of the same logical change. See
-[Rewriting History section of Pro Git](https://git-scm.com/book/en/Git-Tools-Rewriting-History)
-for an overview of streamlining commit history.
-
-1. Format commit messages using 55 characters for the subject line, 72 lines for the
-description, followed by related issues, e.g. `Issues: SPR-1234, SPR-1235`.
-See the
-[Commit Guidelines section of Pro Git](https://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines)
-for best practices around commit messages and use `git log` to see some examples.
-
-1. List the JIRA issue number in the PR description.
-
-If accepted, your contribution may be heavily modified as needed prior to merging.
-You will likely retain author attribution for your Git commits granted that the bulk of
-your changes remain intact. You may also be asked to rework the submission.
-
-If asked to make corrections, simply push the changes against the same branch, and your
-pull request will be updated. In other words, you do not need to create a new pull request
-when asked to make changes.
-
-### Build from Source
-
-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source)
-wiki page for instructions on how to check out, build, and import the Spring Framework
-source code into your IDE.
-
-### Source Code Style
-
-The wiki pages
-[Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and
-[IntelliJ IDEA Editor Settings](https://github.com/spring-projects/spring-framework/wiki/IntelliJ-IDEA-Editor-Settings)
-defines the source file coding standards we use along with some IDEA editor settings we customize.
-
-### Reference Docs
-
-The reference documentation is in the [src/docs/asciidoc](src/docs/asciidoc) directory and, in
-[Asciidoctor](https://asciidoctor.org/) format. For trivial changes, you may be able to browse,
-edit source files, and submit directly from Github.
-
-When making changes locally, use `./gradlew asciidoctor` and then browse the result under
-`build/asciidoc/html5/index.html`.
-
-Asciidoctor also supports live editing. For more details read
-[Editing AsciiDoc with Live Preview](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/).
-Note that if you choose the
-[System Monitor](https://asciidoctor.org/docs/editing-asciidoc-with-live-preview/#using-a-system-monitor)
-option, you can find a Guardfile under `src/docs/asciidoc`.
@@ -1,48 +1,59 @@
-# <img src="src/docs/asciidoc/images/spring-framework.png" width="80" height="80"> Spring Framework
+## Spring Framework
+The Spring Framework provides a comprehensive programming and configuration model for modern
+Java-based enterprise applications - on any kind of deployment platform. A key element of Spring is
+infrastructural support at the application level: Spring focuses on the "plumbing" of enterprise
+applications so that teams can focus on application-level business logic, without unnecessary ties
+to specific deployment environments.

-This is the home of the Spring Framework, the foundation for all
-[Spring projects](https://spring.io/projects). Together the Spring Framework and the family of Spring projects make up what we call "Spring". 
+The framework also serves as the foundation for
+[Spring Integration](https://github.com/SpringSource/spring-integration),
+[Spring Batch](https://github.com/SpringSource/spring-batch) and the rest of the Spring
+[family of projects](http://springsource.org/projects). Browse the repositories under the
+[SpringSource organization](https://github.com/SpringSource) on GitHub for a full list.

-Spring provides everything you need beyond the Java language to create enterprise
-applications in a wide range of scenarios and architectures. Please read the
-[Overview](https://docs.spring.io/spring/docs/current/spring-framework-reference/overview.html#spring-introduction)
-section in the reference for a more complete introduction.
+[.NET](https://github.com/SpringSource/spring-net) and
+[Python](https://github.com/SpringSource/spring-python) variants are available as well.

-## Code of Conduct
-
-This project is governed by the [Spring Code of Conduct](CODE_OF_CONDUCT.adoc).
-By participating you are expected to uphold this code.
-Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
-
-## Access to Binaries
-
-For access to artifacts or a distribution zip, see the
-[Spring Framework Artifacts](https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Artifacts)
-wiki page.
+## Downloading artifacts
+Instructions on
+[downloading Spring artifacts](https://github.com/SpringSource/spring-framework/wiki/Downloading-Spring-artifacts)
+via Maven and other build systems are available via the project wiki.

 ## Documentation
+See the current [Javadoc](http://static.springsource.org/spring-framework/docs/current/api)
+and [Reference docs](http://static.springsource.org/spring-framework/docs/current/reference).

-The Spring Frameworks maintains reference documentation
-([published](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/) and
-[source](src/docs/asciidoc)),
-Github [wiki pages](https://github.com/spring-projects/spring-framework/wiki), and an
-[API reference](https://docs.spring.io/spring-framework/docs/current/javadoc-api/).
-There are also [guides and tutorials](https://spring.io/guides) across Spring projects.
+## Getting support
+Check out the [Spring forums](http://forum.springsource.org) and the
+[Spring tag](http://stackoverflow.com/questions/tagged/spring) on StackOverflow.
+[Commercial support](http://springsource.com/support/springsupport) is available too.

-## Build from Source
+## Issue Tracking
+Spring's JIRA issue tracker can be found [here](http://jira.springsource.org/browse/SPR). Think
+you've found a bug? Please consider submitting a reproduction project via the
+[spring-framework-issues](https://github.com/springsource/spring-framework-issues) repository. The
+[readme](https://github.com/springsource/spring-framework-issues#readme) provides simple
+step-by-step instructions.

-See the [Build from Source](https://github.com/spring-projects/spring-framework/wiki/Build-from-Source)
-wiki page and also [CONTRIBUTING.md](CONTRIBUTING.md).
+## Building from source
+Instructions on
+[building Spring from source](https://github.com/SpringSource/spring-framework/wiki/Building-from-source)
+are available via the project wiki.

-## Stay in Touch
+## Contributing
+[Pull requests](http://help.github.com/send-pull-requests) are welcome; you'll be asked to sign our
+contributor license agreement ([CLA](https://support.springsource.com/spring_committer_signup)).
+Trivial changes like typo fixes are especially appreciated (just
+[fork and edit!](https://github.com/blog/844-forking-with-the-edit-button)). For larger changes,
+please search through JIRA for similiar issues, creating a new one if necessary, and discuss your
+ideas with the Spring team.

-Follow [@SpringCentral](https://twitter.com/springcentral),
-[@SpringFramework](https://twitter.com/springframework), and its
-[team members](https://twitter.com/springframework/lists/team/members) on Twitter.
-In-depth articles can be found at [The Spring Blog](https://spring.io/blog/),
-and releases are announced via our [news feed](https://spring.io/blog/category/news).
+## Staying in touch
+Follow [@springframework](http://twitter.com/springframework) and its
+[team members](http://twitter.com/springframework/team/members) on Twitter. In-depth articles can be
+found at the SpringSource [team blog](http://blog.springsource.org), and releases are announced via
+our [news feed](http://www.springsource.org/news-events).

 ## License
-
 The Spring Framework is released under version 2.0 of the
-[Apache License](https://www.apache.org/licenses/LICENSE-2.0).
+[Apache License](http://www.apache.org/licenses/LICENSE-2.0).
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module relativePaths="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
+
@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="build-spring-framework" default="precommit">
+
+	<path id="unit.test.bundles">
+		<pathelement location="../org.springframework.instrument"/>
+		<pathelement location="../org.springframework.instrument.tomcat"/>
+		<pathelement location="../org.springframework.core"/>
+		<pathelement location="../org.springframework.expression"/>
+		<pathelement location="../org.springframework.beans"/>
+		<pathelement location="../org.springframework.aop"/>
+		<pathelement location="../org.springframework.context"/>
+		<pathelement location="../org.springframework.transaction"/>
+		<pathelement location="../org.springframework.oxm"/>
+		<pathelement location="../org.springframework.jms"/>
+		<pathelement location="../org.springframework.jdbc"/>
+		<pathelement location="../org.springframework.web"/>
+		<pathelement location="../org.springframework.orm"/>
+		<pathelement location="../org.springframework.context.support"/>
+		<pathelement location="../org.springframework.aspects"/>
+		<pathelement location="../org.springframework.web.servlet"/>
+		<pathelement location="../org.springframework.web.portlet"/>
+		<pathelement location="../org.springframework.test"/>
+		<pathelement location="../org.springframework.web.struts"/>
+	</path>
+
+	<path id="bundles">
+		<pathelement location="../org.springframework.spring-parent"/>
+		<pathelement location="../org.springframework.asm"/>
+		<path refid="unit.test.bundles" />
+		<pathelement location="../org.springframework.integration-tests"/>
+		<pathelement location="../org.springframework.spring-library"/>
+	</path>
+
+	<property file="${basedir}/../build.properties"/>
+	<import file="${basedir}/package-top-level.xml"/>
+	<import file="${basedir}/publish-top-level.xml"/>
+	<import file="${basedir}/publish-documentation.xml"/>
+	<import file="${basedir}/../spring-build/multi-bundle/default.xml"/>
+
+	<target name="precommit" depends="clean, clean-integration, test"/>
+
+	<presetdef name="javadoc.links">
+		<javadoc>
+			<link href="http://download.oracle.com/javase/6/docs/api"/>
+			<link href="http://download.oracle.com/javaee/6/api"/>
+			<link href="http://aopalliance.sourceforge.net/doc"/>
+			<!-- Caucho Burlap/Hessian -->
+			<link href="http://cglib.sourceforge.net/apidocs"/>
+			<!-- EasyMock -->
+			<link href="http://ehcache.sourceforge.net/apidocs"/>
+			<link href="http://freemarker.sourceforge.net/docs/api/"/>
+			<link href="http://docs.jboss.org/hibernate/core/3.6/javadocs/"/>
+			<!-- iBATIS -->
+			<!-- iText -->
+			<!-- Commons Attributes -->
+			<link href="http://jakarta.apache.org/commons/collections/apidocs-COLLECTIONS_3_0/"/>
+			<link href="http://jakarta.apache.org/commons/dbcp/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/fileupload/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/httpclient/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/logging/apidocs/"/>
+			<link href="http://jakarta.apache.org/commons/pool/apidocs/"/>
+			<!-- JasperReports -->
+			<!-- JDO -->
+			<!-- JMX -->
+			<!-- JOTM -->
+			<!-- JPA -->
+			<!-- JSF -->
+			<link href="http://junit.sourceforge.net/javadoc_40/"/>
+			<link href="http://logging.apache.org/log4j/docs/api/"/>
+			<link href="http://jakarta.apache.org/regexp/apidocs/"/>
+			<link href="http://jakarta.apache.org/poi/apidocs/"/>
+			<link href="http://portals.apache.org/pluto/portlet-1.0-apidocs/"/>
+			<link href="http://www.quartz-scheduler.org/api/2.1.0/"/>
+			<link href="http://struts.apache.org/struts-doc-1.2.9/api/"/>
+			<link href="http://java.sun.com/javase/6/docs/jre/api/net/httpserver/spec/"/>
+			<link href="http://tiles.apache.org/framework/apidocs/"/>
+			<link href="http://velocity.apache.org/engine/devel/apidocs/"/>
+		</javadoc>
+	</presetdef>
+
+</project>
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="package-bundle">
+
+	<target name="package" depends="ivy.init">
+		<dist-jar/>
+		<src-jar/>
+	</target>
+
+</project>
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="package-library">
+
+	<target name="package" depends="ivy.init">
+		<dist-jar/>
+	</target>
+
+</project>
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="package-top-level">
+
+	<target name="package" description="Creates the release package for this project">
+		<delete dir="${package.output.dir}" quiet="true"/>
+		<mkdir dir="${package.output.dir}"/>
+		<delete file="${package.output.file}" quiet="true"/>
+		<mkdir dir="${artifacts.dir}"/>
+
+		<all-bundles target="package">
+			<property name="package.output.dir" value="${package.output.dir}"/>
+		</all-bundles>
+
+		<ant target="javadoc-api" inheritAll="false">
+			<property name="target.dir" value="${package.docs.dir}"/>
+		</ant>
+
+		<!-- Reference Document START-->
+		<path id="doc.projects">
+			<path location="${basedir}/../spring-framework-reference"/>
+		</path>
+
+		<all-bundles target="doc" buildpathRef="doc.projects"/>
+
+		<delete>
+		  <fileset dir="${basedir}/../spring-framework-reference" includes="**/*.zip"/>
+		</delete>
+
+		<all-bundles target="package" buildpathRef="doc.projects">
+			<property name="package.output.dir" value="${package.output.dir}"/>
+		</all-bundles>
+
+		<!-- Reference Document END-->
+
+		<copy todir="${package.output.dir}">
+			<fileset dir="${basedir}/resources"/>
+		</copy>
+
+		<copy todir="${package.output.dir}/projects">
+			<fileset dir="${basedir}/..">
+				<exclude name="*/target/**"/>
+				<exclude name="integration-repo/**"/>
+				<exclude name="ivy-cache/**"/>
+				<exclude name="spring-build/lib/docbook/**" />
+				<exclude name="**/*OLD*/**"/>
+			</fileset>
+		</copy>
+
+		<replaceregexp match="build.stamp.*\n" replace="" flags="g"
+				file="${package.output.dir}/projects/build.properties"/>
+
+		<replaceregexp match="release.type=.*" replace="release.type=integration" flags="g"
+				file="${package.output.dir}/projects/build.properties"/>
+
+		<zip destfile="${package.output.file}">
+			<zipfileset dir="${package.dir}">
+				<exclude name="${package.basename}/docs/**"/>
+			</zipfileset>
+		</zip>
+		
+		<zip destfile="${artifacts.dir}/${package.basename}-with-docs.zip">
+			<zipfileset dir="${package.dir}"/>
+		</zip>
+
+		<zip destfile="${artifacts.dir}/${package.basename}-dependencies.zip">
+			<zipfileset dir="${basedir}/../ivy-cache/repository">
+				<exclude name="org.apache.velocity/org.apache.velocity.docbookframework.dist/**"/>
+			</zipfileset>
+		</zip>
+		
+	</target>
+
+</project>
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="publish-documentation">
+
+<!-- Main targets -->
+	<target name="publish-documentation" depends="publish-documentation.init">
+		<sshexec host="static.springsource.org" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
+				command="rm -rf /opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"/>
+		<sshexec host="static.springsource.org" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
+				command="mkdir /opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"/>
+
+		<scp remoteToDir="${username}@static.springsource.org:/opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version}"
+				keyfile="${key.file}" passphrase="${passphrase}" sftp="true" verbose="true">
+			<fileset dir="${package.output.dir}">
+				<include name="changelog.txt" />
+				<include name="license.txt" />
+				<include name="readme.txt" />
+			</fileset>
+			<fileset dir="${package.docs.dir}" />
+		</scp>
+
+		<sshexec host="static.springsource.org" username="${username}" keyfile="${key.file}" passphrase="${passphrase}"
+				command="rm -f /opt/www/domains/springframework.org/www/htdocs/spring/docs/3.1.x ; ln -s /opt/www/domains/springframework.org/www/htdocs/spring/docs/${bundle.version} /opt/www/domains/springframework.org/www/htdocs/spring/docs/3.1.x"/>
+	</target>
+
+<!-- Other targets -->
+	<target name="publish-documentation.init">
+		<fail message="The 'username' property must be set">
+			<condition>
+				<not>
+					<isset property="username"/>
+				</not>
+			</condition>
+		</fail>
+		<fail message="The 'key.file' property must be set">
+			<condition>
+				<not>
+					<isset property="key.file"/>
+				</not>
+			</condition>
+		</fail>
+		<fail message="The 'passphrase' property must be set">
+			<condition>
+				<not>
+					<isset property="passphrase"/>
+				</not>
+			</condition>
+		</fail>
+	</target>
+
+</project>
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="publish-top-level" xmlns:aws="antlib:org.springframework.build.aws">
+
+	<target name="publish" depends="publish-package, publish-multi-bundle.publish"
+			description="Publish package, Ivy, and Maven artifacts"/>
+
+	<target name="publish-package" depends="aws.init">
+		<checksum file="${package.output.file}" algorithm="sha1"/>
+		<checksum file="${artifacts.dir}/${package.basename}-with-docs.zip" algorithm="sha1"/>
+		<checksum file="${artifacts.dir}/${package.basename}-dependencies.zip" algorithm="sha1"/>
+		
+		<aws:s3 accessKey="${accessKey}" secretKey="${secretKey}">
+			<upload bucketName="dist.${bucket.basename}" file="${package.output.file}"
+					toFile="${adjusted.release.type}/${project.key}/${package.file.name}" publicRead="true">
+				<metadata name="project.name" value="Spring Framework"/>
+				<metadata name="release.type" value="${release.type}"/>
+				<metadata name="bundle.version" value="${bundle.version}"/>
+				<metadata name="package.file.name" value="${package.file.name}"/>
+			</upload>
+			<upload bucketName="dist.${bucket.basename}" file="${package.output.file}.sha1"
+					toFile="${adjusted.release.type}/${project.key}/${package.file.name}.sha1" publicRead="true"/>
+
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-with-docs.zip"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-with-docs.zip" publicRead="true">
+				<metadata name="project.name" value="Spring Framework"/>
+				<metadata name="release.type" value="${release.type}"/>
+				<metadata name="bundle.version" value="${bundle.version}"/>
+				<metadata name="package.file.name" value="${package.basename}-with-docs.zip"/>
+			</upload>
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-with-docs.zip.sha1"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-with-docs.zip.sha1" publicRead="true"/>
+
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-dependencies.zip"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-dependencies.zip" publicRead="true">
+				<metadata name="project.name" value="Spring Framework"/>
+				<metadata name="release.type" value="${release.type}"/>
+				<metadata name="bundle.version" value="${bundle.version}"/>
+				<metadata name="package.file.name" value="${package.basename}-dependencies.zip"/>
+			</upload>
+			<upload bucketName="dist.${bucket.basename}" file="${artifacts.dir}/${package.basename}-dependencies.zip.sha1"
+					toFile="${adjusted.release.type}/${project.key}/${package.basename}-dependencies.zip.sha1" publicRead="true"/>
+		</aws:s3>
+	</target>
+</project>
@@ -0,0 +1,42 @@
+This is where the master build that creates releases of Spring Framework resides.
+The build system is based on spring-build, which is linked in using an SVN
+external to https://src.springframework.org/svn/spring-build.
+
+Build Pre-requisites:
+- javac 1.6 or > must be in your system path
+- ant 1.7 or > must be in your system path
+- set ANT_OPTS as follows (to avoid out of memory errors):
+    ANT_OPTS="-XX:MaxPermSize=1024m -Xmx1024m -Dtest.vm.args='-XX:MaxPermSize=512m -Xmx1024m'"
+
+USERS
+- To build all Spring Framework projects, including samples:
+
+    1. From this directory, run:
+       ant
+
+- To install the built artifacts into your local Maven cache:
+
+    1. From this directory, run:
+       ant install-maven
+
+- For a complete tutorial, see:
+
+       http://blog.springsource.com/2009/03/03/building-spring-3
+
+
+DEVELOPERS
+- To build a new Spring Framework distribution for release:
+
+  1. Update the files containing the version number to reflect the new release
+     version, if necessary.
+
+         build.properties
+         build-spring-framework/resources/readme.txt
+         spring-framework/src/spring-framework-reference.xml
+
+  2. From this directory, run:
+
+         ant jar package
+
+     The release archive will be created and placed in:
+         target/artifacts
@@ -0,0 +1,970 @@
+SPRING FRAMEWORK CHANGELOG
+==========================
+http://www.springsource.org
+
+
+Changes in version 3.1.4 (2013-01-23)
+-------------------------------------
+
+* overhauled non-void JavaBean write method support (SPR-10029)
+* SpEL support for static finals on interfaces (SPR-10125)
+* BridgeMethodResolver properly handles bridge methods in interfaces (SPR-9330)
+* LocalVariableTableParameterNameDiscoverer works for bridge methods as well (SPR-9429)
+* CachedIntrospectionResults uses full WeakReference for any non-safe ClassLoader arrangement (SPR-10028)
+* CachedIntrospectionResults.clearClassLoader(null) removes cached classes for the system class loader (SPR-9189)
+* DefaultListableBeanFactory avoids wide/interleaved metadata locks to avoid deadlock potential (SPR-10020)
+* fixed CGLIB proxy class leaks through further equals/hashCode implementations in Spring AOP pointcuts (SPR-8008)
+* ConfigurationClassPostProcessor consistently uses ClassLoader, not loading core JDK classes via ASM (SPR-10058)
+* MessageSourceResourceBundle overrides JDK 1.6 containsKey method, avoiding NPE in getKeys (SPR-10136)
+* SpringBeanAutowiringInterceptor eagerly releases BeanFactory if post-construction fails (SPR-10013)
+* added "exposeAccessContext" flag JndiRmiClientInterceptor/ProxyFactoryBean (for WebLogic; SPR-9428)
+* MBeanExporter does not log warnings for manually unregistered MBeans (SPR-9451)
+* AbstractCacheManager accepts no caches defined, allowing for EHCache default cache setup (SPR-7955)
+* reintroduced "mode" and "proxy-target-class" attributes in spring-task-3.1.xsd (SPR-10177)
+* improved defensiveness of JDBC 3.0 ParameterMetaData calls for parameter type determination (SPR-10084)
+* JpaTransactionManager etc finds default EntityManagerFactory in parent context as well (SPR-10160)
+* tx timeouts for JPA translate to "javax.persistence.query.timeout" only (for EclipseLink compatibility; SPR-10068)
+* DefaultMessageListenerContainer allows for concurrent subscription consumers on WebLogic/ActiveMQ (SPR-10037)
+* DefaultMessageListenerContainer clears resources of paused tasks when shutting down after stop (SPR-10092)
+* JmsTemplate uses configured receiveTimeout if shorter than remaining transaction timeout (SPR-10109)
+* added MappingJackson2MessageConverter for JMS (SPR-10099)
+* ResourceDatabasePopulator explicitly closes its LineNumberReader (SPR-9912)
+* MimeMessageHelper encodes attachment filename if not ASCII compliant (SPR-9258)
+* FreeMarkerConfigurationFactory properly supports TemplateLoaders when recreating Configurations (SPR-9389)
+* SpringContextResourceAdapter implements equals/hashCode according to the JCA 1.5 contract (SPR-9162)
+* ContextLoader properly detects pre-refreshed WebApplicationContext (SPR-9996)
+* AbstractCachingViewResolver uses a cache limit of 1024 by default, avoiding overflow for redirect URLs (SPR-10065)
+* fixed HierarchicalUriComponents equals implementation (SPR-10088)
+* MockHttpServletRequest's getParameter(Values) returns null for null parameter name (SPR-10192)
+* MockHttpServletResponse's getHeaderNames declares Collection instead of Set for Servlet 3.0 compatibility (SPR-9885)
+* ResourcePropertySource supports JDK 5-style Properties XML (SPR-9896)
+
+
+Changes in version 3.1.3 (2012-10-31)
+-------------------------------------
+
+* fixed cache handling for JNLP connections
+* LinkedCaseInsensitiveMap checks for uniqueness of case-insensitive keys now
+* ResourceBundleMessageSource supports "defaultEncoding", "fallbackToSystemLocale", "cacheSeconds"
+* BeanWrapper does not fall back to String constructor if ConversionService attempt failed before
+* @Import'ed configuration classes get properly registered in case of same class name
+* @Autowired-driven ObjectFactory/Provider resolution works in non-singleton beans as well
+* @Resource processing properly works with scoped beans and prototypes again
+* allow replaced-method 'arg-type' matches against element body as well as 'match' attribute
+* fixed potential race condition in concurrent calling of autowired methods on a prototype bean
+* cancel on a Future returned by a TaskScheduler works reliably
+* LoadTimeWeaverAware beans are consistently being created early for JPA weaving to work reliably
+* Spring-backed DataSources consistently implement JDBC 4.0's Wrapper interface
+* optimized ResourceDatabasePopulator to work around JDK 1.7 substring performance regression
+* deprecated SimpleJdbcTestUtils in favor of JdbcTestUtils
+* introduced "countRowsInTableWhere()" and "dropTables()" in JdbcTestUtils
+* same-named unit from persistence.xml overrides in case of conflict with default unit
+* JPA persistence.xml files may use jar-file entries relative to the unit root (as per the JPA spec)
+* added "jtaDataSource" property to JPA LocalContainerEntityManagerFactoryBean (for default units)
+* Hibernate 4 LocalSessionFactoryBuilder sets thread context ClassLoader (for JBoss 7 compatibility)
+* Jaxb2Marshaller performs proper "supports" check for scanned packages
+* media types in HTTP Accept headers can be parsed with single quotes (-> Android 2.x)
+* MediaType's include method now recognizes wildcards in media types with a suffix
+* added support for recognizing wildcards in media types with a suffix
+* UriComponentsBuilder is capable of handling opaque URIs as well
+* CookieGenerator supports "cookieHttpOnly" flag for Servlet 3.0
+* HttpComponentsHttpInvokerRequestExecutor explicitly releases connection on HttpComponents 4.2
+* improved no-match handling for @RequestMapping methods
+* dynamic return value types for @MVC methods
+* fixed issue with resolution of WebDataBinder argument
+* fixed issue with resolving Errors controller argument
+* now decoding target parameters prior to saving a FlashMap
+* prevent response updates if @ResponseStatus has a reason
+* improved regex for parsing query params
+* optimized use of AntPathStringMatcher
+* optimized use of HandlerMethod and subclasses
+* fixed issue in message conversion where producible and acceptable headers are equally specific
+* fixed NullPointerException in AbstractMessageConverterMethodProcessor
+* fixed side effect from caching in AnnotationMethodHandlerExceptionResolver
+* DispatcherPortlet uses a forward for rendering a view as resource response
+* fixed Portlet request mapping priorities in cross-controller case
+
+
+Changes in version 3.1.2 (2012-07-09)
+-------------------------------------
+
+* removed INDEX.LIST entries from Spring jar META-INF dirs
+* fixed OSGi metadata for optional "javax.inject" package import
+* fixed AbstractResource's InputStream-based "contentLength()" implementation
+* fixed MutablePropertySources "get" implementation to correctly return null if not found
+* fixed @PropertySource placeholder resolution to apply to all specified values
+* JDBC parameter binding uses JDBC 3.0 ParameterMetaData (if available) for type determination
+* added "jtaTransactionManager" property to Hibernate 4 LocalSessionFactoryBean/Builder
+* EhCacheFactoryBean applies listeners and enabled/disabled flags to existing cache regions as well
+* added "repeatCount" bean property to Quartz SimpleTriggerFactoryBean
+* support executor qualification with @Async#value
+* ServletContextResource's getFile implementation falls back to getRealPath for non-existent files
+* fixed StandardServletMultipartResolver compatibility with Resin (only deleting actual file parts)
+* fixed RequestConditionHolder to return null when no match is found
+* fixed concurrency issue in AnnotationMethodHandlerExceptionResolver
+* fixed issue with parsing invalid Content-Type or Accept headers
+* added "defaultCharset" property to StringHttpMessageConverter
+* added Jackson 2 HttpMessageConverter and View types
+* translate IOException on EOF from Jackson to HttpMessageNotReadableException
+* fix content negotiation issue when sorting selected media types by quality value
+* raise RestClientException instead of IllegalArgumentException for unknown status codes
+* discover controllers based on type-level @RequestMapping in new @MVC support classes
+* fixed issue with suffix pattern in AnnotationMethodHandlerAdapter
+* merge rather than add URI vars in ExtendedServletRequestDataBinder
+* raise RestClientException for unknown HTTP status codes
+* fixed issue with encoded params in UriComponentsBuilder
+* XStreamMarshaller converts StreamException to Spring exception in case of unmarshalling an empty stream
+* corrected DispatcherPortlet behavior to not forward event exceptions to the render phase by default
+
+
+Changes in version 3.1.1 (2012-02-16)
+-------------------------------------
+
+* official support for Hibernate 4.0.0/4.0.1 as well as Hibernate 4.1
+* JBossNativeJdbcExtractor is compatible with JBoss AS 7 as well
+* restored JBossLoadTimeWeaver compatibility with JBoss AS 5.1
+* Provider injection works with generically typed collections of beans as well
+* @ActiveProfiles mechanism in test context framework works with @ImportResource as well
+* context:property-placeholder's "file-encoding" attribute value is being applied correctly
+* clarified Resource's "getFilename" method to return null if resource type does not have a filename
+* Resource "contentLength()" implementations work with OSGi bundle resources and JBoss VFS resources
+* PathMatchingResourcePatternResolver preserves caching for JNLP (Java Web Start) jar connections
+* optimized converter lookup in GenericConversionService to avoid contention in JDK proxy check
+* DataBinder correctly handles ParseException from Formatter for String->String case
+* CacheNamespaceHandler actually parses cache:annotation-driven's "key-generator" attribute
+* introduced CustomSQLExceptionTranslatorRegistry/Registrar for JDBC error code translation
+* officially deprecated TopLinkJpaDialect in favor of EclipseLink and Spring's EclipseLinkJpaDialect
+* fixed LocalContainerEntityManagerFactoryBean's "packagesToScan" to avoid additional provider scan
+* LocalContainerEntityManagerFactoryBean's "persistenceUnitName" applies to "packagesToScan" as well
+* DefaultPersistenceUnitManager uses containing jar as persistence unit root URL for default unit
+* added protected "isPersistenceUnitOverrideAllowed()" method to DefaultPersistenceUnitManager
+* Hibernate synchronization properly unbinds Session even in case of afterCompletion exception
+* Hibernate exception translation covers NonUniqueObjectException to DuplicateKeyException case
+* Hibernate 4 LocalSessionFactoryBean implements PersistenceExceptionTranslator interface as well
+* Hibernate 4 LocalSessionFactoryBean does not insist on a "dataSource" reference being set
+* added "entityInterceptor" property to Hibernate 4 LocalSessionFactoryBean
+* added "getConfiguration" accessor to Hibernate 4 LocalSessionFactoryBean
+* added "durability" and "description" properties to JobDetailFactoryBean
+* fixed QuartzJobBean and MethodInvokingJobDetailFactoryBean for compatibility with Quartz 2.0/2.1
+* JMS CachingConnectionFactory never caches consumers for temporary queues and topics
+* JMS SimpleMessageListenerContainer silently falls back to lazy registration of consumers
+* added "receive-timeout" attribute to jms:listener-container element in JMS namespace
+* ServletServerHttpRequest/Response fall back on the Content-Type and encoding of the request
+* preserve quotes in MediaType parameters
+* added "normalize()" method to UriComponents
+* remove empty path segments from input to UriComponentsBuilder
+* added "fromRequestUri(request)" and "fromCurrentRequestUri()" methods to ServletUriComponentsBuilder
+* Servlet/PortletContextResource's "isReadable()" implementation returns false for directories
+* allow adding flash attributes in methods with a ModelAndView return value
+* make flash attributes available in the model of Parameterizable/UrlFilenameViewController
+* revised the FlashMapManager contract and implementation to address a flaw in its design
+* removed check for HTTP POST when resolving multipart request controller method arguments
+* fixed request mapping bug involving direct vs pattern path matches with HTTP methods
+* updated @RequestMapping and reference docs wrt differences between @MVC 3.1 and @MVC 2.5-3.0
+* improved @SessionAttributes handling to provide better support for clustered sessions
+* added property to RedirectView to disable expanding URI variables in redirect URL
+
+
+Changes in version 3.1 GA (2011-12-12)
+--------------------------------------
+
+* SmartLifecycle beans in Lifecycle dependency graphs are only being started when isAutoStartup=true
+* ConversionService is able to work with "Collections.emptyList()" as target type (again)
+* restored DataBinder's ability to bind to an auto-growing List with unknown element type
+* added SmartValidator interface with general support for validation hints
+* added custom @Validated annotation with support for JSR-303 validation groups
+* JSR-303 SpringValidatorAdapter and MVC data binding provide support for validation groups
+* restored SpringValidatorAdapter's ability to handle bean constraints with property paths
+* added MethodValidationInterceptor/PostProcessor for Hibernate Validator 4.2 based method validation
+* fixed QuartzJobBean to work with Quartz 2.0/2.1 as well
+* @Transactional qualifiers match against transaction manager definitions in parent contexts as well
+* optimized AnnotationTransactionAspect and AnnotationCacheAspect pointcuts to avoid runtime checks
+* renamed @CacheEvict's "afterInvocation" attribute to "beforeInvocation" (for better readability)
+* added "mappingResources" property to LocalContainerEntityManagerFactoryBean (pointing to orm.xml)
+* Hibernate 4.0 variant of HibernateTransactionManager properly works with Open Session in View now
+* JmsInvokerClientInterceptor/FactoryBean always uses createConnection/createSession when on JMS 1.1
+* added out-of-the-box MappingJacksonMessageConverter impl for Spring's JMS MessageConverter facility
+* DispatcherServlet's "dispatchOptionsRequest" only sets the default 'Allow' header if actually needed
+* ResourceHttpRequestHandler sends content without content-type header if no media type found
+* ResourceHttpRequestHandler and ContentNegotiatingViewResolver use consistent mime type resolution
+* simplified support package layout in "web.method" and "web.servlet.mvc.method"
+* added "useTrailingSlashMatch" property to RequestMappingHandlerMapping
+* Portlet MVC annotation mapping allows for distributing action names across controllers
+* added String constants to MediaType
+
+ 
+Changes in version 3.1 RC2 (2011-11-28)
+---------------------------------------
+
+* fixed OSGi manifest for spring-web bundle to not require Apache HttpComponents anymore
+* fixed GenericTypeResolver to consistently return null if not resolvable
+* added proper "contentLength()" implementation to ByteArrayResource
+* refined Resource "exists()" check for HTTP URLs to always return false for 404 status
+* LocaleEditor and StringToLocaleConverter do not restrict variant part through validation
+* LinkedCaseInsensitiveMap overrides putAll method as well (for IBM JDK 1.6 compatibility)
+* optimized DefaultListableBeanFactory's PropertyDescriptor caching for concurrent access
+* renamed ValueWrapperImpl to SimpleValueWrapper (for use in Cache implementations)
+* exposed EHCache 1.7's "statisticsEnabled"/"sampledStatisticsEnabled" on EhCacheFactoryBean
+* SpringValidatorAdapter accepts non-indexed set paths (for Hibernate Validator compatibility)
+* TransactionSynchronizationManager eagerly cleans up void ResourceHolders on any access
+* SimpleJdbcTestUtils executeSqlScript properly closes its LineNumberReader after use
+* JDO PersistenceManager synchronization performs close attempt after completion (if necessary)
+* JPA EntityManagerFactoryUtils silently ignores IllegalArgumentExceptions from setHint calls
+* fixed HibernateTransactionManager for Hibernate 4.0 to refer to correct openSession() method
+* added "namingStrategy" property to Hibernate 4 LocalSessionFactoryBean variant
+* HibernateJpaDialect does NOT expose underlying Session for underlying SessionFactory anymore
+* fixed MethodInvokingJobDetailFactoryBean's Quartz 2.0 support
+* added Quartz 2.1 compatibility while preserving Quartz 2.0 support
+* introduced JobDetail/CronTrigger/SimpleTriggerFactoryBean variants for Quartz 2.0/2.1 support
+* added "forwarder" property to ConnectorServerFactoryBean, accepting an MBeanServerForwarder
+* RmiClientInterceptor detects nested SocketException as connect failure as well
+* fixed StandardServlet/PortletEnvironment to check for JNDI (for Google App Engine compatibility)
+* Servlet/PortletContextResource's getFile prefers "file:" URL resolution over calling getRealPath
+* Portlet session mutex uses global session attribute to be shared among all portlets in the session
+* using original request URI in FlashMap matching logic to account for URL rewriting
+* now supporting target request with multiple parameter values in FlashMap matching logic
+* fixed issue in SimpleMappingExceptionResolver causing exception when setting "statusCodes" property
+* added ignoreDefaultModelOnRedirect attribute to <mvc:annotation-driven/>
+* added methods to UriComponentsBuilder for replacing the path or the query
+* support UriComponentsBuilder as @Controller method argument
+* added ServletUriComponentsBuilder to build a UriComponents instance starting with a ServletRequest
+* fixed issue with cache ignoring prototype-scoped controllers in RequestMappingHandlerAdapter
+* fixed issue with setting Content-Length header depending on the charset of the response
+* fixed @RequestMapping header matching to correctly process negated header conditions
+* added getObjectMapper() accessor to MappingJacksonHttpMessageConverter
+* AbstractCachingViewResolver caches unresolved view names by default ("cacheUnresolved"=true)
+* form input tag now allows type values other than "text" such as HTML5-specific types
+* form hidden tag now supports "disabled" attribute
+* fixed "formMultiSelect"/"formCheckboxes" FreeMarker macros to compare against actual field value
+* MockHttpServletRequest/Response now keep contentType field and Content-Type header in sync
+* updated Spring MVC configuration section to include MVC Java config and the MVC namespace
+
+
+Changes in version 3.1 RC1 (2011-10-11)
+---------------------------------------
+
+* upgraded to JUnit 4.9
+* updated Quartz support package for Quartz 2.0 compatibility
+* support for load-time weaving on WebSphere 7 and 8
+* updated JBossLoadTimeWeaver to automatically detect and support JBoss AS 7 as well
+* added support for Hibernate 4.0 (HibernateJpaDialect as well as natively in orm.hibernate4)
+* added 'destroy method inference' (SPR-8751)
+* prepared Spring's DataSource and RowSet adapters for forward compatibility with JDBC 4.1
+* introduced ForkJoinPoolFactoryBean for Java 7 (alternative: add new jsr166.jar to Java 6)
+* introduced extended WritableResource interface
+* ConversionService prevents Converter from trying to convert to a subtype of its actual target type
+* CollectionCollection/MapToMapConverter preserve original Collection/Map if no converted elements
+* DefaultListableBeanFactory is only deserializable through a SerializedBeanFactoryReference
+* DefaultListableBeanFactory's getBean(name, type) attempts type conversion if necessary
+* DefaultListableBeanFactory allows for init methods to register further bean definitions (again)
+* XmlBeanDefinitionReader accepts description subelement within map entry as well (as per the XSD)
+* ConfigurationClassPostProcessor supports use of same processor instance with several factories
+* SpringBeanAutowiringSupport is able to process @Value annotations on any given target instance
+* introduced @EnableAspectJAutoProxy
+* overridden @PersistenceContext annotations on subclass methods are being processed correctly
+* DataBinder uses a default limit of 256 for array/collection auto-growing
+* added "autoGrowNestedPaths" property to ConfigurableWebBindingInitializer
+* added "getMultipartContentType(String)" method to MultipartRequest interface
+* added headers support to MultipartFile abstraction (actually supported on Servlet 3.0)
+* revised Servlet 3.0 based StandardServletMultipartResolver for correct param/file distinction
+* MultipartFilter uses a Servlet 3.0 based StandardServletMultipartResolver by default
+* added RequestPartServletServerHttpRequest and corresponding @RequestPart support in Spring MVC
+* added "connectTimeout" and "readTimeout" properties to Simple/CommonsClientHttpRequestFactory
+* added flash attribute support through FlashMap and FlashMapManager abstractions
+* added RedirectAttributes abstraction as supported method argument type of @RequestMapping methods
+* added "ignoreDefaultModelOnRedirect" flag to RequestMappingHandlerAdapter
+* fixed @ExceptionHandler exception type matching (ExceptionDepthComparator)
+* ResourceHttpRequestHandler detects invalid directory traversal in given path
+* HtmlUtils properly escapes single quotes as well
+* Spring JSP tags do not use their own expression support on Servlet 3.0 containers by default
+* added support for web.xml context-param "springJspExpressionSupport" (explicit "true"/"false")
+* ContextLoader and FrameworkServlet support "contextId" parameter for custom serialization id
+* added "acceptProxyClasses" flag to RemoteInvocationSerializingExporter
+* refined WebLogic RMI descriptor to only mark 'getTargetInterfaceName' method as idempotent
+* revised JMS CachedConnectionFactory to avoid unnecessary rollback calls on Session return
+* fixed JMS CachedConnectionFactory to fully synchronize its Session list
+* JpaTransactionManager etc can find EntityManagerFactory by "persistenceUnitName" property now
+* HibernateJpaDialect exposes underlying Session for underlying SessionFactory
+* deprecated JpaTemplate/JpaInterceptor/JpaDaoSupport and JdoTemplate/JdoInterceptor/JdoDaoSupport
+* updated H2 error codes in sql-error-codes.xml
+* fixed NamedParameterJdbcTemplate to use correct maximum type for queryForInt/Long
+* jdbc:script's "separator" and "execution" attributes work nested with embedded-database as well
+* added "encoding" attribute to jdbc:script element
+* JavaMailSenderImpl detects and respects "mail.transport.protocol" property in existing Session
+* added ConcurrentMapCacheManager, dynamically building ConcurrentMapCache instances at runtime
+* added "disabled" property to EhCacheFactoryBean
+* introduced generic invokeMethod() in ReflectionTestUtils
+* introduced DelegatingSmartContextLoader as new default ContextLoader for TestContext framework
+* deprecated @ExpectedException
+* AnnotationConfigContextLoader now detects default configuration classes within test classes
+* TestContext now uses MergedContextConfiguration for the ContextCache key
+* extended Servlet API mocks for Servlet 3.0 forward compatibility as far as possible
+* made MockHttpServletResponse compatible with Servlet 3.0 getHeader(s) method returning Strings
+* added getHeaderValue(s) method to MockHttpServletResponse for raw value access
+
+
+Changes in version 3.1 M2 (2011-06-08)
+--------------------------------------
+
+* revised TypeDescriptor signature and implementation for clearer handling of nested generics
+* full support for arbitrary nesting of collections in fields
+* proper type detection in nested collections within arrays
+* collection/array conversion returns original collection if possible (instead of first element)
+* AnnotatedBeanDefinitionReader now inherits Environment of supplied BeanDefinitionRegistry
+* eliminated @Feature support in favor of @Enable* and framework-provided @Configuration classes
+* introduced @EnableTransactionManagement, @EnableScheduling, etc
+* add Java config alternative to MVC namespace via @EnableWebMvc annotation
+* introduce HandlerMethod abstraction selecting and invoking @RequestMapping methods
+* add HandlerMethod-based implementations of HandlerMapping, HandlerAdapter, HandlerExceptionResolver
+* merge @PathVariables in the model before rendering except for JSON/XML serialization/marshalling.
+* use @PathVariables in addition to request parameters in data binding
+* support URI variable placeholders in "redirect:" prefixed view names
+* add flag to extract value from single-key model in MappingJacksonJsonView
+* support @Valid on @RequestBody method arguments
+* allow bean references in mvc:interceptor namespace elements
+* consolidate initialization and use of MappedInterceptors in AbstractHandlerMapping
+* added Servlet 3.0 based WebApplicationInitializer mechanism for programmatic bootstrapping
+* added Servlet 3.0 based StandardServletMultipartResolver
+* added "packagesToScan" feature to LocalContainerEntityManagerFactoryBean (avoiding persistence.xml)
+* fixed JPA 2.0 timeout hints to correctly specify milliseconds
+* added support for shutdown scripts to DataSourceInitializer (see "databaseCleaner" property)
+* added "separator" and "execution" attributes to jdbc:script element
+* revised cache abstraction to focus on minimal atomic access operations
+* updated Quartz package to support Quartz 1.8 as well (note: not fully supporting Quartz 2.0 yet)
+* RemoteExporter uses an opaque proxy for 'serviceInterface' (no AOP interfaces exposed)
+* introduced AnnotationConfigContextLoader to provide TestContext support for @Configuration classes
+* introduced @ActiveProfiles for declarative configuration of bean definition profiles in tests
+* TestContext generates context cache key based on all applicable configuration metadata
+* deprecated AbstractJUnit38SpringContextTests and AbstractTransactionalJUnit38SpringContextTests
+
+
+Changes in version 3.1 M1 (2011-02-11)
+--------------------------------------
+
+* upgraded to JUnit 4.8.1 and TestNG 5.12.1
+* fixed aspects bundle to declare dependencies for @Async aspect as well
+* introduced Environment abstraction with flexible placeholder resolution
+* introduced support for environment profiles in XML bean definition files
+* introduced @Profile annotation for configuration classes and individual component classes
+* introduced PropertySourcesPlaceholderConfigurer as alternative to PropertyPlaceholderConfigurer
+* introduced "c:" namespace for constructor argument shortcuts (analogous to the "p:" namespace)
+* introduced @FeatureConfiguration classes with @Feature methods that return FeatureSpecifications
+* added TxAnnotationDriven, MvcAnnotationDriven, etc. as out-of-the-box FeatureSpecifications
+* introduced caching abstraction and cache annotation support
+* moved EhCache FactoryBeans from context-support to context module
+* EhCacheManagerFactoryBean properly closes "ehcache.xml" input stream, if any
+* exceptions thrown by @Scheduled methods will be propagated to a registered ErrorHandler
+* ProxyCreationContext uses "ThreadLocal.remove()" over "ThreadLocal.set(null)" as well
+* BeanDefinitionVisitor now actually visits factory method names
+* fixed potential InjectionMetadata NPE when using SpringBeanAutowiringInterceptor
+* fixed AbstractBindingResult to avoid NPE in "hashCode()" if target is null
+* Servlet/PortletRequestDataBinder perform unwrapping for MultipartRequest as well
+* ResourceHttpRequestHandler does not set Content-Length header for 304 response
+* LocaleChangeInterceptor validates locale values in order to prevent XSS vulnerability
+
+
+Changes in version 3.0.5 (2010-10-20)
+-------------------------------------
+
+* support for Hibernate 3.6 final
+* added core serializer abstraction with default implementations using Java Serialization
+* consistent use of JDK 1.5's "ThreadLocal.remove()" over "ThreadLocal.set(null)"
+* fixed JodaTimeContextHolder to use a non-inheritable ThreadLocal and expose a reset method
+* revised "ClassUtils.isAssignable" semantics to cover primitives vs wrappers in both directions
+* optimized AnnotationUtils findAnnotation performance for repeated search on same interfaces
+* ConversionService protects itself against infinite recursion in ObjectToCollectionConverter
+* fixed TypeDescriptor to correctly resolve nested collections and their element types
+* BeanWrapper does not attempt to populate Map values on access (just auto-grows Map itself)
+* fixed Autowired/CommonAnnotationBeanPostProcessor to prevent race condition in skipping check
+* fixed @Value injection to correctly cache temporary null results for non-singleton beans
+* ApplicationContext registers context-specific ClassArrayEditor for its bean ClassLoader
+* refined ApplicationContext singleton processing to not fail for manually registered null instances
+* fixed ApplicationContext event processing for repeated invocations to non-singleton listener beans
+* optimized @Bean error messages for static factory methods as well as for argument type mismatches
+* modified expression parsing to pass full TypeDescriptor context through to ConversionService calls
+* adapted expression parser's Constructor/MethodResolver to accept TypeDescriptors instead of raw types
+* SpEL supports projection on any kind of Collection (not just on Lists and arrays)
+* SpEL MapAccessor consistently rejects "target.key" style access to Maps if no such key is found
+* SpEL method invocations prefer method with fewest parameters (e.g. no-arg over vararg)
+* AspectJExpressionPointcut uses bean ClassLoader for initializing the AspectJ pointcut parser
+* added AnnotationAsyncExecutionAspect as AspectJ-based variant of @Async processing
+* added mode="proxy"/"aspectj" and proxy-target-class options to task:annotation-driven
+* JDBC bundle uses local ClassLoader as bean ClassLoader for "sql-error-codes.xml" parsing
+* EmbeddedDatabaseFactory shuts down database when failing to populate it in "initDatabase()"
+* embedded database support now also works with Derby >= 10.6
+* "jdbc:embedded-database" uses id as database name to allow multiple ones in parallel
+* ResourceDatabasePopulator throws descriptive ScriptStatementFailedException with resource details
+* added configurable Connection/Statement/ResultSet target types to Jdbc4NativeJdbcExtractor
+* added OracleJdbc4NativeJdbcExtractor with pre-configured Oracle JDBC API types
+* DefaultLobHandler's "wrapAsLob" mode works with PostgreSQL's "getAsciiStream()" requirement
+* ResultSetWrappingSqlRowSet (as used by JdbcTemplate's "queryForRowSet") supports column labels now
+* LocalSessionFactoryBean's "entityCacheStrategies" works with region names on Hibernate 3.6 as well
+* fixed DefaultMessageListenerContainer's no-message-received commit to work without Session caching
+* DefaultMessageListenerContainer's skips no-message-received commit on Tibco (avoiding a deadlock)
+* JaxWsPortClientInterceptor does not fall back to annotation-specified name as portName anymore
+* UriTemplate is serializable now
+* fixed AnnotationMethodHandlerAdapter's caching to avoid concurrency issues in RequestMappingInfo
+* fixed @MVC processing of parameter-level annotations to work with interface-based proxies again
+* revised @RequestParam processing to support CSV-to-array/collection binding with ConversionService
+* fixed EvalTag's EvaluationContext caching to properly handle JSP tag caching across requests
+* AbstractJasperReportsView only sets locale model attributes if not present already
+* DispatcherPortlet throws custom NoHandlerFoundException instead of misleading UnavailableException
+* DispatcherPortlet copies all action parameters to render parameters in case of an action exception
+* DispatcherPortlet's default resource serving explicitly prevents access to WEB-INF and META-INF
+* Portlet @ExceptionHandler methods allow for writing the response directly (like in the Servlet case)
+* MockHttpServletRequest/HttpSession/etc returns independent Enumeration from "getAttributeNames()"
+
+
+Changes in version 3.0.4 (2010-08-19)
+-------------------------------------
+
+* support for Hibernate Core 3.6, Hibernate Validator 4.1, EclipseLink 2.1, EHCache 2.2
+* OSGi manifest version range accepts EHCache 2.x as well
+* added "contentLength()" method to Resource abstraction
+* URL-based Resource variants introspect "last-modified" and "content-length" response headers
+* refined "exists()" check for UrlResource (HEAD request) and ClassPathResource (URL resolution)
+* ConversionService is able to deal with empty collections and nested collections (fixed regression)
+* ConversionService properly handles nested Resource arrays in Map values (fixed regression)
+* ConversionService does not accidentally use copy constructor for same type
+* fixed double ConversionFailedException nesting for ObjectToObjectConverter invocations
+* BeanWrapper preserves annotation information for individual array/list/map elements
+* Spring's constructor resolution consistently finds non-public multi-arg constructors
+* revised constructor argument caching, avoiding a race condition for converted argument values
+* SpEL passes full collection type context (generics, annotations) to ConversionService
+* SpEL 'select last' operator now works consistently with maps
+* BeanWrapper/DataBinder's "autoGrowNestedPaths" works for Maps as well
+* fixed concurrency issue in TypedStringValue, showing for nested typed Maps in prototype beans
+* fixed WeakReferenceMonitor to never stop its monitoring thread if an entry has been registered
+* fixed CronTrigger to correctly parse month parts expressed as numbers (1-12 instead of 0-11)
+* TaskExecutorFactoryBean (as used by task:executor) exposes full ThreadPoolTaskExecutor type
+* JmsResourceHolder does not ignore IllegalStateException from locally synchronized transaction
+* fixed JMS CachingConnectionFactory to correctly cache a producer without fixed destination as well
+* DefaultMessageListenerContainer triggers Session commit even if no message has been received
+* DefaultMessageListenerContainer supports client id setting even for non-shared Connections
+* Spring's MessageEndpointFactory classes are now JCA 1.6 compliant as well
+* AbstractJaxWsServiceExporter supports "bindingType" bean property, overriding @BindingType
+* AbstractJaxWsServiceExporter supports "webServiceFeatures" bean property on JAX-WS 2.2
+* JaxWsPortProxyFactoryBean takes "wsdlDocumentUrl", "namespaceUri" etc defaults from @WebService
+* Jaxb2Marshaller's "marshallerProperties" Map accepts any value type
+* SpringTemplateLoader for FreeMarker supports last-modified timestamp through Resource abstraction
+* HibernateJpaDialect correctly closes borrowed connections even for nested JDBC executions
+* DefaultJdoDialect supports JDO 3.0 query timeout facility (as supported by DataNucleus 2.1)
+* transaction names based on method id from most specific method (target class instead of interface)
+* added "validationMessageSource" to LocalValidatorFactoryBean, for Spring-based validation messages
+* Spring field error arguments include actually declared annotation attributes in alphabetical order
+* JSR-303 Pattern message resolvable through Spring MessageSource (despite special characters) 
+* DispatcherServlet applies default view name translation to error views as well
+* mvc:annotation-driven reliably detects JSR-303 and JAXB2 in an OSGi environment as well
+* revised @MVC handler method resolution with respect to handler methods on generic interfaces
+* @MVC handler methods reliably resolve MultipartRequest arguments with HiddenHttpMethodFilter
+* WebDataBinder and @MVC request params detect and introspect MultipartFile arrays as well
+* fixed @PathVariable regression in combination with ConversionService usage on DataBinder
+* @CookieValue returns decoded cookie value in a Servlet environment (analogous to @RequestParam)
+* MVC HandlerExceptionResolvers prevent caching for exception views if preventResponseCaching=true
+* @ExceptionHandler works for inherited method and CGLIB proxies on Portlet controllers as well
+* Portlet @MVC's implicit render model will be updated at the end of the event phase
+* Portlet AbstractController consistently uses session mutex if "synchronizeOnSession" is active
+* PortletWrappingController supports Portlet 2.0 resource and event requests as well
+* fixed JSP EvalTag to render null result as empty String instead of "null" String
+* JSP EvalTag resolves "@myBeanName" references in expressions against the WebApplicationContext
+* added support for static resource serving: ResourceHttpRequestHandler, mvc:resources
+* revised DispatcherServlet's last-modified handling to properly work with scoped controllers
+* MockMultipartHttpServletRequest pre-defines method "POST" and content type "multipart/form-data"
+
+
+Changes in version 3.0.3 (2010-06-15)
+-------------------------------------
+
+* Spring autodetects JodaTime 1.3 or higher (as required), ignoring older JodaTime versions
+* clarified that Spring's Jackson support requires Jackson 1.3 or higher
+* JPA 2.0 support tested and supported with Hibernate 3.5.2 and OpenJPA 2.0.0 GA as well
+* revised VFS support for Spring's component scanning to work on JBoss AS 6.0.0 M3 as well
+* fixed URIEditor's URI construction to consider fragment as well
+* added default InputSourceEditor for SAX InputSource construction with a URL String as system id
+* CachedIntrospectionResults only caches GenericTypeAwarePropertyDescriptors if fully safe
+* revised BeanWrapper's exception wrapping to consistently handle ConversionExceptions
+* DefaultListableBeanFactory checks for alias circle on registerAlias (avoiding endless loop)
+* ConversionService is able to apply Converters to interface-based array elements
+* ConversionService fully supports conversion from String to MediaType now (through 'valueOf')
+* revised exception handling in ObjectToObjectConverter, avoiding InvocationTargetExceptions
+* a context ConversionService is able to override an ApplicationContext's resource editors
+* refined LifecycleProcessor exception handling, properly wrapping a start exception from a bean
+* revised DefaultLifecycleProcessor's handling of circular dependencies to avoid stack overflow
+* fixed constructor argument caching for prototypes with multiple constructor matches
+* specific detection of CGLIB subclasses in order to properly handle CGLIB interfaces
+* registerDependentBean resolves to the canonical bean name in order to handle alias references
+* fixed registerResolvableDependency mechanism to correctly handle non-serializable factory objects
+* added "expose-proxy" attribute to aop namespace (enforcing AopContext proxy exposure with CGLIB)
+* revised AbstractInterceptorDrivenBeanDefinitionDecorator for further alignment with auto-proxying
+* BeanDefinitionVisitor/PropertyPlaceholderConfigurer finds and resolves values in arrays as well
+* property placeholders can deal with nested expressions which happen to use the same suffix
+* SpEL's Elvis operator is able to deal with #{${myProp}?:defaultValue} case if myProp is empty
+* introduced EmbeddedValueResolverAware callback interface for convenient placeholder resolution
+* @Transactional qualifier value matches against @Qualifier annotations on @Bean methods as well
+* setTransactionIsolation on JDBC Connection only called when actually necessary (for PostgreSQL)
+* added limit for parsed SQL cache to NamedParameterJdbcTemplate (default is 256; configurable) 
+* CachingConnectionFactory detects destination equality for WebSphere MQ as well (using toString)
+* DefaultPersistenceUnitManager's getPersistenceUnitInfo method has 2.5 compatible signature again
+* DefaultMessageListenerContainer reacts to maxConcurrentConsumers reduction for long-lived tasks
+* added "idleConsumerLimit" bean property to DefaultMessageListenerContainer (default is 1)
+* AsyncAnnotationBeanPostProcessor consistently adds @Async processing as first Advisor in the chain
+* ScheduledTaskRegistrar (as used for @Scheduled processing) properly shuts down its default executor
+* CronTrigger defensively protects itself against accidental re-fires if a task runs too early
+* MailSendException includes all messages as failed messages in case of a connect failure
+* added support for JAX-WS 2.1 WebServiceFeatures to JaxWsPortClientInterceptor/PortProxyFactoryBean
+* added XmlAwareFormHttpMessageConverter, taking over the 3.0.2-introduced XML multipart support
+* ServletContextResourcePatternResolver handles "/WEB-INF/lib/*.jar!/**/context.xml" style patterns
+* fixed MVC mapping regression for servlet url-pattern "/" case on servers other than WebSphere
+* MVC mappings properly apply even to welcome file entries that forward to a DispatcherServlet
+* fixed @ExceptionHandler resolution in case of multiple matches at different inheritance levels
+* revised Portlet SessionStatus.setComplete() to avoid re-exposure of attributes in render phase
+* shortened Portlet MVC's implicit model render parameter name to "implicitModel"
+* added convenient "checkRefresh" bean property to TilesConfigurer
+* TilesConfigurer's "definitionsFactoryClass" property applies common Tiles DefinitionsFactory setup
+* JSP FormTag calculates proper default form action even when using a rewrite filter on WebSphere
+* JSP HiddenInputTag allows for using common HTML attributes (equivalent to LabelTag)
+* fixed JSP ErrorsTag to avoid invalid "*.errors" id, using form object name as id prefix instead
+* fixed JSP SelectTag's support for rendering enum constants
+* JSP Radiobutton/CheckboxesTag utilizes PropertyEditor/ConversionService for label rendering
+* MockHttpServletResponse supports multiple includes
+
+
+Changes in version 3.0.2 (2010-04-02)
+-------------------------------------
+
+* fixed cross-module version ranges in OSGi manifests
+* fixed contents of org.springframework.web.struts jar
+* upgraded to Hibernate Validator 4.0.2 and Jackson 1.4.2
+* compatibility with Hibernate 3.5 final (native and also as a JPA 2.0 provider)
+* compatibility with OpenJPA 2.0 (support for JPA 2.0 persistence.xml versioning)
+* compatibility with Hessian 4.0 (in terms of exception propagation)
+* compatibility with JasperReports 3.x (in terms of resource management)
+* restored full compatibility with Servlet 2.4 containers on all VMs
+* PropertyEditor lookup fallback works on Google App Engine as well
+* fixed TypeDescriptor/MethodParameter toString for all cases in debug log messages
+* widened AbstractFactoryBean's "getObjectType" signature to return any Class as well
+* BeanPostProcessors are allowed to return a null bean value in the middle of the chain
+* autowire="byType" ignores parameter name when choosing a primary bean, as defined
+* ObjectFactoryCreatingFactoryBean creates a serializable ObjectFactory reference
+* added ProviderCreatingFactoryBean, exposing a serializable JSR-330 Provider reference
+* "conversionService" bean will be ignored if it is not of type ConversionService
+* revised AbstractInterceptorDrivenBeanDefinitionDecorator for alignment with auto-proxying
+* SimpleJdbcCall's "returningResultSet" accepts any plain RowMapper now
+* added public "validateDatabaseSchema" method to Hibernate LocalSessionFactoryBean
+* HibernateJpaDialect borrows JDBC Connection on demand (supporting aggressive release)
+* JCA listener containers delegate to wrapped Transaction handle (for Geronimo compatibility)
+* @Transactional qualifiers work in unit tests as well (TransactionalTestExecutionListener)
+* @Value processing works in test instances (using the test context framework) as well now
+* @DirtiesContext is now inherited for class-level usage
+* NativeWebRequest detects native MultipartRequest when decorated by HiddenHttpMethodFilter
+* WebRequestInterceptor exposes HttpServletResponse through NativeWebRequest (after downcast)
+* WebContentInterceptor does not restrict HTTP methods by default anymore
+* WebApplicationObjectSupport's initServletContext will be called only once in any scenario
+* DispatcherPortlet passes handler instance into HandlerExceptionResolver for action exception
+* DispatcherPortlet applies preHandleRender callbacks in case of action exception as well
+* UrlPathHelper cuts off trailing servlet-path slashes for root mappings (on WebSphere)
+* introduced support for HttpEntity and ResponseEntity wrappers, adding context to body values
+* fixed DataBinder's conversion error handling for direct field access with ConversionService
+* @InitBinder methods support all applicable Spring 3.0 parameter annotations as well
+* fixed @RequestParam(required=false) regression for @InitBinder methods
+* @ExceptionHandler methods consistently receive original exception
+* fixed indexed property binding regression in form tag library
+* fixed @Configurable issue with null bean name
+
+
+Changes in version 3.0.1 (2010-02-18)
+-------------------------------------
+
+* upgraded to AspectJ 1.6.8
+* full support for JPA 2.0 persistence schema and PersistenceUnitInfo SPI
+* support for JPA PersistenceContext/Unit injection on Google App Engine
+* support for Hibernate 3.5 (as native Hibernate API and as JPA 2.0 provider)
+* support for Tiles 2.2.1 (preserving compatibility with Tiles 2.1.2 and above)
+* consistent treatment of unresolvable placeholders for Resource and Resource array properties
+* ConversionFailedException exDLBFposes offending value through public "getValue()" method
+* fixed BeanFactory's "getBeansWithAnnotation" to ignore beans with non-determinable type
+* widened FactoryBean's "getObjectType" signature to return any Class (Class<?>)
+* do not ever consider Object as a candidate type for autowiring by type (autowire="byType") 
+* BeanDefinitionReader and ClassPath/FileSystemXmlApplicationContext use varargs where possible
+* introduced BeanDefinitionRegistryPostProcessor extension to BeanFactoryPostProcessor
+* @Configuration classes support definition of BeanFactoryPostProcessor beans
+* component-scan's scoped-proxy attribute applies to scope-annotated singleton beans as well
+* generic ApplicationListener event type gets detected through AOP proxy as well
+* ApplicationListeners will only be executed once per event (even for scripted objects)
+* ApplicationListeners will get detected lazily as well (e.g. on @Bean's concrete result)
+* inner bean ApplicationListeners will be invoked through their proxy (if any)
+* fixed SimpleApplicationEventMulticaster's retriever caching to allow for proper removal
+* context-specific "conversionService" bean may refer to annotation-configured converter beans
+* refined DefaultLifecycleProcessor's start/stop logging and stop exception handling
+* DefaultLifecycleProcessor allows for overriding specific hooks in subclasses
+* BeanNameAutoProxyCreator detects alias matches for specified bean names
+* proxies with AspectJ pointcuts are fully serializable within a BeanFactory now
+* SharedEntityManagerCreator's EntityManager proxies are fully serializable now
+* Query call chaining works with shared EntityManager proxy outside of transaction as well
+* TransactionInterceptor is able to serialize "transactionManagerBeanName" as well
+* non-matching @Transactional qualifier value will lead to IllegalStateException
+* fixed WebSphereUowTransactionManager regression: correctly roll back in case of exception
+* JndiObjectFactoryBean explicitly only chooses public interfaces as default proxy interfaces
+* added vararg variants of query methods to JdbcTemplate (as known from SimpleJdbcTemplate)
+* MBeanClientInterceptor/MBeanProxyFactoryBean understands CompositeData/TabularData arrays
+* added "workManagerMBeanName" property to JBossWorkManagerTaskExecutor
+* task:executor's id value is now used as thread name prefix of ThreadPoolTaskExecutor
+* fixed @Scheduled processing to kick in once only even in an ApplicationContext hierarchy
+* fixed MediaType's Comparable behavior to do a full comparison, aligned with equals behavior
+* added "sortBySpecificity" method to MediaType, for typical use with accept header matching
+* MimeMessageHelper encodes from, to, cc, bcc String addresses with given encoding as well
+* changed HttpStatus.REQUEST_TOO_LONG constant to REQUEST_ENTITY_TOO_LARGE
+* relaxed generic Class declaration in HttpMessageConverter's canRead/canWrite/read signatures
+* fixed "mvc:view-controller" to work in a fully isolated fashion on Spring Dynamic Modules
+* DefaultRequestToViewNameTranslator strips trailing slashes as well (can also be turned off)
+* @RequestParam/RequestHeader/CookieValue's defaultValue allows for declaring empty String
+* @SessionAttributes works when used on an annotated controller interface with AOP proxying
+* WebRequest is a resolvable dependency in Servlet/Portlet web application contexts
+* revised JSP-based views to never fail when trying to set Servlet API forward attributes
+* lenient evaluation of boolean 'true' attribute expressions in JSP form tag library
+* added new spring:eval tag for evaluating SpEL expressions from JSP pages
+* SpringBeanAutowiringSupport works in extra ClassLoaders as well (e.g. WebLogic JAX-WS)
+
+
+Changes in version 3.0.0.GA (2009-12-16)
+----------------------------------------
+
+* component scanning autodetects the new EE 6 "javax.annotation.ManagedBean" stereotype
+* updated JPA 2.0 support to the final spec (tested compatibility with EclipseLink 2.0 GA)
+* full support for GlassFish V3 GA (includes component scanning and load-time weaving)
+* upgraded to JRuby 1.4 (while remaining compatible with JRuby 1.1 and above)
+* bean property names are matched leniently ("title" and "Title"; "ISBN" and "iSBN")
+* bean properties of type enum array/collection can be populated with comma-separated String
+* removed getBeansWithAnnotation(Class,boolean,boolean) method from ListableBeanFactory
+* PropertyPlaceholderConfigurer is compatible with Spring 2.5 extensions (again)
+* SmartLifecycle beans will get auto-started on demand even if marked as lazy-init
+* MBeanExporter detects FactoryBean-exported resources independent from declaration order
+* refactored SpelExpressionParser to accept SpelParserConfiguration object with boolean flags
+* revised TypeDescriptor's valueOf and forObject factory methods with some level of caching
+* revised GenericConverter's "getConvertibleTypes" signature to return Set of ConvertiblePair
+* GenericConversionService prefers matches against inherited interfaces over superclasses
+* renamed ConverterRegistry's addGenericConverter(GenericConverter) method to addConverter
+* no default converters for Object-to-Map and Map-To-Object anymore
+* default converter for String-to-Properties parsing only applies for actual Properties objects
+* default ObjectToStringConverter only stringifies objects that indicate proper toString behavior
+* added "converters" property to FormattingConversionServiceFactoryBean as well
+* full support for formatters and formatting annotations on array/collection elements
+* no default number formatter (relying on plain java.lang.Number parsing and rendering)
+* no default formatters for Date/Calendar (requiring explicit use of @DateTimeFormat)
+* BeanValidationPostProcessor runs in before-initialization phase (before init methods) by default
+* removed MultipartRequest mixin interface again (avoiding a package dependency cycle)
+* revised RestTemplate method signatures to accept Object values instead of just Strings
+* revised path variable extraction to properly deal with dots in variable values (again)
+* reintroduced createBinder template method in Servlet/Portlet AnnotationMethodHandlerAdapter
+
+
+Changes in version 3.0.0.RC3 (2009-12-01)
+-----------------------------------------
+
+* prepared for Grails and ROO requirements
+* restored compatibility with Apache CXF
+* fixed bean definition import via "classpath*:" URLs
+* added chaining-capable "add" method to MutablePropertyValues
+* constructor arguments can be overridden by name in child bean definitions
+* BeanDefinitions return isSingleton()=true by default again, with scope name empty
+* init/destroy methods get processed in the order of declaration at each hierarchy level
+* fixed lookup of LifecycleProcessor bean in a Spring Dynamic Modules environment
+* refined lifecycle processing through introduction of startup/shutdown phases
+* fixed transaction synchronization setup with TransactionAwareDataSourceProxy involved
+* added support for Hibernate 3.3 RegionFactory cache SPI to LocalSessionFactoryBean
+* JSR-303 SpringValidatorAdapter uses field name as first argument (analogous to bind errors)
+* replaced DefaultConversionService with ConversionServiceFactory(Bean)
+* revised FormatterRegistry interface and FormattingConversionServiceFactoryBean setup
+* mvc:annotation-driven exposes default Validator and ConversionService as top-level beans
+* mvc:annotation-driven registers applicable HttpMessageConverters by default, if available
+* added interceptors support to mvc namespace, for path-based interceptor mappings
+
+
+Changes in version 3.0.0.RC2 (2009-11-13)
+-----------------------------------------
+
+* updated to final versions of JSR-330 "javax.inject" and JSR-303 "javax.validation" APIs
+* full compliance with the JSR-330 TCK (i.e. full compliance with the final specification)
+* support for Hibernate Validator 4.0 GA (as the JSR-303 reference implementation)
+* added support for load-time weaving in JBoss 5.x
+* added support for recent EHCache 1.6 configuration properties to EHCacheFactoryBean
+* added AnnotatedBeanDefinitionReader helper for programmatic registration of annotated classes
+* added AnnotationConfig(Web)ApplicationContext for convenient registration/scanning of classes
+* added GenericXmlApplicationContext with flexible configuration options for its XML support
+* AbstractApplicationContext can also start up in case of system properties access failure
+* internal MergedBeanDefinitionPostProcessors apply after all other post-processors
+* inner beans detected as ApplicationListeners as well (only supported for inner singletons)
+* child bean definition's scope attribute can be inherited from parent bean definition now
+* introduced SmartLifecycle interface with auto-startup and shutdown order support
+* introduced LifecycleProcessor delegate, customizable through "lifecycleProcessor" bean
+* MessageListenerContainers and Quartz SchedulerFactoryBean start up on refresh instead of init
+* added initialize-database tag to jdbc namespace for populating external data sources with data
+* PathMatchingResourcePatternResolver leniently ignores non-existing root directories
+* DefaultConversionService understands "on"/"off", "yes"/"no", "1"/"0" as boolean values
+* CustomEditorConfigurer supports PropertyEditor instances again (with deprecation warning)
+* revised MethodParameter's annotation accessor methods
+* ClassUtils is now parameterized with Class<?> and Class<T> where appropriate
+* DataBinder now accepts var-args to set allowed, disallowed, and required fields
+* DataBinder auto-grows nested paths on traversal (avoiding NullValueInNestedPathException)
+* fixed enum binding regression with WebRequestDataBinder (as used by @MVC data binding now)
+* fixed FieldError to expose rejected input value as String value instead of as array
+* JSR-303 Validator will only register validation failures if no binding failure happened
+* ContentNegotiatingViewResolver works with ignoreAcceptHeader and defaultContentType as well
+* added Spring MVC namespace, with convenient mvc:annotation-driven configuration element
+* default number and datetime formatters configured when using the Spring MVC namespace
+* full support for datetime formatting using the Joda Time library (automatically enabled)
+* added convenient @NumberFormat and @DateTimeFormat annotations for declarative formatting
+* implicit T.valueOf(S) and constructor T(S) lookup if no explicit S->T converter matches
+* AbstractExcelView is compatible with Apache POI 3.0 as well as 3.5 now
+* TilesConfigurer only sets up EL support if JSP 2.1 is present (for JSP 2.0 compatibility)
+* re-introduced Struts 1.x support ("org.springframework.web.struts") in deprecated form
+* deprecated scheduling support for JDK 1.3 Timer ("org.springframework.scheduling.timer")
+* deprecated remoting support for JAX-RPC (in favor of JAX-WS)
+
+
+Changes in version 3.0.0.RC1 (2009-09-25)
+-----------------------------------------
+
+* upgraded to CGLIB 2.2, AspectJ 1.6.5, Groovy 1.6.3, EHCache 1.6.2, JUnit 4.7, TestNG 5.10
+* introduced early support for JSR-330 "javax.inject" annotations (for autowiring)
+* introduced early support for JSR-303 Bean Validation (setup and MVC integration)
+* added default editors for "java.util.Currency" and "java.util.TimeZone"
+* refined PathMatchingResourcePatternResolver's treatment of non-readable directories
+* PathMatchingResourcePatternResolver understands VFS resources (i.e. works on JBoss 5.x)
+* revised AccessControlContext access from BeanFactory
+* AbstractBeanDefinitionParser can deal with null return value as well
+* PropertyOverrideConfigurer's "ignoreInvalidKeys" ignores invalid property names as well
+* PropertyPlaceholderConfigurer supports "${myKey:myDefaultValue}" defaulting syntax
+* BeanFactory's default type conversion falls back to String constructor on target type
+* BeanFactory tries to create unknown collection implementation types via default constructor
+* BeanFactory supports ObjectFactory as a dependency type for @Autowired and @Value
+* BeanFactory supports JSR-330 Provider interface as a dependency type for @Inject
+* BeanFactory prefers local primary bean to primary bean in parent factory
+* protected @Autowired method can be overridden with non-annotated method to suppress injection
+* private @Autowired methods with same signature will be called individually across a hierarchy
+* @PostConstruct processed top-down (base class first); @PreDestroy bottom-up (subclass first)
+* ConfigurationClassPostProcessor detect @Bean methods on registered plain bean classes as well
+* support for default "conversionService" bean in an ApplicationContext
+* MBeanServerFactoryBean returns JDK 1.5 platform MBeanServer for agent id "" (empty String)
+* changed NamedParameter/SimpleJdbcOperations parameter signatures to accept any Map value type 
+* refined logging in JMS SingleConnectionFactory and DefaultMessageListenerContainer
+* introduced "ui.format" package as an alternative to PropertyEditors for data binding
+* @RequestMapping annotation now supported for annotated interfaces (and JDK proxies) as well
+* @RequestParam and co support placeholders and expressions in their defaultValue attributes
+* @Value expressions supported as MVC handler method arguments as well (against request scope)
+* JSR-303 support for validation of @MVC handler method arguments driven by @Valid annotations
+* refined response handling for @ExceptionHandler methods
+* @ResponseStatus usage in handler methods detected by RedirectView
+* all @SessionAttributes get exposed to the model before handler method execution
+* @Event/ResourceMapping uniquely mapped to through event/resource id, even across controllers
+* MultipartRequest is available as a mixin interface on (Native)WebRequest as well
+* removed outdated "cacheJspExpressions" feature from ExpressionEvaluationUtils
+* introduced common ErrorHandler strategy, supported by message listener container
+* Jpa/JdoTransactionManager passes resolved timeout into Jpa/JdoDialect's beginTransaction
+* HibernateJpaDialect applies timeout onto native Hibernate Transaction before begin call
+* Spring's Hibernate support is now compatible with Hibernate 3.5 beta 1 as well
+* Spring's JPA support is now fully compatible with JPA 2.0 as in EclipseLink 2.0.0.M7
+* SpringJUnit4ClassRunner is now compatible with JUnit 4.5, 4.6, and 4.7
+* SpringJUnit4ClassRunner once again supports collective timeouts for repeated tests
+* deprecated @NotTransactional annotation for test classes in favor of @BeforeTransaction
+
+
+Changes in version 3.0.0.M4 (2009-08-10)
+----------------------------------------
+
+* upgraded to JUnit 4.6, TestNG 5.9, and EasyMock 2.5.1
+* updated all Spring Framework OSGI manifests to list unversioned imports explicitly
+* relaxed several OSGi bundle dependencies (optional, extended version ranges)
+* revised Java 6 checks to test for the presence of specific Java 6 interfaces/classes only
+* replaced Commons Collections dependency with Spring-provided LinkedCaseInsensitiveMap
+* case-insensitive Maps and key Sets preserve original casing for introspection/logging
+* constructor argument type matching supports arrays and simple class names now
+* XML constructor-arg element allows for specifying a constructor argument by name now
+* XML import elements with relative resource patterns are supported as well now
+* introduced non-lenient constructor resolution mode for BeanDefinitions (for RFC-124)
+* revised DefaultListableBeanFactory's access control when running within a SecurityManager
+* BeanWrapper and DefaultListableBeanFactory accept a custom ConversionService now
+* DefaultListableBeanFactory references are serializable now when initialized with an id
+* scoped proxies are serializable now, for web scopes as well as for singleton beans
+* injected request/session references are serializable proxies for the current request now
+* Servlet/Portlet ApplicationContexts use a specific id based on servlet/portlet name
+* ReloadableResourceBundleMessageSource correctly calculates filenames for all locales now
+* @PostConstruct works for multiple private init methods of the same name in a hierarchy
+* @Primary/@Lazy/@DependsOn supported as meta-annotations as well
+* @Bean/@Scope etc supported as meta-annotations on factory methods as well now
+* @Required does not get processed on beans returned by @Bean factory methods
+* @Import detects and accepts existing configuration class of the desired type
+* @Transactional supports qualifier value for choosing between multiple transaction managers
+* WebSphereUowTransactionManager falls back to UOWManagerFactory lookup by default
+* JMS SingleConnectionFactory performs start call within connection monitor (for Oracle AQ)
+* @ManagedResource is marked as inherited now, for generic management-aware base classes
+* introduced dedicated @ManagedMetric annotation for metric attributes in a JMX environment
+* added task namespace with scheduler/executor configuration and scheduled task definitions
+* added jdbc namespace with embedded-database tag (supporting HSQL, H2, and Derby)
+* Hibernate AnnotationSessionFactoryBean detects Hibernate's special @Entity annotation too
+* added SimpleJaxWsServiceExporter workaround for WebLogic 10.3's address format requirements
+* added support for @WebServiceProvider annotation to Spring's JaxWsServiceExporters
+* updated Hessian support for Hessian 3.2 compatibility (requiring Hessian 3.2 or above now)
+* updated Tiles support for Tiles 2.1 compatibility (requiring Tiles 2.1.2 or above now)
+* Velocity/FreeMarker/TilesViewResolver only returns a view if the target resource exists now
+* @DirtiesContext is now supported at the test class level with configurable class modes
+* added beforeTestClass() and afterTestClass() to the TestExecutionListener API
+* ProfileValueUtils now enforces class-level overrides for @IfProfileValue
+* @ContextConfiguration's loader attribute is now inherited if not declared locally
+* TransactionalTestExecutionListener no longer flushes transactions before rolling back
+
+
+Changes in version 3.0.0.M3 (2009-05-06)
+----------------------------------------
+
+* Spring 3.0 includes reference documentation now
+* Spring 3.0 is shipping with proper Maven POMs now
+* updated to JRuby 1.2 (remaining compatible with JRuby 1.1 and above)
+* updated to Hessian 3.2.1 (remaining compatible with Hessian 3.1.3 and above)
+* updated to FreeMarker 2.3.15 (for exposure of FreeMarkerServlet-style HTTP scopes)
+* removed Axis 1.x support package, keeping basic JAX-RPC support only (next to JAX-WS)
+* introduced explicit XML array element in spring-beans-3.0.xsd
+* introduced new type conversion SPI and converter API in spring-core convert package
+* introduced annotated @Bean factory methods and JavaConfig-style @Configuration classes
+* introduced @Primary, @Lazy and @DependsOn annotations for scanned components
+* custom stereotype annotations can be meta-annotated with @Service, @Controller etc as well
+* @Scope and @Transactional are now supported as meta-annotations on custom annotations
+* @Autowired uses field/parameter name as fallback qualifier value
+* qualifier annotations can be used at method level as well (applying to all parameters)
+* @Value annotation can be used at method level as well (e.g. on bean property setters)
+* @Value values may use ${...} placeholders (driven by PropertyPlaceholderConfigurer)
+* @Resource names may use ${...} placeholders (driven by PropertyPlaceholderConfigurer)
+* fixed EL evaluation of prepared constructor arguments for repeated prototype creation
+* ConstructorArgumentValues exposed indexed arguments in the order of definition
+* AutowiredAnnotationBeanPostProcessor calculates cached arguments in a synchronized block
+* declarative destroy-method="..." specifications get validated at bean creation time
+* component-scan's "base-package" attribute supports spaces as separators as well
+* CachedIntrospectionResults always caches bean classes except in case of custom BeanInfo
+* GenericTypeResolver's type variable cache uses weak values (for OSGi compatibility)
+* fixed CachingMapDecorator to support garbage-collected weak references (again)
+* AOP ProxyFactory excludes non-public interfaces when autodetecting proxy interfaces
+* added DuplicateKeyException to DAO exception hierachy 
+* added EmbeddedDatabase support in spring-jdbc embedded package, with initial HSQL support
+* SessionAwareMessageListener supports generic declaration of concrete JMS Message type
+* RmiServiceExporter and RmiRegistryFactoryBean synchronize registry lookup/creation
+* added "unregisterManagedResource" method to MBeanExporter/MBeanExportOperations
+* TimerTaskExecutor creates non-daemon Timer and uses bean name as default Timer name
+* added TaskScheduler interface and Trigger abstraction
+* added ConcurrentTaskScheduler and ThreadPoolTaskScheduler
+* added CommonJ TimerManagerTaskScheduler
+* added CronTrigger implementation for cron expression support
+* renamed "contextProperties" attribute to "contextParameters" (matching web.xml naming)
+* "contextParameters" contains Servlet/PortletConfig parameters as well
+* added default "servletContext" and "servletConfig" environment beans
+* added default "portletContext" and "portletConfig" environment beans
+* added default web scope "application", wrapping a ServletContext/PortletContext
+* JSF FacesContext and ExternalContext are resolvable dependencies by default, if available
+* FacesRequestAttributes (as used by RequestContextHolder) can access global Portlet session
+* revised @RequestMapping semantics for REST support purposes
+* request handler methods with @ModelAttribute annotation always return a model attribute
+* introduced @ExceptionHandler annotation for used in annotated web controllers
+* introduced ModelAndViewResolver SPI for custom handler method return types
+* FreeMarkerView can be initialized with ServletContext only (e.g. for testing)
+* MockPortletSession supports destruction of session attributes on invalidation
+* completed upgrade of the TestContext Framework to JUnit 4.5
+* SpringJUnit4ClassRunner subclasses can now override the default ContextLoader class
+* added "value" alias for @ContextConfiguration's "locations" attribute
+
+
+Changes in version 3.0.0.M2 (2009-02-25)
+----------------------------------------
+
+* revised expression parser API design
+* added SimpleThreadScope implementation
+* refined OSGi version constraints for "javax.annotation" and "junit.framework"
+* "systemProperties" bean is not considered a default match for type Properties anymore
+* SimpleAliasRegistry's "getAliases" method returns transitive aliases now
+* SimpleAliasRegistry detects resolved aliases that loop back to the original name
+* PropertyPlaceholderConfigurer does not modify Map in case of equal String keys
+* improved NoClassDefFoundError handling during constructor resolution
+* inner class names in Java source style ("java.lang.Thread.State") supported as well
+* pre-converted property values are preserved more eagerly for re-created beans
+* prototype beans receive independent collection/array even when based on single value
+* registered plain singletons will be fully matched according to their qualifiers
+* @Qualifier value matching takes chained aliases of target beans into account as well
+* ASM-based AnnotationMetadata fully resolves class arguments and enums into Java types
+* ProceedingJoinPoint resolves parameter names using ASM-based parameter name discovery
+* MethodInvocations and ProceedingJoinPoints always expose original method (not bridge)
+* bridge method resolution works with Hibernate-generated CGLIB proxies as well
+* generic collection type resolution respects upper bound (e.g. ? extends Number) as well
+* TypeUtils detects variations of ParameterizedType/GenericArrayType assignability as well
+* ReflectionUtils findMethod detects methods on "java.lang.Object" as well
+* UrlResource eagerly closes HTTP connections in case of "getInputStream()" failure
+* PathMatchingResourcePatternResolver avoids NPE when initialized with null ClassLoader
+* all "taskExecutor" bean properties now accept any "java.util.concurrent.Executor"
+* added "Future submit(Runnable)" and "Future submit(Callable)" to AsyncTaskExecutor
+* SimpleAsyncTaskExecutor supports a custom "java.util.concurrent.ThreadFactory"
+* SchedulingTaskExecutor interface extends AsyncTaskExecutor now
+* added ThreadPoolExecutorFactoryBean (exposing the native ExecutorService interface)
+* added ExecutorServiceAdapter class as a standard wrapper for a Spring TaskExecutor
+* reduced backport-concurrent support to TaskExecutor adapters
+* added @Async annotation and AsyncAnnotationAdvisor (namespace support coming in M3)
+* EJB 3.1's @Asynchronous annotation gets detected and supported by default as well
+* ApplicationListener beans get obtained on demand, supporting non-singletons as well
+* ApplicationListeners will be called in the order according to the Ordered contract
+* generified ApplicationListener interface, narrowing the event type to be received
+* introduced SmartApplicationListener interface for supported event/source types
+* generified Transaction/Hibernate/Jdo/JpaCallback with generic "doInXxx" return type
+* HibernateOperations uses generic parameter/return types where possible
+* JdoOperations uses generic parameter/return types where possible (following JDO 2.1)
+* removed "flush" operation from JdoDialect (fully relying on JDO 2.0+ compliance now)
+* added JDO 2.1 compliant StandardPersistenceManagerProxy/SpringPersistenceManagerProxy
+* Spring-created EntityManagers support JPA 2.0 draft API ("unwrap", "getQueryBuilder")
+* Spring initiates JPA 2.0 query timeout with remaining Spring transaction timeout
+* added support for WebSphere's ResourceAdapter-managed messaging transactions
+* made SpringBeanAutowiringInterceptor callback signature compatible with WebSphere
+* WebSphereUowTransactionManager preserves original exception in case of rollback
+* added "flush()" method to TransactionStatus and TransactionSynchronization interfaces
+* test context manager automatically flushes transactions before rolling back
+* DefaultLobHandler uses explicit Blob/Clob access for reading when "wrapAsLob"=true
+* fixed JmsException/JmsUtils to fully avoid NPEs in case of cause messages being null
+* fixed MessageListenerAdapter's "getSubscriptionName()" to work without delegate as well
+* fixed HTTP invoker to support resolution of multi-level primitive array classes again
+* deprecated support for JMS 1.0.2 providers (JmsTemplate102 etc)
+* introduced top-level HTTP support package "org.springframework.http"
+* introduced RestTemplate facility in package "org.springframework.web.client"
+* introduced OXM support package (originating from Spring Web Services)
+* introduced OXM-based MarshallingMessageConverter for Spring JMS
+* introduced OXM-based MarshallingView for Spring MVC
+* refined @PathVariable handling in MVC handler methods
+* updated Spring Portlet MVC infrastructure and mocks for Portlet API 2.0
+* added resource and event methods to Portlet HandlerAdapter/HandlerInterceptor
+* added resolveException method for resource requests to HandlerExceptionResolver
+* introduced Resource/EventAwareController subinterfaces of Portlet Controller
+* introduced @Action/@Render/@Resource/@EventMapping annotations for Portlet MVC
+* added @RequestHeader support for Portlet MVC (based on Portlet request properties)
+* introduced @CookieValue annotation for Servlet and Portlet MVC handler methods
+* @RequestMapping type-level param constraints taken into account consistently
+* optional boolean parameters in MVC handler methods resolve to "false" if not present
+* "url" macro in "spring.ftl" performs standard Servlet URL encoding automatically
+
+
+Changes in version 3.0.0.M1 (2008-12-05)
+----------------------------------------
+
+* revised project layout and build system (module-based sources, bundle repository)
+* updated entire codebase for Java 5 code style (generics, varargs, StringBuilder)
+* updated to JUnit 4.5 and JRuby 1.1
+* removed WebLogic 8.1 and WebSphere 5.1 support
+* removed native TopLink API support (superseded by JPA)
+* removed Commons Attributes support (superseded by Java 5 annotations)
+* removed Jakarta JSTL support for JSP 1.2 (superseded by JSP 2.0)
+* removed outdated Struts 1.x Action delegation support
+* removed ContextLoaderServlet and Log4jConfigServlet
+* deprecated form controller hierarchy in favor of @MVC form object handling
+* deprecated JUnit 3.8 test class hierarchy in favor of test context framework
+* revised TaskExecutor interface to extend "java.util.concurrent.Executor" now
+* introduced Spring EL parser in org.springframework.expression package
+* introduced #{...} expression support in bean definitions
+* introduced @Value annotation for embedded expression support
+* introduced @PathVariable annotation for MVC handler methods
+* introduced ShallowEtagHeaderFilter
+* introduced AbstractAtomFeedView and AbstractRssFeedView
+* introduced default value support for @RequestParam
+* introduced @RequestHeader annotation for MVC handler methods
+* introduced "spring:url" and "spring:param" JSP tags
@@ -0,0 +1,261 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
+
+=======================================================================   
+
+SPRING FRAMEWORK 3.1 SUBCOMPONENTS: 
+
+Spring Framework 3.1 includes a number of subcomponents with
+separate copyright notices and license terms.  The product that 
+includes this file does not necessarily use all the open source 
+subcomponents referred to below. Your use of the source
+code for these subcomponents is subject to the terms and
+conditions of the following licenses. 
+
+>>> asm-2.2.3:
+
+Copyright (c) 2000-2005 INRIA, France Telecom
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holders nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGE.
+
+Copyright (c) 1999-2009, OW2 Consortium <http://www.ow2.org/>	
+		
+=======================================================================   
+
+To the extent any open source subcomponents are licensed under the EPL and/or other 
+similar licenses that require the source code and/or modifications to 
+source code to be made available (as would be noted above), you may obtain a 
+copy of the source code corresponding to the binaries for such open source 
+components and modifications thereto, if any, (the "Source Files"), by 
+downloading the Source Files from http://www.springsource.org/download, 
+or by sending a request, with your name and address to: VMware, Inc., 3401 Hillview 
+Avenue, Palo Alto, CA 94304, United States of America or email info@vmware.com.  All 
+such requests should clearly specify:  OPEN SOURCE FILES REQUEST, Attention General 
+Counsel.  VMware shall mail a copy of the Source Files to you on a CD or equivalent 
+physical medium.  This offer to obtain a copy of the Source Files is valid for three 
+years from the date you acquired this Software product.
@@ -0,0 +1,9 @@
+Spring Framework 3.1
+Copyright (c) 2002-2011 SpringSource, a division of VMware, Inc.
+
+This product is licensed to you under the Apache License, Version 2.0 (the "License").
+You may not use this product except in compliance with the License.
+
+This product may include a number of subcomponents with separate copyright notices and
+license terms. Your use of the source code for the these subcomponents is subject to
+the terms and conditions of the subcomponent's license, as noted in the LICENSE file.
@@ -0,0 +1,26 @@
+SPRING FRAMEWORK 3.1.4 (January 2013)
+-------------------------------------
+http://www.springsource.org
+
+1. INTRODUCTION
+
+Spring Framework 3.1 builds on the Spring Framework 3.0 foundation with
+a focus on Java-based application configuration and MVC enhancements.
+
+2. RELEASE NOTES
+
+This release comes with complete reference documentation. For further
+details, consult the provided javadoc for specific packages and classes.
+
+3. DISTRIBUTION JAR FILES
+
+The Spring Framework module jar files can be found in the 'dist'
+directory. Note that this release does not contain a 'spring.jar' file
+anymore, in contrast to previous Spring generations. Furthermore, the jar
+file names now follow bundle repository conventions.
+
+4. GETTING STARTED
+
+Please consult the blog examples at http://blog.springsource.com as well
+as sections of interest in the reference documentation. Sample
+applications and related material are provided as separate downloads.
@@ -1,327 +0,0 @@
-buildscript {
-	repositories {
-		gradlePluginPortal()
-		maven { url "https://repo.spring.io/plugins-release" }
-	}
-	dependencies {
-		classpath("io.spring.gradle:propdeps-plugin:0.0.9.RELEASE")
-		classpath("io.spring.gradle:docbook-reference-plugin:0.3.1")
-		classpath("org.asciidoctor:asciidoctorj-pdf:1.5.0-alpha.16")
-		classpath("org.asciidoctor:asciidoctorj-epub3:1.5.0-alpha.7")
-	}
-}
-
-// 3rd party plugin repositories can be configured in settings.gradle
-plugins {
-	id "com.gradle.build-scan" version "1.8"
-	id "io.spring.dependency-management" version "1.0.7.RELEASE" apply false
-	id "org.jetbrains.kotlin.jvm" version "1.2.71" apply false
-	id "org.jetbrains.dokka" version "0.9.18"
-	id "org.asciidoctor.convert" version "1.5.6"
-}
-
-buildScan {
-	licenseAgreementUrl = "https://gradle.com/terms-of-service"
-	licenseAgree = "yes"
-}
-
-ext {
-	linkHomepage = "https://projects.spring.io/spring-framework"
-	linkCi = "https://build.spring.io/browse/SPR"
-	linkIssue = "https://jira.spring.io/browse/SPR"
-	linkScmUrl = "https://github.com/spring-projects/spring-framework"
-	linkScmConnection = "scm:git:git://github.com/spring-projects/spring-framework.git"
-	linkScmDevConnection = "scm:git:ssh://git@github.com:spring-projects/spring-framework.git"
-
-	moduleProjects = subprojects.findAll {
-		!it.name.equals("spring-build-src") && !it.name.equals("spring-framework-bom")
-	}
-
-	aspectjVersion       = "1.8.14"
-	freemarkerVersion    = "2.3.28"
-	groovyVersion        = "2.4.17"
-	hsqldbVersion        = "2.4.1"
-	jackson2Version      = "2.9.9"
-	jettyVersion         = "9.4.19.v20190610"
-	junitJupiterVersion  = "5.0.3"
-	junitPlatformVersion = "1.0.3"
-	junitVintageVersion  = "4.12.3"
-	kotlinVersion        = "1.2.71"
-	log4jVersion         = "2.11.2"
-	nettyVersion         = "4.1.39.Final"
-	reactorVersion       = "Bismuth-SR17"
-	rxjavaVersion        = "1.3.8"
-	rxjavaAdapterVersion = "1.2.1"
-	rxjava2Version       = "2.1.17"
-	slf4jVersion         = "1.7.28"	  // spring-jcl + consistent 3rd party deps
-	tiles3Version        = "3.0.8"
-	tomcatVersion        = "8.5.45"
-	undertowVersion      = "1.4.27.Final"
-
-	gradleScriptDir = "${rootProject.projectDir}/gradle"
-	withoutJclOverSlf4j = {
-		exclude group: "org.slf4j", module: "jcl-over-slf4j"
-	}
-}
-
-configure(allprojects) { project ->
-	group = "org.springframework"
-	version = qualifyVersionIfNecessary(version)
-
-	apply plugin: "java"
-	apply plugin: "kotlin"
-	apply plugin: "propdeps"
-	apply plugin: "test-source-set-dependencies"
-	apply plugin: "io.spring.dependency-management"
-	apply from: "${gradleScriptDir}/ide.gradle"
-
-	dependencyManagement {
-		resolutionStrategy {
-			cacheChangingModulesFor 0, "seconds"
-		}
-		applyMavenExclusions = false
-		generatedPomCustomization {
-			enabled = false
-		}
-	}
-
-	configurations.all {
-		// Check for updates every build
-		resolutionStrategy.cacheChangingModulesFor 0, "seconds"
-
-		// Consistent slf4j version (e.g. clashes between slf4j versions)
-		resolutionStrategy.eachDependency { DependencyResolveDetails details ->
-			if (details.requested.group == "org.slf4j") {
-				details.useVersion slf4jVersion
-			}
-		}
-	}
-
-	def commonCompilerArgs =
-			["-Xlint:serial", "-Xlint:cast", "-Xlint:classfile", "-Xlint:dep-ann",
-			 "-Xlint:divzero", "-Xlint:empty", "-Xlint:finally", "-Xlint:overrides",
-			 "-Xlint:path", "-Xlint:processing", "-Xlint:static", "-Xlint:try", "-Xlint:-options"]
-
-	compileJava.options*.compilerArgs = commonCompilerArgs +
-			["-Xlint:varargs", "-Xlint:fallthrough", "-Xlint:rawtypes",
-			 "-Xlint:deprecation", "-Xlint:unchecked", "-Werror"]
-
-	compileTestJava.options*.compilerArgs = commonCompilerArgs +
-			["-Xlint:-varargs", "-Xlint:-fallthrough", "-Xlint:-rawtypes",
-			 "-Xlint:-deprecation", "-Xlint:-unchecked"]
-
-	compileJava {
-		sourceCompatibility = 1.8
-		targetCompatibility = 1.8
-		options.encoding = "UTF-8"
-	}
-
-	compileTestJava {
-		sourceCompatibility = 1.8
-		targetCompatibility = 1.8
-		options.encoding = "UTF-8"
-		options.compilerArgs += "-parameters"
-	}
-
-	compileKotlin {
-		kotlinOptions {
-			jvmTarget = "1.8"
-			freeCompilerArgs = ["-Xjsr305=strict"]
-			apiVersion = "1.1"
-			languageVersion = "1.1"
-		}
-	}
-
-	compileTestKotlin {
-		kotlinOptions {
-			jvmTarget = "1.8"
-			freeCompilerArgs = ["-Xjsr305=strict"]
-		}
-	}
-
-	test {
-		systemProperty("java.awt.headless", "true")
-		systemProperty("testGroups", project.properties.get("testGroups"))
-		scanForTestClasses = false
-		include(["**/*Tests.class", "**/*Test.class"])
-		// Since we set scanForTestClasses to false, we need to filter out inner
-		// classes with the "$" pattern; otherwise, using -Dtest.single=MyTests to
-		// run MyTests by itself will fail if MyTests contains any inner classes.
-		exclude(["**/Abstract*.class", '**/*$*'])
-		reports.junitXml.setDestination(file("$buildDir/test-results"))
-	}
-
-	repositories {
-		mavenCentral()
-		maven { url "https://repo.spring.io/libs-spring-framework-build" }
-	}
-
-	dependencies {
-		testCompile("junit:junit:4.12") {
-			exclude group: "org.hamcrest", module: "hamcrest-core"
-		}
-		testCompile("org.mockito:mockito-core:2.19.1") {
-			exclude group: "org.hamcrest", module: "hamcrest-core"
-		}
-		testCompile("com.nhaarman:mockito-kotlin:1.6.0") {
-			exclude module: "kotlin-stdlib"
-			exclude module: "kotlin-reflect"
-			exclude module: "mockito-core"
-		}
-		testCompile("org.hamcrest:hamcrest-all:1.3")
-		testRuntime("org.apache.logging.log4j:log4j-core:${log4jVersion}")
-		testRuntime("org.apache.logging.log4j:log4j-slf4j-impl:${log4jVersion}")
-		testRuntime("org.apache.logging.log4j:log4j-jul:${log4jVersion}")
-		// JSR-305 only used for non-required meta-annotations
-		compileOnly("com.google.code.findbugs:jsr305:3.0.2")
-		testCompileOnly("com.google.code.findbugs:jsr305:3.0.2")
-	}
-
-	ext.javadocLinks = [
-		"https://docs.oracle.com/javase/8/docs/api/",
-		"https://docs.oracle.com/javaee/7/api/",
-		"https://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/",  // CommonJ
-		"https://www.ibm.com/support/knowledgecenter/SS7JFU_8.5.5/com.ibm.websphere.javadoc.doc/web/apidocs/",
-		"https://glassfish.java.net/nonav/docs/v3/api/",
-		"https://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
-		"https://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
-		"https://tiles.apache.org/tiles-request/apidocs/",
-		"https://tiles.apache.org/framework/apidocs/",
-		"https://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
-		"https://www.ehcache.org/apidocs/2.10.4/",
-		"https://www.quartz-scheduler.org/api/2.3.0/",
-		"https://fasterxml.github.io/jackson-core/javadoc/2.9/",
-		"https://fasterxml.github.io/jackson-databind/javadoc/2.9/",
-		"https://fasterxml.github.io/jackson-dataformat-xml/javadoc/2.9/",
-		"https://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs/",
-		"https://junit.org/junit4/javadoc/4.12/",
-		"https://junit.org/junit5/docs/${junitJupiterVersion}/api/"
-	] as String[]
-}
-
-configure(subprojects - project(":spring-build-src")) { subproject ->
-	apply from: "${gradleScriptDir}/publish-maven.gradle"
-
-	jar {
-		manifest.attributes["Implementation-Title"] = subproject.name
-		manifest.attributes["Implementation-Version"] = subproject.version
-		manifest.attributes["Automatic-Module-Name"] = subproject.name.replace('-', '.')  // for Jigsaw
-		manifest.attributes["Created-By"] =
-				"${System.getProperty("java.version")} (${System.getProperty("java.specification.vendor")})"
-
-		from("${rootProject.projectDir}/src/docs/dist") {
-			include "license.txt"
-			include "notice.txt"
-			into "META-INF"
-			expand(copyright: new Date().format("yyyy"), version: project.version)
-		}
-	}
-
-	javadoc {
-		description = "Generates project-level javadoc for use in -javadoc jar"
-
-		options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
-		options.author = true
-		options.header = project.name
-		options.use = true
-		options.links(project.ext.javadocLinks)
-		options.addStringOption("Xdoclint:none", "-quiet")
-
-		// Suppress warnings due to cross-module @see and @link references.
-		// Note that global 'api' task does display all warnings.
-		logging.captureStandardError LogLevel.INFO
-		logging.captureStandardOutput LogLevel.INFO  // suppress "## warnings" message
-	}
-
-	task sourcesJar(type: Jar, dependsOn: classes) {
-		duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-		classifier = "sources"
-		from sourceSets.main.allSource
-		// Don't include or exclude anything explicitly by default. See SPR-12085.
-	}
-
-	task javadocJar(type: Jar) {
-		classifier = "javadoc"
-		from javadoc
-	}
-
-	artifacts {
-		archives sourcesJar
-		archives javadocJar
-	}
-}
-
-configure(rootProject) {
-	description = "Spring Framework"
-
-	apply plugin: "groovy"
-	apply from: "${gradleScriptDir}/jdiff.gradle"
-	apply from: "${gradleScriptDir}/docs.gradle"
-
-	dependencyManagement {
-		imports {
-			mavenBom "io.projectreactor:reactor-bom:${reactorVersion}"
-		}
-	}
-
-	// Don't publish the default jar for the root project
-	configurations.archives.artifacts.clear()
-
-	dependencies {  // for integration tests
-		testCompile(project(":spring-aop"))
-		testCompile(project(":spring-beans"))
-		testCompile(project(":spring-context"))
-		testCompile(project(":spring-core"))
-		testCompile(project(":spring-expression"))
-		testCompile(project(":spring-jdbc"))
-		testCompile(project(":spring-orm"))
-		testCompile(project(":spring-test"))
-		testCompile(project(":spring-tx"))
-		testCompile(project(":spring-web"))
-		testCompile("javax.inject:javax.inject:1")
-		testCompile("javax.resource:javax.resource-api:1.7")
-		testCompile("javax.servlet:javax.servlet-api:3.1.0")
-		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
-		testCompile("org.hsqldb:hsqldb:${hsqldbVersion}")
-		testCompile("org.hibernate:hibernate-core:5.1.17.Final")
-	}
-
-	artifacts {
-		archives docsZip
-		archives schemaZip
-		archives distZip
-	}
-
-	task wrapper(type: Wrapper) {
-		description = "Generates gradlew[.bat] scripts"
-		gradleVersion = "4.4.1"
-
-		doLast() {
-			def gradleOpts = "-XX:MaxMetaspaceSize=1024m -Xmx1024m"
-			def gradleBatOpts = "$gradleOpts -XX:MaxHeapSize=256m"
-			File wrapperFile = file("gradlew")
-			wrapperFile.text = wrapperFile.text.replace("DEFAULT_JVM_OPTS=",
-					"GRADLE_OPTS=\"$gradleOpts \$GRADLE_OPTS\"\nDEFAULT_JVM_OPTS=")
-			File wrapperBatFile = file("gradlew.bat")
-			wrapperBatFile.text = wrapperBatFile.text.replace("set DEFAULT_JVM_OPTS=",
-					"set GRADLE_OPTS=$gradleBatOpts %GRADLE_OPTS%\nset DEFAULT_JVM_OPTS=")
-		}
-	}
-}
-
-/*
- * Support publication of artifacts versioned by topic branch.
- * CI builds supply `-P BRANCH_NAME=<TOPIC>` to gradle at build time.
- * If <TOPIC> starts with 'SPR-', change version
- *     from BUILD-SNAPSHOT => <TOPIC>-SNAPSHOT
- *     e.g. 3.2.1.BUILD-SNAPSHOT => 3.2.1.SPR-1234-SNAPSHOT
- */
-def qualifyVersionIfNecessary(version) {
-	if (rootProject.hasProperty("BRANCH_NAME")) {
-		def qualifier = rootProject.getProperty("BRANCH_NAME")
-		if (qualifier.startsWith("SPR-")) {
-			return version.replace("BUILD", qualifier)
-		}
-	}
-	return version
-}
@@ -0,0 +1,32 @@
+version=3.1.5
+
+natural.name=spring-framework
+project.name=Spring Framework
+project.key=SPR
+ivy.cache.dir=${basedir}/../ivy-cache
+integration.repo.dir=${basedir}/../integration-repo
+license.dir=${basedir}/../build-spring-framework/resources
+javadoc.exclude.package.names=org/springframework/samples/**
+javadoc.max.memory=1024M
+test.vm.args=-Xmx1024M -XX:MaxPermSize=512M -XX:+HeapDumpOnOutOfMemoryError
+compiler.args=-enableJavadoc -warn:none
+
+## common osgi ranges used in template.mf files
+spring.osgi.range.nq=${version:[=.=.=, =.=.+1)}
+spring.osgi.range="${spring.osgi.range.nq}"
+aj.osgi.range="[1.6.8, 2.0.0)"
+
+## For GA releases
+#release.type=release
+#build.stamp=RELEASE
+
+## For milestone releases
+#release.type=milestone
+#build.stamp=M1
+
+## For trunk development / ci builds
+release.type=integration
+build.stamp=BUILD-SNAPSHOT
+
+#bundlor
+fail.on.warnings=false
@@ -0,0 +1,4 @@
+# common dependency versions
+aspectj.version=1.6.8.RELEASE
+junit.version=4.9.0
+testng.version=5.12.1
@@ -1,10 +0,0 @@
-description = "Exposes gradle buildSrc for IDE support"
-
-apply plugin: "groovy"
-
-dependencies {
-	compile gradleApi()
-	compile localGroovy()
-}
-
-configurations.archives.artifacts.clear()
@@ -1,55 +0,0 @@
-/*
- * Copyright 2002-2014 the original author or authors.
- *
- * Licensed 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.
- */
-
-package org.springframework.build.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration;
-import org.gradle.api.artifacts.ProjectDependency;
-
-/**
- * Gradle plugin that automatically updates testCompile dependencies to include
- * the test source sets of project dependencies.
- *
- * @author Phillip Webb
- */
-class TestSourceSetDependenciesPlugin implements Plugin<Project> {
-
-	@Override
-	public void apply(Project project) {
-		project.afterEvaluate {
-			Set<ProjectDependency> projectDependencies = new LinkedHashSet<ProjectDependency>()
-			collectProjectDependencies(projectDependencies, project)
-			projectDependencies.each {
-				project.dependencies.add("testCompile", it.dependencyProject.sourceSets.test.output)
-			}
-		}
-	}
-
-	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
-		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
-			Configuration configuration = project.getConfigurations().findByName(configurationName)
-			if (configuration) {
-				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
-					projectDependencies.add(it)
-					collectProjectDependencies(projectDependencies, it.dependencyProject)
-				}
-			}
-		}
-	}
-
-}
@@ -1 +0,0 @@
-implementation-class=org.springframework.build.gradle.TestSourceSetDependenciesPlugin
@@ -0,0 +1,6 @@
+# properties used by Bamboo build plan at http://build.springframework.org/build/admin/buildConfiguration.action?buildKey=SPR-TRUNKQUICK
+# run in conjunction with ANT_OPTS='-XX:MaxPermSize=512m -Xmx1024m'
+compiler.args=-enableJavadoc -warn:none
+java.awt.headless=true
+ci.build=true
+test.vm.args=-XX:MaxPermSize=512m -Xmx1024m
@@ -0,0 +1,267 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<profiles version="11">
+<profile kind="CodeFormatterProfile" name="Spring" version="11">
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.lineSplit" value="120"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_binary_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_binary_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.wrap_before_binary_operator" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode" value="enabled"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.assertIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+<setting id="org.eclipse.jdt.core.compiler.source" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="120"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.compliance" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.compiler.problem.enumIdentifier" value="error"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.compiler.codegen.targetPlatform" value="1.5"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+<setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+<setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="tab"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+<setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+</profile>
+</profiles>
@@ -1 +0,0 @@
-version=5.0.21.BUILD-SNAPSHOT
@@ -1,239 +0,0 @@
-/*
- * Copyright 2002-2017 the original author or authors.
- *
- *  Licensed 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
- *
- *       https://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.
- */
-
-task api(type: Javadoc) {
-	group = "Documentation"
-	description = "Generates aggregated Javadoc API documentation."
-	title = "${rootProject.description} ${version} API"
-
-	dependsOn {
-		subprojects.collect {
-			it.tasks.getByName("jar")
-		}
-	}
-	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
-	options.author = true
-	options.header = rootProject.description
-	options.use = true
-	options.overview = "src/docs/api/overview.html"
-	options.stylesheetFile = file("src/docs/api/stylesheet.css")
-	options.splitIndex = true
-	options.links(project.ext.javadocLinks)
-	options.addStringOption('Xdoclint:none', '-quiet')
-
-	source subprojects.collect { project ->
-		project.sourceSets.main.allJava
-	}
-
-	maxMemory = "1024m"
-	destinationDir = new File(buildDir, "api")
-
-	doFirst {
-		classpath = files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
-	}
-}
-
-dokka {
-	dependsOn {
-		tasks.getByName("api")
-	}
-	doFirst {
-		classpath = subprojects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
-		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
-
-	}
-	moduleName = "spring-framework"
-	outputFormat = "html"
-	outputDirectory = "$buildDir/docs/kdoc"
-
-	sourceDirs = files(subprojects.collect { project ->
-		def kotlinDirs = project.sourceSets.main.kotlin.srcDirs.collect()
-		kotlinDirs -= project.sourceSets.main.java.srcDirs
-	})
-	externalDocumentationLink {
-		url = new URL("https://docs.spring.io/spring-framework/docs/$version/javadoc-api/")
-		packageListUrl = new File(buildDir, "api/package-list").toURI().toURL()
-	}
-	externalDocumentationLink {
-		url = new URL("https://projectreactor.io/docs/core/release/api/")
-	}
-	externalDocumentationLink {
-		url = new URL("https://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/")
-	}
-}
-
-asciidoctor {
-	sources {
-		include '*.adoc'
-	}
-	resources {
-		from(sourceDir) {
-			include 'images/*', 'stylesheets/*', 'tocbot-3.0.2/*'
-		}
-	}
-	logDocuments = true
-	backends = ["html5"]
-	// only ouput PDF documentation for non-SNAPSHOT builds
-	if(!project.getVersion().toString().contains("BUILD-SNAPSHOT")) {
-		backends += "pdf"
-	}
-	options doctype: 'book', eruby: 'erubis'
-	attributes  'icons': 'font',
-			'idprefix': '',
-			'idseparator': '-',
-			docinfo: '',
-			revnumber: project.version,
-			sectanchors: '',
-			sectnums: '',
-			'source-highlighter': 'coderay@', // TODO switch to 'rouge' once supported by the html5 backend
-			stylesdir: 'stylesheets/',
-			stylesheet: 'main.css',
-			'spring-version': project.version
-
-}
-
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'dokka']) {
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "docs"
-	description = "Builds -${classifier} archive containing api and reference " +
-			"for deployment at https://docs.spring.io/spring-framework/docs."
-
-	from("src/dist") {
-		include "changelog.txt"
-	}
-
-	from (api) {
-		into "javadoc-api"
-	}
-
-	from ("$asciidoctor.outputDir/html5") {
-		into "spring-framework-reference"
-	}
-
-	from ("$asciidoctor.outputDir/pdf") {
-		into "spring-framework-reference/pdf"
-	}
-
-	from (dokka) {
-		into "kdoc-api"
-	}
-}
-
-task schemaZip(type: Zip) {
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "schema"
-	description = "Builds -${classifier} archive containing all " +
-			"XSDs for deployment at https://springframework.org/schema."
-	duplicatesStrategy 'exclude'
-	moduleProjects.each { subproject ->
-		def Properties schemas = new Properties();
-
-		subproject.sourceSets.main.resources.find {
-			(it.path.endsWith("META-INF/spring.schemas") || it.path.endsWith("META-INF\\spring.schemas"))
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = subproject.sourceSets.main.resources.find {
-				(it.path.endsWith(schemas.get(key)) || it.path.endsWith(schemas.get(key).replaceAll('\\/','\\\\')))
-			}
-			assert xsdFile != null
-			into (shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
-
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "dist"
-	description = "Builds -${classifier} archive, containing all jars and docs, " +
-			"suitable for community download page."
-
-	ext.baseDir = "${baseName}-${project.version}";
-
-	from("src/docs/dist") {
-		include "readme.txt"
-		include "license.txt"
-		include "notice.txt"
-		into "${baseDir}"
-		expand(copyright: new Date().format("yyyy"), version: project.version)
-	}
-
-	from(zipTree(docsZip.archivePath)) {
-		into "${baseDir}/docs"
-	}
-
-	from(zipTree(schemaZip.archivePath)) {
-		into "${baseDir}/schema"
-	}
-
-	moduleProjects.each { subproject ->
-		into ("${baseDir}/libs") {
-			from subproject.jar
-			if (subproject.tasks.findByPath("sourcesJar")) {
-				from subproject.sourcesJar
-			}
-			if (subproject.tasks.findByPath("javadocJar")) {
-				from subproject.javadocJar
-			}
-		}
-	}
-}
-
-distZip.mustRunAfter subprojects.test
-
-// Create a distribution that contains all dependencies (required and optional).
-// Not published by default; only for use when building from source.
-task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "dist-with-deps"
-	description = "Builds -${classifier} archive, containing everything " +
-			"in the -${distZip.classifier} archive plus all runtime dependencies."
-
-	from zipTree(distZip.archivePath)
-
-	gradle.taskGraph.whenReady { taskGraph ->
-		if (taskGraph.hasTask(":${zipTask.name}")) {
-			def projectNames = rootProject.subprojects*.name
-			def artifacts = new HashSet()
-			subprojects.each { subproject ->
-				(subproject.configurations.runtime.resolvedConfiguration.resolvedArtifacts +
-						subproject.configurations.optional.resolvedConfiguration.resolvedArtifacts).each { artifact ->
-					def dependency = artifact.moduleVersion.id
-					if (!projectNames.contains(dependency.name)) {
-						artifacts << artifact.file
-					}
-				}
-			}
-
-			zipTask.from(artifacts) {
-				into "${distZip.baseDir}/deps"
-			}
-		}
-	}
-}
@@ -1,114 +0,0 @@
-import org.gradle.plugins.ide.eclipse.model.ProjectDependency
-import org.gradle.plugins.ide.eclipse.model.SourceFolder
-
-
-apply plugin: "propdeps-eclipse"
-apply plugin: "propdeps-idea"
-
-eclipse.jdt {
-	sourceCompatibility = 1.8
-	targetCompatibility = 1.8
-}
-
-// Replace classpath entries with project dependencies (GRADLE-1116)
-// https://issues.gradle.org/browse/GRADLE-1116
-eclipse.classpath.file.whenMerged { classpath ->
-	def regexp = /.*?\/([^\/]+)\/build\/([^\/]+\/)+(?:main|test)/ // only match those that end in main or test (avoids removing necessary entries like build/classes/jaxb)
-	def projectOutputDependencies = classpath.entries.findAll { entry -> entry.path =~ regexp }
-	projectOutputDependencies.each { entry ->
-		def matcher = (entry.path =~ regexp)
-		if (matcher) {
-			def projectName = matcher[0][1]
-			def path = "/${projectName}"
-			if(!classpath.entries.find { e -> e instanceof ProjectDependency && e.path == path }) {
-				def dependency = new ProjectDependency(path)
-				dependency.exported = true
-				classpath.entries.add(dependency)
-			}
-			classpath.entries.remove(entry)
-		}
-	}
-	classpath.entries.removeAll { entry -> (entry.path =~ /(?!.*?repack.*\.jar).*?\/([^\/]+)\/build\/libs\/[^\/]+\.jar/) }
-}
-
-
-// Use separate main/test outputs (prevents WTP from packaging test classes)
-eclipse.classpath.defaultOutputDir = file(project.name+"/bin/eclipse")
-eclipse.classpath.file.beforeMerged { classpath ->
-	classpath.entries.findAll{ it instanceof SourceFolder }.each {
-		if(it.output.startsWith("bin/")) {
-			it.output = null
-		}
-	}
-}
-eclipse.classpath.file.whenMerged { classpath ->
-	classpath.entries.findAll{ it instanceof SourceFolder }.each {
-		it.output = "bin/" + it.path.split("/")[1]
-	}
-}
-
-// Ensure project dependencies come after 3rd-party libs (SPR-11836)
-// https://jira.spring.io/browse/SPR-11836
-eclipse.classpath.file.whenMerged { classpath ->
-	classpath.entries.findAll { it instanceof ProjectDependency }.each {
-		// delete from original position
-		classpath.entries.remove(it)
-		// append to end of classpath
-		classpath.entries.add(it)
-	}
-}
-
-// Allow projects to be used as WTP modules
-eclipse.project.natures "org.eclipse.wst.common.project.facet.core.nature"
-
-// Include project specific settings
-task eclipseSettings(type: Copy) {
-	from rootProject.files(
-		"src/eclipse/org.eclipse.jdt.ui.prefs",
-		"src/eclipse/org.eclipse.wst.common.project.facet.core.xml")
-	into project.file('.settings/')
-	outputs.upToDateWhen { false }
-}
-
-task eclipseWstComponent(type: Copy) {
-	from rootProject.files(
-		"src/eclipse/org.eclipse.wst.common.component")
-	into project.file('.settings/')
-	expand(deployname: project.name)
-	outputs.upToDateWhen { false }
-}
-
-task eclipseJdtPrepare(type: Copy) {
-	from rootProject.file("src/eclipse/org.eclipse.jdt.core.prefs")
-	into project.file(".settings/")
-	outputs.upToDateWhen { false }
-}
-
-task cleanEclipseJdtUi(type: Delete) {
-	delete project.file(".settings/org.eclipse.jdt.core.prefs")
-	delete project.file(".settings/org.eclipse.jdt.ui.prefs")
-	delete project.file(".settings/org.eclipse.wst.common.component")
-	delete project.file(".settings/org.eclipse.wst.common.project.facet.core.xml")
-}
-
-tasks["eclipseJdt"].dependsOn(eclipseJdtPrepare)
-tasks["cleanEclipse"].dependsOn(cleanEclipseJdtUi)
-tasks["eclipse"].dependsOn(eclipseSettings, eclipseWstComponent)
-
-
-// Filter 'build' folder
-eclipse.project.file.withXml {
-	def node = it.asNode()
-
-	def filteredResources = node.get("filteredResources")
-	if(filteredResources) {
-		node.remove(filteredResources)
-	}
-	def filterNode = node.appendNode("filteredResources").appendNode("filter")
-	filterNode.appendNode("id", "1359048889071")
-	filterNode.appendNode("name", "")
-	filterNode.appendNode("type", "30")
-	def matcherNode = filterNode.appendNode("matcher")
-	matcherNode.appendNode("id", "org.eclipse.ui.ide.multiFilter")
-	matcherNode.appendNode("arguments", "1.0-projectRelativePath-matches-false-false-build")
-}
@@ -1,76 +0,0 @@
-/**
- * Generate a JDiff report between the current version and an older version.
- *
- * Usage:
- *  gradle jdiff -D OLD_VERSION=3.1.3.RELEASE -D OLD_VERSION_ROOT=/path/to/3.1.3.RELEASE
- *
- * View generated report at:
- *  build/reports/jdiff/changes.html
- *
- * @param OLD_VERSION required
- * @param OLD_VERSION_ROOT required, typically pointing to a separate git clone dir
- */
-task jdiff {
-	description = "Generates a JDiff report"
-	group = "Documentation"
-
-	def jdiffHome = "${rootProject.rootDir}/gradle/jdiff"
-
-	ant.taskdef(
-			name: "jdiff",
-			classname: "jdiff.JDiffAntTask",
-			classpath: "${jdiffHome}/antjdiff.jar")
-
-	def currentVersion = rootProject.version
-	def currentVersionRoot = rootProject.rootDir
-
-	def oldVersion = System.getProperty("OLD_VERSION")
-	def oldVersionRoot = System.getProperty("OLD_VERSION_ROOT")
-
-	def outputDir = "${rootProject.buildDir}/reports/jdiff/${oldVersion}_to_${currentVersion}"
-
-	doLast {
-		if (oldVersion == null)
-			throw new IllegalArgumentException(
-				"Set OLD_VERSION property to indicate older of the two versions being compared")
-		if (oldVersionRoot == null)
-			throw new IllegalArgumentException(
-				"Set OLD_VERSION_ROOT property to indicate the root directory for ${oldVersion}")
-
-		oldVersionRoot = new File(oldVersionRoot)
-
-		ant.property(name: "JDIFF_HOME", value: jdiffHome)
-		ant.mkdir(dir: outputDir)
-		ant.jdiff(
-				destdir: outputDir,
-				source: "1.8",
-				verbose: "off",
-				stats: "on",
-				docchanges: "off") {
-			old(name: "Spring Framework ${oldVersion}") {
-				oldVersionRoot.eachDirMatch( {
-						def candidate = new File(it)
-						candidate.name.matches("org.springframework.*") ||
-						candidate.name.matches("spring-.*") }) { match ->
-					match.eachDirRecurse { subdir ->
-						if (subdir.path ==~ '.*/src/main/java$') {
-							dirset(dir: subdir.path, includes: "org/**")
-						}
-					}
-				}
-			}
-			"new"(name: "Spring Framework ${currentVersion}") {
-				currentVersionRoot.eachDirMatch( {
-						def candidate = new File(it)
-						candidate.name.matches("org.springframework.*") ||
-						candidate.name.matches("spring-.*") }) { match ->
-					match.eachDirRecurse { subdir ->
-						if (subdir.path ==~ '.*/src/main/java$') {
-							dirset(dir: subdir.path, includes: "org/**")
-						}
-					}
-				}
-			}
-		}
-	}
-}
@@ -1,506 +0,0 @@
-		  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Lesser General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public
-    License along with this library; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
-
-
@@ -1,9 +0,0 @@
-/**
- * This class is used only as a "null" argument for Javadoc when comparing
- * two API files. Javadoc has to have a package, .java or .class file as an
- * argument, even though JDiff doesn't use it.
- */
-public class Null {
-    public Null() {
-    }
-}
@@ -1,6 +0,0 @@
-This distribution of JDiff 1.1.1 is included in the Spring Framework build
-because JDiff has a hard requirement on a JDIFF_HOME directory containing
-jdiff.jar and xerces.jar as well as other presentation resources.
-
-The actual generation of JDiff reports is driven by the `jdiff` task declared
-in build.gradle in the project root.
@@ -1,59 +0,0 @@
-
-                           JDiff Doclet
-                           ------------
-
-                           Matthew Doar
-                          mdoar@pobox.com
-
-
-The JDiff doclet is used to generate a report describing the
-difference between two public Java APIs. 
-
-The file jdiff.html contains the reference page for JDiff.  The latest
-version of JDiff can be downloaded at:
-https://sourceforge.net/projects/javadiff
-
-To use the Ant task on your own project, see example.xml. More examples
-of using JDiff to compare the public APIs of J2SE1.3 and J2SE1.4 can
-be seen at http://www.jdiff.org
-
-For an example with the source distribution, run "ant" and
-look at the HTML output in ./build/reports/example/changes.html 
-The page at ./build/reports/example/changes/com.acme.sp.SPImpl.html
-shows what a typical page of changes looks like. 
-
-System Requirements
-------------------
-
-JDiff has been tested with all releases of Java since J2SE1.2 but
-releases of JDiff after 1.10.0 focus on JDK1.5.
-
-License
-------
-
-JDiff is licensed under the Lesser GNU General Public License (LGPL).
-See the file LICENSE.txt.
-
-Acknowledgements
----------------
-
-JDiff uses Stuart D. Gathman's Java translation of Gene Myers' O(ND) 
-difference algorithm.
-
-JDiff uses Xerces 1.4.2 from https://www.apache.org.
-
-JDiff also includes a script to use the classdoc application from
-http://classdoc.sourceforge.net or http://www.jensgulden.de, by Jens
-Gulden, (mail@jensgulden.de), to call a doclet such as jdiff on a .jar
-file rather than on source.
-
-Many thanks to the reviewers at Sun and Vitria who gave feedback on early
-versions of JDiff output, and also to the distillers of Laphroaig, and to
-Arturo Fuente for his consistently fine cigars which helped inspire
-much of this work.
-
-
-Footnote:
-
-If you are looking for a generalized diff tool for XML, try diffmk from
-https://wwws.sun.com/software/xml/developers/diffmk/
@@ -1,60 +0,0 @@
-apply plugin: "propdeps-maven"
-
-install {
-	repositories.mavenInstaller {
-		customizePom(pom, project)
-	}
-}
-
-def customizePom(pom, gradleProject) {
-	pom.whenConfigured { generatedPom ->
-		// eliminate test-scoped dependencies (no need in maven central poms)
-		generatedPom.dependencies.removeAll { dep ->
-			dep.scope == "test"
-		}
-
-		// sort to make pom dependencies order consistent to ease comparison of older poms
-		generatedPom.dependencies = generatedPom.dependencies.sort { dep ->
-			"$dep.scope:$dep.groupId:$dep.artifactId"
-		}
-
-		def managedVersions = dependencyManagement.managedVersions
-		generatedPom.dependencies.findAll{dep -> !dep.version }.each { dep ->
-			dep.version = managedVersions["${dep.groupId}:${dep.artifactId}"]
-		}
-
-		// add all items necessary for maven central publication
-		generatedPom.project {
-			name = gradleProject.description
-			description = gradleProject.description
-			url = "https://github.com/spring-projects/spring-framework"
-			organization {
-				name = "Spring IO"
-				url = "https://projects.spring.io/spring-framework"
-			}
-			licenses {
-				license {
-					name "Apache License, Version 2.0"
-					url "https://www.apache.org/licenses/LICENSE-2.0"
-					distribution "repo"
-				}
-			}
-			scm {
-				url = "https://github.com/spring-projects/spring-framework"
-				connection = "scm:git:git://github.com/spring-projects/spring-framework"
-				developerConnection = "scm:git:git://github.com/spring-projects/spring-framework"
-			}
-			developers {
-				developer {
-					id = "jhoeller"
-					name = "Juergen Hoeller"
-					email = "jhoeller@pivotal.io"
-				}
-			}
-			issueManagement {
-				system = "Jira"
-				url = "https://jira.springsource.org/browse/SPR"
-			}
-		}
-	}
-}
@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4.1-bin.zip
@@ -1,173 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-GRADLE_OPTS="-XX:MaxMetaspaceSize=1024m -Xmx1024m $GRADLE_OPTS"
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
@@ -1,85 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set GRADLE_OPTS=-XX:MaxMetaspaceSize=1024m -Xmx1024m -XX:MaxHeapSize=256m %GRADLE_OPTS%
-set DEFAULT_JVM_OPTS=
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
@@ -1,122 +0,0 @@
-@echo off
-
-set CURRENT_DIR=%~dp0
-cd %CURRENT_DIR%
-
-cls
-
-echo.
-echo -----------------------------------------------------------------------
-echo Spring Framework - Eclipse/STS project import guide
-echo.
-echo This script will guide you through the process of importing the Spring
-echo Framework projects into Eclipse or the Spring Tool Suite (STS). It is
-echo recommended that you have a recent version of Eclipse or STS. As a bare
-echo minimum you will need Eclipse with full Java 8 support, the AspectJ
-echo Development Tools (AJDT), and the Groovy Compiler.
-echo.
-echo If you need to download and install Eclipse or STS, please do that now
-echo by visiting one of the following sites:
-echo.
-echo - Eclipse downloads: https://download.eclipse.org/eclipse/downloads
-echo - STS downloads: https://spring.io/tools/sts/all
-echo - STS nightly builds: https://dist.springsource.com/snapshot/STS/nightly-distributions.html
-echo - ADJT: https://www.eclipse.org/ajdt/downloads/
-echo - Groovy Eclipse: https://github.com/groovy/groovy-eclipse/wiki
-echo.
-echo Otherwise, press enter and we'll begin.
-
-pause
-
-REM this command:
-REM - wipes out any existing Eclipse metadata
-REM - generates OXM test classes to avoid errors on import into Eclipse
-REM - generates metadata for all subprojects
-REM - skips metadata gen for the root project (-x :eclipse) to work
-REM   around Eclipse's inability to import hierarchical project structures
-REM SET COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
-SET COMMAND=gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse
-
-echo.
-echo -----------------------------------------------------------------------
-echo STEP 1: Generate subproject Eclipse metadata
-echo. 
-echo The first step will be to generate Eclipse project metadata for each
-echo of the spring-* subprojects. This happens via the built-in
-echo "Gradle wrapper" script (./gradlew in this directory). If this is your
-echo first time using the Gradle wrapper, this step may take a few minutes
-echo while a Gradle distribution is downloaded for you.
-echo. 
-echo The command run will be:
-echo. 
-echo     %COMMAND%
-echo. 
-echo Press enter when ready.
-
-pause
-
-call %COMMAND%
-if not "%ERRORLEVEL%" == "0" exit /B %ERRORLEVEL%
-
-echo.
-echo -----------------------------------------------------------------------
-echo STEP 2: Import subprojects into Eclipse/STS
-echo.
-echo Within Eclipse/STS, do the following:
-echo. 
-echo File ^> Import... ^> Existing Projects into Workspace
-echo      ^> When prompted for the 'root directory', provide %CURRENT_DIR%
-echo      ^> Press enter. You will see the modules show up under "Projects"
-echo      ^> All projects should be selected/checked. Click Finish.
-echo      ^> When the project import is complete, you should have no errors.
-echo.
-echo When the above is complete, return here and press the enter key.
-
-pause
-
-set COMMAND=gradlew --no-daemon :eclipse
-
-echo.
-echo -----------------------------------------------------------------------
-echo STEP 3: generate root project Eclipse metadata
-echo. 
-echo Unfortunately, Eclipse does not allow for importing project
-echo hierarchies, so we had to skip root project metadata generation in the
-echo during step 1. In this step we simply generate root project metadata
-echo so you can import it in the next step.
-echo. 
-echo The command run will be:
-echo. 
-echo     %COMMAND%
-echo. 
-echo Press the enter key when ready.
-pause
-
-call %COMMAND%
-if not "%ERRORLEVEL%" == "0" exit /B %ERRORLEVEL%
-
-echo.
-echo -----------------------------------------------------------------------
-echo STEP 4: Import root project into Eclipse/STS
-echo. 
-echo Follow the project import steps listed in step 2 above to import the
-echo root project.
-echo. 
-echo Press enter when complete, and move on to the final step.
-
-pause
-
-echo.
-echo -----------------------------------------------------------------------
-echo STEP 5: Enable Git support for all projects
-echo. 
-echo - In the Eclipse/STS Package Explorer, select all spring* projects.
-echo - Right-click to open the context menu and select Team ^> Share Project...
-echo - In the Share Project dialog that appears, select Git and press Next
-echo - Check "Use or create repository in parent folder of project"
-echo - Click Finish
-echo. 
-echo When complete, you'll have Git support enabled for all projects.
-echo. 
-echo You're ready to code! Goodbye!
-
@@ -1,129 +0,0 @@
-cd `dirname $0`
-clear
-cat <<EOM
-
------------------------------------------------------------------------
-Spring Framework - Eclipse/STS Project Import Guide
-
-This script will guide you through the process of importing the Spring
-Framework projects into Eclipse or the Spring Tool Suite (STS). It is
-recommended that you have a recent version of Eclipse or STS. As a bare
-minimum you will need Eclipse with full Java 8 support, the AspectJ
-Development Tools (AJDT), and the Groovy Compiler.
-
-This script has been tested against:
-
- STS:     3.8.3.RELEASE (Eclipse Neon.2 4.6.2)
- AJDT:    2.2.4.201612122115 (Eclipse Neon 4.6)
-
-If you need to download and install Eclipse or STS, please do that now
-by visiting one of the following sites:
-
- Eclipse downloads: https://download.eclipse.org/eclipse/downloads
- STS downloads: https://spring.io/tools/sts/all
- STS nightly builds: https://dist.springsource.com/snapshot/STS/nightly-distributions.html
- ADJT: https://www.eclipse.org/ajdt/downloads/
- Groovy Eclipse: https://github.com/groovy/groovy-eclipse/wiki
-
-Once Eclipse/STS is installed, press enter, and we'll begin.
-EOM
-
-read
-
-# this command:
-# - wipes out any existing Eclipse metadata
-# - generates OXM test classes to avoid errors on import into Eclipse
-# - generates metadata for all subprojects
-# - skips metadata gen for the root project (-x :eclipse) to work
-#   around Eclipse's inability to import hierarchical project structures
-COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
-
-cat <<EOM
-
------------------------------------------------------------------------
-STEP 1: Generate subproject Eclipse metadata
-
-The first step will be to generate Eclipse project metadata for each of
-the spring-* subprojects. This happens via the built-in "Gradle wrapper"
-script (./gradlew in this directory). If this is your first time using
-the Gradle wrapper, this step may take a few minutes while a Gradle
-distribution is downloaded for you.
-
-The command run will be:
-
-    $COMMAND
-
-Press enter when ready.
-EOM
-
-read
-
-$COMMAND || exit
-
-cat <<EOM
-
------------------------------------------------------------------------
-STEP 2: Import subprojects into Eclipse/STS
-
-Within Eclipse/STS, do the following:
-
- File > Import... > Existing Projects into Workspace
- When prompted for the 'root directory', provide $PWD.
- Press enter. You will see the modules show up under "Projects".
- All projects should be selected/checked. Click Finish.
- When the project import is complete, you should have no errors.
-
-When the above is complete, return here and press the enter key.
-EOM
-
-read
-
-COMMAND="./gradlew --no-daemon :eclipse"
-
-cat <<EOM
-
------------------------------------------------------------------------
-STEP 3: Generate root project Eclipse metadata
-
-Unfortunately, Eclipse does not support importing project hierarchies,
-so we had to skip root project metadata generation during step 1. In
-this step we simply generate root project metadata so that you can
-import it in the next step.
-
-The command run will be:
-
-    $COMMAND
-
-Press the enter key when ready.
-EOM
-
-read
-
-$COMMAND || exit
-
-cat <<EOM
------------------------------------------------------------------------
-STEP 4: Import root project into Eclipse/STS
-
-Follow the project import steps listed in step 2 above to import the
-root "spring" project.
-
-Press enter when complete, and move on to the final step.
-EOM
-
-read
-
-cat <<EOM
------------------------------------------------------------------------
-STEP 5: Enable Git support for all projects
-
- In the Eclipse/STS Package Explorer, select all spring* projects.
- Right-click to open the context menu and select Team > Share Project...
- In the Share Project dialog that appears, select Git and press Next.
- Check "Use or create repository in parent folder of project".
- Click Finish.
-
-When complete, you'll have Git support enabled for all projects.
-
-You're ready to code! Goodbye!
-EOM
@@ -1,36 +0,0 @@
-The following has been tested against IntelliJ IDEA 2016.2.2
-
-## Steps
-
-_Within your locally cloned spring-framework working directory:_
-
-1. Precompile `spring-oxm` with `./gradlew :spring-oxm:compileTestJava`
-2. Import into IntelliJ (File -> New -> Project from Existing Sources -> Navigate to directory -> Select build.gradle)
-3. When prompted exclude the `spring-aspects` module (or after the import via File-> Project Structure -> Modules)
-4. Code away
-
-## Known issues
-
-1. `spring-core` and `spring-oxm` should be pre-compiled due to repackaged dependencies.
-See `*RepackJar` tasks in the build and https://youtrack.jetbrains.com/issue/IDEA-160605).
-2. `spring-aspects` does not compile due to references to aspect types unknown to
-IntelliJ IDEA. See https://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the
-'spring-aspects' can be excluded from the project to avoid compilation errors.
-3. While JUnit tests pass from the command line with Gradle, some may fail when run from
-IntelliJ IDEA. Resolving this is a work in progress. If attempting to run all JUnit tests from within
-IntelliJ IDEA, you will likely need to set the following VM options to avoid out of memory errors:
-    -XX:MaxPermSize=2048m -Xmx2048m -XX:MaxHeapSize=2048m
-4. If you invoke "Rebuild Project" in the IDE, you'll have to generate some test
-resources of the `spring-oxm` module again (`./gradlew :spring-oxm:compileTestJava`)    
-
-
-## Tips
-
-In any case, please do not check in your own generated .iml, .ipr, or .iws files.
-You'll notice these files are already intentionally in .gitignore. The same policy goes for eclipse metadata.
-
-## FAQ
-
-Q. What about IntelliJ IDEA's own [Gradle support](https://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
-
-A. Keep an eye on https://youtrack.jetbrains.com/issue/IDEA-53476
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" path="src/main/resources"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/resources"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.beans"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/org.springframework.core"/>
+	<classpathentry kind="var" path="IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-2.4.0.jar" sourcepath="/IVY_CACHE/com.jamonapi/com.springsource.com.jamonapi/2.4.0/com.springsource.com.jamonapi-sources-2.4.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.2.0/com.springsource.net.sf.cglib-2.2.0.jar" sourcepath="/IVY_CACHE/net.sourceforge.cglib/com.springsource.net.sf.cglib/2.1.3/com.springsource.net.sf.cglib-sources-2.1.3.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-1.0.0.jar" sourcepath="/IVY_CACHE/org.aopalliance/com.springsource.org.aopalliance/1.0.0/com.springsource.org.aopalliance-sources-1.0.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-1.1.1.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.logging/1.1.1/com.springsource.org.apache.commons.logging-sources-1.1.1.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-1.3.0.jar" sourcepath="/IVY_CACHE/org.apache.commons/com.springsource.org.apache.commons.pool/1.3.0/com.springsource.org.apache.commons.pool-sources-1.3.0.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-1.2.15.jar" sourcepath="/IVY_CACHE/org.apache.log4j/com.springsource.org.apache.log4j/1.2.15/com.springsource.org.apache.log4j-sources-1.2.15.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.aspectj/com.springsource.org.aspectj.weaver/1.6.8.RELEASE/com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar" sourcepath="IVY_CACHE/org.aspectj/com.springsource.org.aspectj.weaver/1.6.8.RELEASE/com.springsource.org.aspectj.weaver-sources-1.6.8.RELEASE.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.easymock/com.springsource.org.easymock/2.5.1/com.springsource.org.easymock-2.5.1.jar" sourcepath="/IVY_CACHE/org.easymock/com.springsource.org.easymock/2.5.1/com.springsource.org.easymock-sources-2.5.1.jar"/>
+	<classpathentry kind="var" path="IVY_CACHE/org.junit/com.springsource.org.junit/4.9.0/com.springsource.org.junit-4.9.0.jar" sourcepath="/IVY_CACHE/org.junit/com.springsource.org.junit/4.9.0/com.springsource.org.junit-sources-4.9.0.jar"/>
+	<classpathentry kind="lib" path="/org.springframework.asm/target/artifacts/org.springframework.asm.jar" sourcepath="/org.springframework.asm/target/artifacts/org.springframework.asm-sources.jar"/>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.springframework.aop</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
@@ -0,0 +1,268 @@
+#Wed Jul 15 00:01:31 PDT 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=0
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=0
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=insert
+org.eclipse.jdt.core.formatter.comment.line_length=80
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=2
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=2
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=false
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=80
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=false
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=tab
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=true
@@ -0,0 +1,4 @@
+#Fri Dec 12 11:37:26 PST 2008
+eclipse.preferences.version=1
+formatter_profile=org.eclipse.jdt.ui.default.eclipse_profile
+formatter_settings_version=11
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module relativePaths="true" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
+      <sourceFolder url="file://$MODULE_DIR$/src/test/resources" isTestSource="true" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="module" module-name="beans" />
+    <orderEntry type="module" module-name="core" />
+    <orderEntry type="library" name="AOP Alliance" level="project" />
+    <orderEntry type="library" name="AspectJ" level="project" />
+    <orderEntry type="library" name="CGLIB" level="project" />
+    <orderEntry type="library" name="Commons Logging" level="project" />
+    <orderEntry type="library" name="Commons Pool" level="project" />
+    <orderEntry type="library" name="EasyMock" level="project" />
+    <orderEntry type="library" name="Jamon" level="project" />
+    <orderEntry type="library" name="JUnit" level="project" />
+    <orderEntry type="library" name="Log4j" level="project" />
+  </component>
+  <component name="copyright">
+    <Base>
+      <setting name="state" value="2" />
+    </Base>
+  </component>
+</module>
+
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="org.springframework.aop">
+	<property file="${basedir}/../build.properties"/>
+	<property file="${basedir}/../build.versions"/>
+	<import file="${basedir}/../build-spring-framework/package-bundle.xml"/>
+	<import file="${basedir}/../spring-build/standard/default.xml"/>
+</project>
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?xml-stylesheet type="text/xsl" href="http://ivyrep.jayasoft.org/ivy-doc.xsl"?>
+<ivy-module
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:noNamespaceSchemaLocation="http://incubator.apache.org/ivy/schemas/ivy.xsd"
+		version="1.3">
+
+	<info organisation="org.springframework" module="${ant.project.name}">
+		<license name="Apache 2.0" url="http://www.apache.org/licenses/LICENSE-2.0"/>
+	</info>
+
+	<configurations>
+		<include file="${spring.build.dir}/common/default-ivy-configurations.xml"/>
+		<conf name="commons-logging" extends="runtime" description="JARs needed to run with Commons Logging"/>
+		<conf name="aspectj" extends="runtime" description="JARs needed to run with AspectJ"/>
+		<conf name="bytecode-proxy" extends="runtime" description="JARs needed to run with CGLIB bytecode proxies"/>
+		<conf name="jamon" extends="runtime" description="JARs needed to run with JamonAPI"/>
+		<conf name="pooling" extends="runtime" description="JARs needed to run the pooling target source"/>
+	</configurations>
+
+	<publications>
+		<artifact name="${ant.project.name}"/>
+		<artifact name="${ant.project.name}-sources" type="src" ext="jar"/>
+		<artifact name="license" type="license" ext="txt"/>
+		<artifact name="notice" type="notice" ext="txt"/>
+	</publications>
+
+	<dependencies>
+		<dependency org="com.jamonapi" name="com.springsource.com.jamonapi" rev="2.4.0" conf="optional, jamon->compile"/>
+		<dependency org="net.sourceforge.cglib" name="com.springsource.net.sf.cglib" rev="2.2.0" conf="optional, bytecode-proxy->compile"/>
+		<dependency org="org.aopalliance" name="com.springsource.org.aopalliance" rev="1.0.0" conf="compile->compile"/>
+		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.logging" rev="1.1.1" conf="compile, commons-logging->compile"/>
+		<dependency org="org.apache.commons" name="com.springsource.org.apache.commons.pool" rev="1.5.3" conf="optional, pooling->compile"/>
+		<dependency org="org.aspectj" name="com.springsource.org.aspectj.weaver" rev="${aspectj.version}" conf="optional, aspectj->compile"/>
+		<dependency org="org.springframework" name="org.springframework.beans" rev="latest.integration" conf="compile->compile"/>
+		<dependency org="org.springframework" name="org.springframework.core" rev="latest.integration" conf="compile->compile"/>
+		<!-- test dependencies -->
+		<dependency org="org.apache.log4j" name="com.springsource.org.apache.log4j" rev="1.2.15" conf="test->runtime"/>
+		<dependency org="org.easymock" name="com.springsource.org.easymock" rev="2.5.1" conf="test->compile"/>
+		<dependency org="org.junit" name="com.springsource.org.junit" rev="${junit.version}" conf="test->runtime"/>
+		<dependency org="org.springframework" name="org.springframework.asm" rev="latest.integration" conf="test->runtime"/>
+	</dependencies>
+
+</ivy-module>
@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.springframework</groupId>
+  <artifactId>spring-aop</artifactId>
+  <packaging>jar</packaging>
+  <version>3.1.5.BUILD-SNAPSHOT</version>
+  <parent>
+    <groupId>org.springframework</groupId>
+    <artifactId>spring-parent</artifactId>
+    <relativePath>../org.springframework.spring-parent</relativePath>
+    <version>3.1.5.BUILD-SNAPSHOT</version>
+  </parent>
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+  <dependencies>
+    <dependency>
+      <groupId>com.jamonapi</groupId>
+      <artifactId>jamon</artifactId>
+      <version>2.4</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>cglib</groupId>
+      <artifactId>cglib-nodep</artifactId>
+      <version>2.2</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>aopalliance</groupId>
+      <artifactId>aopalliance</artifactId>
+      <version>1.0</version>
+      <scope>compile</scope>
+    </dependency>
+    <!-- common logging dependency is in spring-core -->
+    <dependency>
+      <groupId>commons-pool</groupId>
+      <artifactId>commons-pool</artifactId>
+      <version>1.5.3</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>org.aspectj</groupId>
+      <artifactId>aspectjweaver</artifactId>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-asm</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-beans</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-core</artifactId>
+      <version>${project.version}</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>log4j</groupId>
+      <artifactId>log4j</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.easymock</groupId>
+      <artifactId>easymock</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -18,31 +18,22 @@ package org.springframework.aop;

 import org.aopalliance.aop.Advice;

-/**
+/** 
 * Base interface holding AOP <b>advice</b> (action to take at a joinpoint)
- * and a filter determining the applicability of the advice (such as
+ * and a filter determining the applicability of the advice (such as 
 * a pointcut). <i>This interface is not for use by Spring users, but to
 * allow for commonality in support for different types of advice.</i>
 *
 * <p>Spring AOP is based around <b>around advice</b> delivered via method
- * <b>interception</b>, compliant with the AOP Alliance interception API.
+ * <b>interception</b>, compliant with the AOP Alliance interception API. 
 * The Advisor interface allows support for different types of advice,
 * such as <b>before</b> and <b>after</b> advice, which need not be
 * implemented using interception.
 *
 * @author Rod Johnson
- * @author Juergen Hoeller
 */
 public interface Advisor {

-	/**
-	 * Common placeholder for an empty {@code Advice} to be returned from
-	 * {@link #getAdvice()} if no proper advice has been configured (yet).
-	 * @since 5.0
-	 */
-	Advice EMPTY_ADVICE = new Advice() {};
-
-
 	/**
 	 * Return the advice part of this aspect. An advice may be an
 	 * interceptor, a before advice, a throws advice, etc.
@@ -59,7 +50,7 @@ public interface Advisor {
 	 * (for example, creating a mixin) or shared with all instances of
 	 * the advised class obtained from the same Spring bean factory.
 	 * <p><b>Note that this method is not currently used by the framework.</b>
-	 * Typical Advisor implementations always return {@code true}.
+	 * Typical Advisor implementations always return <code>true</code>.
 	 * Use singleton/prototype bean definitions or appropriate programmatic
 	 * proxy creation to ensure that Advisors have the correct lifecycle model.
 	 * @return whether this advice is associated with a particular target instance
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -18,8 +18,6 @@ package org.springframework.aop;

 import java.lang.reflect.Method;

-import org.springframework.lang.Nullable;
-
 /**
 * After returning advice is invoked only on normal method return, not if an
 * exception is thrown. Such advice can see the return value, but cannot change it.
@@ -35,12 +33,12 @@ public interface AfterReturningAdvice extends AfterAdvice {
 	 * @param returnValue the value returned by the method, if any
 	 * @param method method being invoked
 	 * @param args arguments to the method
-	 * @param target target of the method invocation. May be {@code null}.
+	 * @param target target of the method invocation. May be <code>null</code>.
 	 * @throws Throwable if this object wishes to abort the call.
 	 * Any exception thrown will be returned to the caller if it's
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;

 }
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -25,7 +25,6 @@ import org.springframework.core.NestedRuntimeException;
 * @author Juergen Hoeller
 * @since 2.0
 */
-@SuppressWarnings("serial")
 public class AopInvocationException extends NestedRuntimeException {

 	/**
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -27,7 +27,6 @@ package org.springframework.aop;
 * @see Pointcut
 * @see MethodMatcher
 */
-@FunctionalInterface
 public interface ClassFilter {

 	/**
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -18,7 +18,7 @@ package org.springframework.aop;

 import org.aopalliance.aop.Advice;

-/**
+/** 
 * Subinterface of AOP Alliance Advice that allows additional interfaces
 * to be implemented by an Advice, and available via a proxy using that
 * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
@@ -37,7 +37,7 @@ import org.aopalliance.aop.Advice;
 * @see IntroductionAdvisor
 */
 public interface DynamicIntroductionAdvice extends Advice {
-
+	
 	/**
 	 * Does this introduction advice implement the given interface?
 	 * @param intf the interface to check
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -30,7 +30,7 @@ package org.springframework.aop;
 * @see IntroductionInterceptor
 */
 public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
-
+	
 	/**
 	 * Return the filter determining which target classes this introduction
 	 * should apply to.
@@ -39,7 +39,7 @@ public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
 	 * @return the class filter
 	 */
 	ClassFilter getClassFilter();
-
+	
 	/**
 	 * Can the advised interfaces be implemented by the introduction advice?
 	 * Invoked before adding an IntroductionAdvisor.
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+/**
+ * A specialized type of MethodMatcher that takes into account introductions when
+ * matching methods. If there are no introductions on the target class, a method
+ * matcher may be able to optimize matching more effectively for example.
+ *
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+public interface IntroductionAwareMethodMatcher extends MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches. This may be invoked
+	 * instead of the 2-arg {@link #matches(java.lang.reflect.Method, Class)} method
+	 * if the caller supports the extended IntroductionAwareMethodMatcher interface.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @param hasIntroductions <code>true</code> if the object on whose behalf we are
+	 * asking is the subject on one or more introductions; <code>false</code> otherwise
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class targetClass, boolean hasIntroductions);
+
+}
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -29,11 +29,11 @@ package org.springframework.aop;
 * @since 1.1.1
 */
 public interface IntroductionInfo {
-
+	
 	/**
 	 * Return the additional interfaces introduced by this Advisor or Advice.
 	 * @return the introduced interfaces
 	 */
-	Class<?>[] getInterfaces();
+	Class[] getInterfaces();

 }
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -1,12 +1,12 @@
 /*
- * Copyright 2002-2012 the original author or authors.
- *
+ * Copyright 2002-2005 the original author or authors.
+ * 
 * Licensed 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
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
+ *      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.
@@ -18,8 +18,6 @@ package org.springframework.aop;

 import java.lang.reflect.Method;

-import org.springframework.lang.Nullable;
-
 /**
 * Advice invoked before a method is invoked. Such advices cannot
 * prevent the method call proceeding, unless they throw a Throwable.
@@ -30,17 +28,17 @@ import org.springframework.lang.Nullable;
 * @author Rod Johnson
 */
 public interface MethodBeforeAdvice extends BeforeAdvice {
-
+	
 	/**
 	 * Callback before a given method is invoked.
 	 * @param method method being invoked
 	 * @param args arguments to the method
-	 * @param target target of the method invocation. May be {@code null}.
+	 * @param target target of the method invocation. May be <code>null</code>.
 	 * @throws Throwable if this object wishes to abort the call.
 	 * Any exception thrown will be returned to the caller if it's
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void before(Method method, Object[] args, Object target) throws Throwable;

 }
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+/**
+ * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
+ *
+ * <p>A MethodMatcher may be evaluated <b>statically</b> or at <b>runtime</b> (dynamically).
+ * Static matching involves method and (possibly) method attributes. Dynamic matching
+ * also makes arguments for a particular call available, and any effects of running
+ * previous advice applying to the joinpoint.
+ *
+ * <p>If an implementation returns <code>false</code> from its {@link #isRuntime()}
+ * method, evaluation can be performed statically, and the result will be the same
+ * for all invocations of this method, whatever their arguments. This means that
+ * if the {@link #isRuntime()} method returns <code>false</code>, the 3-arg
+ * {@link #matches(java.lang.reflect.Method, Class, Object[])} method will never be invoked.
+ *
+ * <p>If an implementation returns <code>true</code> from its 2-arg
+ * {@link #matches(java.lang.reflect.Method, Class)} method and its {@link #isRuntime()} method
+ * returns <code>true</code>, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
+ * method will be invoked <i>immediately before each potential execution of the related advice</i>,
+ * to decide whether the advice should run. All previous advice, such as earlier interceptors
+ * in an interceptor chain, will have run, so any state changes they have produced in
+ * parameters or ThreadLocal state will be available at the time of evaluation.
+ *
+ * @author Rod Johnson
+ * @since 11.11.2003
+ * @see Pointcut
+ * @see ClassFilter
+ */
+public interface MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches. If this
+	 * returns <code>false</code> or if the {@link #isRuntime()} method
+	 * returns <code>false</code>, no runtime check (i.e. no.
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call) will be made.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class<?> targetClass);
+
+	/**
+	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
+	 * runtime even if the 2-arg matches method returns <code>true</code>?
+	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
+	 * again before each method invocation,
+	 * @return whether or not a runtime match via the 3-arg
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method
+	 * is required if static matching passed
+	 */
+	boolean isRuntime();
+
+	/**
+	 * Check whether there a runtime (dynamic) match for this method,
+	 * which must have matched statically.
+	 * <p>This method is invoked only if the 2-arg matches method returns
+	 * <code>true</code> for the given method and target class, and if the
+	 * {@link #isRuntime()} method returns <code>true</code>. Invoked
+	 * immediately before potential running of the advice, after any
+	 * advice earlier in the advice chain has run.
+	 * @param method the candidate method
+	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * the candidate class must be taken to be the method's declaring class)
+	 * @param args arguments to the method
+	 * @return whether there's a runtime match
+	 * @see MethodMatcher#matches(Method, Class)
+	 */
+	boolean matches(Method method, Class<?> targetClass, Object[] args);
+
+
+	/**
+	 * Canonical instance that matches all methods.
+	 */
+	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
+
+}
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -34,13 +34,13 @@ public interface Pointcut {

 	/**
 	 * Return the ClassFilter for this pointcut.
-	 * @return the ClassFilter (never {@code null})
+	 * @return the ClassFilter (never <code>null</code>)
 	 */
 	ClassFilter getClassFilter();

 	/**
 	 * Return the MethodMatcher for this pointcut.
-	 * @return the MethodMatcher (never {@code null})
+	 * @return the MethodMatcher (never <code>null</code>)
 	 */
 	MethodMatcher getMethodMatcher();

@@ -1,12 +1,12 @@
 /*
- * Copyright 2002-2012 the original author or authors.
- *
+ * Copyright 2002-2005 the original author or authors.
+ * 
 * Licensed 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
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
+ * 
+ *      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.
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.intercept.MethodInvocation;
+
+/**
+ * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
+ * interface, allowing access to the proxy that the method invocation was made through.
+ *
+ * <p>Useful to be able to substitute return values with the proxy,
+ * if necessary, for example if the invocation target returned itself.
+ *
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @since 1.1.3
+ * @see org.springframework.aop.framework.ReflectiveMethodInvocation
+ * @see org.springframework.aop.support.DelegatingIntroductionInterceptor
+ */
+public interface ProxyMethodInvocation extends MethodInvocation {
+
+	/**
+	 * Return the proxy that this method invocation was made through.
+	 * @return the original proxy object
+	 */
+	Object getProxy();
+
+	/**
+	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
+	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @return an invocable clone of this invocation.
+	 * <code>proceed()</code> can be called once per clone.
+	 */
+	MethodInvocation invocableClone();
+
+	/**
+	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
+	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @param arguments the arguments that the cloned invocation is supposed to use,
+	 * overriding the original arguments
+	 * @return an invocable clone of this invocation.
+	 * <code>proceed()</code> can be called once per clone.
+	 */
+	MethodInvocation invocableClone(Object[] arguments);
+
+	/**
+	 * Set the arguments to be used on subsequent invocations in the any advice
+	 * in this chain.
+	 * @param arguments the argument array
+	 */
+	void setArguments(Object[] arguments);
+
+	/**
+	 * Add the specified user attribute with the given value to this invocation.
+	 * <p>Such attributes are not used within the AOP framework itself. They are
+	 * just kept as part of the invocation object, for use in special interceptors.
+	 * @param key the name of the attribute
+	 * @param value the value of the attribute, or <code>null</code> to reset it
+	 */
+	void setUserAttribute(String key, Object value);
+
+	/**
+	 * Return the value of the specified user attribute.
+	 * @param key the name of the attribute
+	 * @return the value of the attribute, or <code>null</code> if not set
+	 * @see #setUserAttribute
+	 */
+	Object getUserAttribute(String key);
+
+}
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,13 +16,11 @@

 package org.springframework.aop;

-import org.springframework.lang.Nullable;
-
 /**
 * Minimal interface for exposing the target class behind a proxy.
 *
 * <p>Implemented by AOP proxy objects and proxy factories
- * (via {@link org.springframework.aop.framework.Advised})
+ * (via {@link org.springframework.aop.framework.Advised}}
 * as well as by {@link TargetSource TargetSources}.
 *
 * @author Juergen Hoeller
@@ -34,9 +32,8 @@ public interface TargetClassAware {
 	/**
 	 * Return the target class behind the implementing object
 	 * (typically a proxy configuration or an actual proxy).
-	 * @return the target Class, or {@code null} if not known
+	 * @return the target Class, or <code>null</code> if not known
 	 */
-	@Nullable
 	Class<?> getTargetClass();

 }
@@ -0,0 +1,70 @@
+/*<
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop;
+
+/**
+ * A <code>TargetSource</code> is used to obtain the current "target" of
+ * an AOP invocation, which will be invoked via reflection if no around
+ * advice chooses to end the interceptor chain itself.
+ *
+ * <p>If a <code>TargetSource</code> is "static", it will always return
+ * the same target, allowing optimizations in the AOP framework. Dynamic
+ * target sources can support pooling, hot swapping, etc.
+ *
+ * <p>Application developers don't usually need to work with
+ * <code>TargetSources</code> directly: this is an AOP framework interface.
+ *
+ * @author Rod Johnson
+ */
+public interface TargetSource extends TargetClassAware {
+
+	/**
+	 * Return the type of targets returned by this {@link TargetSource}.
+	 * <p>Can return <code>null</code>, although certain usages of a
+	 * <code>TargetSource</code> might just work with a predetermined
+	 * target class.
+	 * @return the type of targets returned by this {@link TargetSource}
+	 */
+	Class<?> getTargetClass();
+
+	/**
+	 * Will all calls to {@link #getTarget()} return the same object?
+	 * <p>In that case, there will be no need to invoke
+	 * {@link #releaseTarget(Object)}, and the AOP framework can cache
+	 * the return value of {@link #getTarget()}.
+	 * @return <code>true</code> if the target is immutable
+	 * @see #getTarget
+	 */
+	boolean isStatic();
+
+	/**
+	 * Return a target instance. Invoked immediately before the
+	 * AOP framework calls the "target" of an AOP method invocation.
+	 * @return the target object, which contains the joinpoint
+	 * @throws Exception if the target object can't be resolved
+	 */
+	Object getTarget() throws Exception;
+
+	/**
+	 * Release the given target object obtained from the
+	 * {@link #getTarget()} method.
+	 * @param target object obtained from a call to {@link #getTarget()}
+	 * @throws Exception if the object can't be released
+	 */
+	void releaseTarget(Object target) throws Exception;
+
+}
@@ -5,7 +5,7 @@
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -23,26 +23,24 @@ import java.io.Serializable;
 *
 * @author Rod Johnson
 */
-@SuppressWarnings("serial")
 class TrueClassFilter implements ClassFilter, Serializable {
-
+	
 	public static final TrueClassFilter INSTANCE = new TrueClassFilter();
-
+	
 	/**
 	 * Enforce Singleton pattern.
 	 */
 	private TrueClassFilter() {
 	}

-	@Override
-	public boolean matches(Class<?> clazz) {
+	public boolean matches(Class clazz) {
 		return true;
 	}
-
+	
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding {@code equals()}.
+	 * Alternative to overriding <code>equals()</code>.
 	 */
 	private Object readResolve() {
 		return INSTANCE;
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -19,55 +19,46 @@ package org.springframework.aop;
 import java.io.Serializable;
 import java.lang.reflect.Method;

-import org.springframework.lang.Nullable;
-
 /**
 * Canonical MethodMatcher instance that matches all methods.
 *
 * @author Rod Johnson
 */
-@SuppressWarnings("serial")
 class TrueMethodMatcher implements MethodMatcher, Serializable {
-
+	
 	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
-
-
+	
 	/**
 	 * Enforce Singleton pattern.
 	 */
 	private TrueMethodMatcher() {
 	}

-
-	@Override
 	public boolean isRuntime() {
 		return false;
 	}

-	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass) {
+	public boolean matches(Method method, Class targetClass) {
 		return true;
 	}

-	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass, Object... args) {
+	public boolean matches(Method method, Class targetClass, Object[] args) {
 		// Should never be invoked as isRuntime returns false.
 		throw new UnsupportedOperationException();
 	}
-
-
+	
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding <code>equals()</code>.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+	
 	@Override
 	public String toString() {
 		return "MethodMatcher.TRUE";
 	}

-	/**
-	 * Required to support serialization. Replaces with canonical
-	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding {@code equals()}.
-	 */
-	private Object readResolve() {
-		return INSTANCE;
-	}
-
 }
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -23,31 +23,28 @@ import java.io.Serializable;
 *
 * @author Rod Johnson
 */
-@SuppressWarnings("serial")
 class TruePointcut implements Pointcut, Serializable {
-
+	
 	public static final TruePointcut INSTANCE = new TruePointcut();
-
+	
 	/**
 	 * Enforce Singleton pattern.
 	 */
 	private TruePointcut() {
 	}

-	@Override
 	public ClassFilter getClassFilter() {
 		return ClassFilter.TRUE;
 	}

-	@Override
 	public MethodMatcher getMethodMatcher() {
 		return MethodMatcher.TRUE;
 	}
-
+	
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding {@code equals()}.
+	 * Alternative to overriding <code>equals()</code>.
 	 */
 	private Object readResolve() {
 		return INSTANCE;
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,9 +16,6 @@

 package org.springframework.aop.aspectj;

-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
@@ -40,9 +37,9 @@ import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
 import org.springframework.aop.support.ComposablePointcut;
 import org.springframework.aop.support.MethodMatchers;
 import org.springframework.aop.support.StaticMethodMatcher;
-import org.springframework.core.DefaultParameterNameDiscoverer;
+import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
+import org.springframework.core.PrioritizedParameterNameDiscoverer;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -59,8 +56,7 @@ import org.springframework.util.StringUtils;
 * @author Ramnivas Laddad
 * @since 2.0
 */
-@SuppressWarnings("serial")
-public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {
+public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation {

 	/**
 	 * Key used in ReflectiveMethodInvocation userAtributes map for the current joinpoint.
@@ -91,24 +87,21 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}


-	private final Class<?> declaringClass;
+	protected final Method aspectJAdviceMethod;

-	private final String methodName;
-
-	private final Class<?>[] parameterTypes;
-
-	protected transient Method aspectJAdviceMethod;
+	/** The total number of arguments we have to populate on advice dispatch */
+	private final int adviceInvocationArgumentCount;

 	private final AspectJExpressionPointcut pointcut;

 	private final AspectInstanceFactory aspectInstanceFactory;

 	/**
-	 * The name of the aspect (ref bean) in which this advice was defined
-	 * (used when determining advice precedence so that we can determine
+	 * The name of the aspect (ref bean) in which this advice was defined (used
+	 * when determining advice precedence so that we can determine
 	 * whether two pieces of advice come from the same aspect).
 	 */
-	private String aspectName = "";
+	private String aspectName;

 	/**
 	 * The order of declaration of this advice within the aspect.
@@ -119,20 +112,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * This will be non-null if the creator of this advice object knows the argument names
 	 * and sets them explicitly
 	 */
-	@Nullable
-	private String[] argumentNames;
+	private String[] argumentNames = null;

 	/** Non-null if after throwing advice binds the thrown value */
-	@Nullable
-	private String throwingName;
+	private String throwingName = null;

 	/** Non-null if after returning advice binds the return value */
-	@Nullable
-	private String returningName;
+	private String returningName = null;

-	private Class<?> discoveredReturningType = Object.class;
+	private Class discoveredReturningType = Object.class;

-	private Class<?> discoveredThrowingType = Object.class;
+	private Class discoveredThrowingType = Object.class;

 	/**
 	 * Index for thisJoinPoint argument (currently only
@@ -146,12 +136,10 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 */
 	private int joinPointStaticPartArgumentIndex = -1;

-	@Nullable
-	private Map<String, Integer> argumentBindings;
+	private Map<String, Integer> argumentBindings = null;

 	private boolean argumentsIntrospected = false;

-	@Nullable
 	private Type discoveredReturningGenericType;
 	// Note: Unlike return type, no such generic information is needed for the throwing type,
 	// since Java doesn't allow exception types to be parameterized.
@@ -167,10 +155,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aspectInstanceFactory) {

 		Assert.notNull(aspectJAdviceMethod, "Advice method must not be null");
-		this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
-		this.methodName = aspectJAdviceMethod.getName();
-		this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
 		this.aspectJAdviceMethod = aspectJAdviceMethod;
+		this.adviceInvocationArgumentCount = this.aspectJAdviceMethod.getParameterTypes().length;
 		this.pointcut = pointcut;
 		this.aspectInstanceFactory = aspectInstanceFactory;
 	}
@@ -213,37 +199,30 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Return the ClassLoader for aspect instances.
 	 */
-	@Nullable
 	public final ClassLoader getAspectClassLoader() {
 		return this.aspectInstanceFactory.getAspectClassLoader();
 	}

-	@Override
 	public int getOrder() {
 		return this.aspectInstanceFactory.getOrder();
 	}


-	/**
-	 * Set the name of the aspect (bean) in which the advice was declared.
-	 */
 	public void setAspectName(String name) {
 		this.aspectName = name;
 	}
-
-	@Override
+	
 	public String getAspectName() {
 		return this.aspectName;
 	}

 	/**
-	 * Set the declaration order of this advice within the aspect.
+	 * Sets the <b>declaration order</b> of this advice within the aspect
 	 */
 	public void setDeclarationOrder(int order) {
 		this.declarationOrder = order;
 	}

-	@Override
 	public int getDeclarationOrder() {
 		return this.declarationOrder;
 	}
@@ -259,7 +238,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		setArgumentNamesFromStringArray(tokens);
 	}

-	public void setArgumentNamesFromStringArray(String... args) {
+	public void setArgumentNamesFromStringArray(String[] args) {
 		this.argumentNames = new String[args.length];
 		for (int i = 0; i < args.length; i++) {
 			this.argumentNames[i] = StringUtils.trimWhitespace(args[i]);
@@ -269,17 +248,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 						this.argumentNames[i] + "' that is not a valid Java identifier");
 			}
 		}
-		if (this.argumentNames != null) {
-			if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
+		if (argumentNames != null) {
+			if (aspectJAdviceMethod.getParameterTypes().length == argumentNames.length + 1) {
 				// May need to add implicit join point arg name...
-				Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
+				Class firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
 				if (firstArgType == JoinPoint.class ||
 						firstArgType == ProceedingJoinPoint.class ||
 						firstArgType == JoinPoint.StaticPart.class) {
-					String[] oldNames = this.argumentNames;
-					this.argumentNames = new String[oldNames.length + 1];
-					this.argumentNames[0] = "THIS_JOIN_POINT";
-					System.arraycopy(oldNames, 0, this.argumentNames, 1, oldNames.length);
+					String[] oldNames = argumentNames;
+					argumentNames = new String[oldNames.length + 1];
+					argumentNames[0] = "THIS_JOIN_POINT";
+					System.arraycopy(oldNames, 0, argumentNames, 1, oldNames.length);
 				}
 			}
 		}
@@ -289,7 +268,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		throw new UnsupportedOperationException("Only afterReturning advice can be used to bind a return value");
 	}

-	/**
+	/** 
 	 * We need to hold the returning name at this level for argument binding calculations,
 	 * this method allows the afterReturning advice subclass to set the name.
 	 */
@@ -305,17 +284,16 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Returning name '" + name  +
-						"' is neither a valid argument name nor the fully-qualified " +
-						"name of a Java type on the classpath. Root cause: " + ex);
+						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
+						"Root cause: " + ex);
 			}
 		}
 	}

-	protected Class<?> getDiscoveredReturningType() {
+	protected Class getDiscoveredReturningType() {
 		return this.discoveredReturningType;
 	}

-	@Nullable
 	protected Type getDiscoveredReturningGenericType() {
 		return this.discoveredReturningGenericType;
 	}
@@ -324,7 +302,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		throw new UnsupportedOperationException("Only afterThrowing advice can be used to bind a thrown exception");
 	}

-	/**
+	/** 
 	 * We need to hold the throwing name at this level for argument binding calculations,
 	 * this method allows the afterThrowing advice subclass to set the name.
 	 */
@@ -340,13 +318,13 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Throwing name '" + name  +
-						"' is neither a valid argument name nor the fully-qualified " +
-						"name of a Java type on the classpath. Root cause: " + ex);
+						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
+						"Root cause: " + ex);
 			}
 		}
 	}

-	protected Class<?> getDiscoveredThrowingType() {
+	protected Class getDiscoveredThrowingType() {
 		return this.discoveredThrowingType;
 	}

@@ -369,27 +347,29 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * on subsequent advice invocations can be as fast as possible.
 	 * <p>If the first argument is of type JoinPoint or ProceedingJoinPoint then we
 	 * pass a JoinPoint in that position (ProceedingJoinPoint for around advice).
-	 * <p>If the first argument is of type {@code JoinPoint.StaticPart}
-	 * then we pass a {@code JoinPoint.StaticPart} in that position.
+	 * <p>If the first argument is of type <code>JoinPoint.StaticPart</code>
+	 * then we pass a <code>JoinPoint.StaticPart</code> in that position.
 	 * <p>Remaining arguments have to be bound by pointcut evaluation at
 	 * a given join point. We will get back a map from argument name to
 	 * value. We need to calculate which advice parameter needs to be bound
 	 * to which argument name. There are multiple strategies for determining
 	 * this binding, which are arranged in a ChainOfResponsibility.
 	 */
-	public final synchronized void calculateArgumentBindings() {
+	public synchronized final void calculateArgumentBindings() {
 		// The simple case... nothing to bind.
-		if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
+		if (this.argumentsIntrospected || this.adviceInvocationArgumentCount == 0) {
 			return;
 		}

-		int numUnboundArgs = this.parameterTypes.length;
-		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
-		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0]) ||
-				maybeBindJoinPointStaticPart(parameterTypes[0])) {
+		int numUnboundArgs = this.adviceInvocationArgumentCount;
+		Class[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
+			numUnboundArgs--;
+		} 
+		else if (maybeBindJoinPointStaticPart(parameterTypes[0])) {
 			numUnboundArgs--;
 		}
-
+			
 		if (numUnboundArgs > 0) {
 			// need to bind arguments by name as returned from the pointcut match
 			bindArgumentsByName(numUnboundArgs);
@@ -398,8 +378,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		this.argumentsIntrospected = true;
 	}

-	private boolean maybeBindJoinPoint(Class<?> candidateParameterType) {
-		if (JoinPoint.class == candidateParameterType) {
+	private boolean maybeBindJoinPoint(Class candidateParameterType) {
+		if (candidateParameterType.equals(JoinPoint.class)) {
 			this.joinPointArgumentIndex = 0;
 			return true;
 		}
@@ -408,8 +388,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}

-	private boolean maybeBindProceedingJoinPoint(Class<?> candidateParameterType) {
-		if (ProceedingJoinPoint.class == candidateParameterType) {
+	private boolean maybeBindProceedingJoinPoint(Class candidateParameterType) {
+		if (candidateParameterType.equals(ProceedingJoinPoint.class)) {
 			if (!supportsProceedingJoinPoint()) {
 				throw new IllegalArgumentException("ProceedingJoinPoint is only supported for around advice");
 			}
@@ -418,18 +398,18 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		else {
 			return false;
-		}
+		}		
 	}

 	protected boolean supportsProceedingJoinPoint() {
 		return false;
 	}

-	private boolean maybeBindJoinPointStaticPart(Class<?> candidateParameterType) {
-		if (JoinPoint.StaticPart.class == candidateParameterType) {
+	private boolean maybeBindJoinPointStaticPart(Class candidateParameterType) {
+		if (candidateParameterType.equals(JoinPoint.StaticPart.class)) {
 			this.joinPointStaticPartArgumentIndex = 0;
 			return true;
-		}
+		} 
 		else {
 			return false;
 		}
@@ -442,7 +422,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.argumentNames != null) {
 			// We have been able to determine the arg names.
 			bindExplicitArguments(numArgumentsExpectingToBind);
-		}
+		} 
 		else {
 			throw new IllegalStateException("Advice method [" + this.aspectJAdviceMethod.getName() + "] " +
 					"requires " + numArgumentsExpectingToBind + " arguments to be bound by name, but " +
@@ -452,13 +432,15 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence

 	/**
 	 * Create a ParameterNameDiscoverer to be used for argument binding.
-	 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
-	 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
+	 * <p>The default implementation creates a {@link PrioritizedParameterNameDiscoverer}
+	 * containing a {@link LocalVariableTableParameterNameDiscoverer} and an
+	 * {@link AspectJAdviceParameterNameDiscoverer}.
 	 */
 	protected ParameterNameDiscoverer createParameterNameDiscoverer() {
 		// We need to discover them, or if that fails, guess,
 		// and if we can't guess with 100% accuracy, fail.
-		DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
+		PrioritizedParameterNameDiscoverer discoverer = new PrioritizedParameterNameDiscoverer();
+		discoverer.addDiscoverer(new LocalVariableTableParameterNameDiscoverer());
 		AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
 				new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
 		adviceParameterNameDiscoverer.setReturningName(this.returningName);
@@ -470,18 +452,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}

 	private void bindExplicitArguments(int numArgumentsLeftToBind) {
-		Assert.state(this.argumentNames != null, "No argument names available");
-		this.argumentBindings = new HashMap<>();
+		this.argumentBindings = new HashMap<String, Integer>();

-		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
+		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterTypes().length;
 		if (this.argumentNames.length != numExpectedArgumentNames) {
-			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
-					" arguments to bind by name in advice, but actually found " +
+			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames
+					+ " arguments to bind by name in advice, but actually found " +
 					this.argumentNames.length + " arguments.");
 		}

 		// So we match in number...
-		int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
+		int argumentIndexOffset = this.adviceInvocationArgumentCount - numArgumentsLeftToBind;
 		for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
 			this.argumentBindings.put(this.argumentNames[i], i);
 		}
@@ -490,9 +471,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		// specified, and find the discovered argument types.
 		if (this.returningName != null) {
 			if (!this.argumentBindings.containsKey(this.returningName)) {
-				throw new IllegalStateException("Returning argument name '" + this.returningName +
-						"' was not bound in advice arguments");
-			}
+				throw new IllegalStateException("Returning argument name '" 
+						+ this.returningName + "' was not bound in advice arguments");
+			} 
 			else {
 				Integer index = this.argumentBindings.get(this.returningName);
 				this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
@@ -501,9 +482,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		if (this.throwingName != null) {
 			if (!this.argumentBindings.containsKey(this.throwingName)) {
-				throw new IllegalStateException("Throwing argument name '" + this.throwingName +
-						"' was not bound in advice arguments");
-			}
+				throw new IllegalStateException("Throwing argument name '" 
+						+ this.throwingName + "' was not bound in advice arguments");
+			} 
 			else {
 				Integer index = this.argumentBindings.get(this.throwingName);
 				this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
@@ -511,7 +492,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}

 		// configure the pointcut expression accordingly.
-		configurePointcutParameters(this.argumentNames, argumentIndexOffset);
+		configurePointcutParameters(argumentIndexOffset);
 	}

 	/**
@@ -519,7 +500,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * pointcut parameters - but returning and throwing vars are handled differently
 	 * and must be removed from the list if present.
 	 */
-	private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
+	private void configurePointcutParameters(int argumentIndexOffset) {
 		int numParametersToRemove = argumentIndexOffset;
 		if (this.returningName != null) {
 			numParametersToRemove++;
@@ -527,24 +508,24 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.throwingName != null) {
 			numParametersToRemove++;
 		}
-		String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
-		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
-		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
+		Class[] pointcutParameterTypes = new Class[pointcutParameterNames.length];
+		Class[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();

 		int index = 0;
-		for (int i = 0; i < argumentNames.length; i++) {
+		for (int i = 0; i < this.argumentNames.length; i++) {
 			if (i < argumentIndexOffset) {
 				continue;
 			}
-			if (argumentNames[i].equals(this.returningName) ||
-				argumentNames[i].equals(this.throwingName)) {
+			if (this.argumentNames[i].equals(this.returningName) ||
+				this.argumentNames[i].equals(this.throwingName)) {
 				continue;
 			}
-			pointcutParameterNames[index] = argumentNames[i];
+			pointcutParameterNames[index] = this.argumentNames[i];
 			pointcutParameterTypes[index] = methodParameterTypes[i];
 			index++;
 		}
-
+		
 		this.pointcut.setParameterNames(pointcutParameterNames);
 		this.pointcut.setParameterTypes(pointcutParameterTypes);
 	}
@@ -558,19 +539,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * @param ex the exception thrown by the method execution (may be null)
 	 * @return the empty array if there are no arguments
 	 */
-	protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable ex) {
-
+	protected Object[] argBinding(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable ex) {
 		calculateArgumentBindings();

 		// AMC start
-		Object[] adviceInvocationArgs = new Object[this.parameterTypes.length];
+		Object[] adviceInvocationArgs = new Object[this.adviceInvocationArgumentCount];
 		int numBound = 0;

 		if (this.joinPointArgumentIndex != -1) {
 			adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
 			numBound++;
-		}
+		} 
 		else if (this.joinPointStaticPartArgumentIndex != -1) {
 			adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
 			numBound++;
@@ -601,10 +580,11 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 		}

-		if (numBound != this.parameterTypes.length) {
-			throw new IllegalStateException("Required to bind " + this.parameterTypes.length +
-					" arguments, but only bound " + numBound + " (JoinPointMatch " +
-					(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
+		if (numBound != this.adviceInvocationArgumentCount) {
+			throw new IllegalStateException("Required to bind " + this.adviceInvocationArgumentCount
+					+ " arguments, but only bound " + numBound + " (JoinPointMatch " + 
+					(jpMatch == null ? "was NOT" : "WAS") + 
+					" bound in invocation)");
 		}

 		return adviceInvocationArgs;
@@ -619,23 +599,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * @return the invocation result
 	 * @throws Throwable in case of invocation failure
 	 */
-	protected Object invokeAdviceMethod(
-			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
-			throws Throwable {
-
+	protected Object invokeAdviceMethod(JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable {
 		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
 	}

 	// As above, but in this case we are given the join point.
-	protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable t) throws Throwable {
+	protected Object invokeAdviceMethod(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable t)
+			throws Throwable {

 		return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
 	}

 	protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
 		Object[] actualArgs = args;
-		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
+		if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
 			actualArgs = null;
 		}
 		try {
@@ -663,7 +640,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Get the current join point match at the join point we are being dispatched on.
 	 */
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch() {
 		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
 		if (!(mi instanceof ProxyMethodInvocation)) {
@@ -678,10 +654,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	// 'last man wins' which is not what we want at all.
 	// Using the expression is guaranteed to be safe, since 2 identical expressions
 	// are guaranteed to bind in exactly the same way.
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch(ProxyMethodInvocation pmi) {
-		String expression = this.pointcut.getExpression();
-		return (expression != null ? (JoinPointMatch) pmi.getUserAttribute(expression) : null);
+		return (JoinPointMatch) pmi.getUserAttribute(this.pointcut.getExpression());
 	}


@@ -691,16 +665,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 				"aspect name '" + this.aspectName + "'";
 	}

-	private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
-		inputStream.defaultReadObject();
-		try {
-			this.aspectJAdviceMethod = this.declaringClass.getMethod(this.methodName, this.parameterTypes);
-		}
-		catch (NoSuchMethodException ex) {
-			throw new IllegalStateException("Failed to find advice method on deserialization", ex);
-		}
-	}
-

 	/**
 	 * MethodMatcher that excludes the specified advice method.
@@ -714,8 +678,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			this.adviceMethod = adviceMethod;
 		}

-		@Override
-		public boolean matches(Method method, @Nullable Class<?> targetClass) {
+		public boolean matches(Method method, Class targetClass) {
 			return !this.adviceMethod.equals(method);
 		}

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -17,7 +17,6 @@
 package org.springframework.aop.aspectj;

 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;

 /**
 * Interface implemented to provide an instance of an AspectJ aspect.
@@ -35,16 +34,14 @@ public interface AspectInstanceFactory extends Ordered {

 	/**
 	 * Create an instance of this factory's aspect.
-	 * @return the aspect instance (never {@code null})
+	 * @return the aspect instance (never <code>null</code>)
 	 */
 	Object getAspectInstance();

 	/**
 	 * Expose the aspect class loader that this factory uses.
-	 * @return the aspect class loader (or {@code null} for the bootstrap loader)
-	 * @see org.springframework.util.ClassUtils#getDefaultClassLoader()
+	 * @return the aspect class loader (never <code>null</code>)
 	 */
-	@Nullable
 	ClassLoader getAspectClassLoader();

 }
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2008 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -21,6 +21,7 @@ import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;

@@ -30,91 +31,89 @@ import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;

 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;

 /**
 * {@link ParameterNameDiscoverer} implementation that tries to deduce parameter names
 * for an advice method from the pointcut expression, returning, and throwing clauses.
- * If an unambiguous interpretation is not available, it returns {@code null}.
+ * If an unambiguous interpretation is not available, it returns <code>null</code>.
 *
 * <p>This class interprets arguments in the following way:
 * <ol>
 * <li>If the first parameter of the method is of type {@link JoinPoint}
 * or {@link ProceedingJoinPoint}, it is assumed to be for passing
- * {@code thisJoinPoint} to the advice, and the parameter name will
- * be assigned the value {@code "thisJoinPoint"}.</li>
+ * <code>thisJoinPoint</code> to the advice, and the parameter name will
+ * be assigned the value <code>"thisJoinPoint"</code>.</li>
 * <li>If the first parameter of the method is of type
- * {@code JoinPoint.StaticPart}, it is assumed to be for passing
- * {@code "thisJoinPointStaticPart"} to the advice, and the parameter name
- * will be assigned the value {@code "thisJoinPointStaticPart"}.</li>
+ * <code>JoinPoint.StaticPart</code>, it is assumed to be for passing
+ * <code>"thisJoinPointStaticPart"</code> to the advice, and the parameter name
+ * will be assigned the value <code>"thisJoinPointStaticPart"</code>.</li>
 * <li>If a {@link #setThrowingName(String) throwingName} has been set, and
- * there are no unbound arguments of type {@code Throwable+}, then an
+ * there are no unbound arguments of type <code>Throwable+</code>, then an
 * {@link IllegalArgumentException} is raised. If there is more than one
- * unbound argument of type {@code Throwable+}, then an
+ * unbound argument of type <code>Throwable+</code>, then an
 * {@link AmbiguousBindingException} is raised. If there is exactly one
- * unbound argument of type {@code Throwable+}, then the corresponding
+ * unbound argument of type <code>Throwable+</code>, then the corresponding
 * parameter name is assigned the value &lt;throwingName&gt;.</li>
 * <li>If there remain unbound arguments, then the pointcut expression is
- * examined. Let {@code a} be the number of annotation-based pointcut
+ * examined. Let <code>a</code> be the number of annotation-based pointcut
 * expressions (&#64;annotation, &#64;this, &#64;target, &#64;args,
 * &#64;within, &#64;withincode) that are used in binding form. Usage in
 * binding form has itself to be deduced: if the expression inside the
 * pointcut is a single string literal that meets Java variable name
- * conventions it is assumed to be a variable name. If {@code a} is
- * zero we proceed to the next stage. If {@code a} &gt; 1 then an
- * {@code AmbiguousBindingException} is raised. If {@code a} == 1,
- * and there are no unbound arguments of type {@code Annotation+},
- * then an {@code IllegalArgumentException} is raised. if there is
+ * conventions it is assumed to be a variable name. If <code>a</code> is
+ * zero we proceed to the next stage. If <code>a</code> &gt; 1 then an
+ * <code>AmbiguousBindingException</code> is raised. If <code>a</code> == 1,
+ * and there are no unbound arguments of type <code>Annotation+</code>,
+ * then an <code>IllegalArgumentException</code> is raised. if there is
 * exactly one such argument, then the corresponding parameter name is
 * assigned the value from the pointcut expression.</li>
 * <li>If a returningName has been set, and there are no unbound arguments
- * then an {@code IllegalArgumentException} is raised. If there is
+ * then an <code>IllegalArgumentException</code> is raised. If there is
 * more than one unbound argument then an
- * {@code AmbiguousBindingException} is raised. If there is exactly
+ * <code>AmbiguousBindingException</code> is raised. If there is exactly
 * one unbound argument then the corresponding parameter name is assigned
 * the value &lt;returningName&gt;.</li>
 * <li>If there remain unbound arguments, then the pointcut expression is
- * examined once more for {@code this}, {@code target}, and
- * {@code args} pointcut expressions used in the binding form (binding
+ * examined once more for <code>this</code>, <code>target</code>, and
+ * <code>args</code> pointcut expressions used in the binding form (binding
 * forms are deduced as described for the annotation based pointcuts). If
 * there remains more than one unbound argument of a primitive type (which
- * can only be bound in {@code args}) then an
- * {@code AmbiguousBindingException} is raised. If there is exactly
- * one argument of a primitive type, then if exactly one {@code args}
+ * can only be bound in <code>args</code>) then an
+ * <code>AmbiguousBindingException</code> is raised. If there is exactly
+ * one argument of a primitive type, then if exactly one <code>args</code>
 * bound variable was found, we assign the corresponding parameter name
- * the variable name. If there were no {@code args} bound variables
- * found an {@code IllegalStateException} is raised. If there are
- * multiple {@code args} bound variables, an
- * {@code AmbiguousBindingException} is raised. At this point, if
+ * the variable name. If there were no <code>args</code> bound variables
+ * found an <code>IllegalStateException</code> is raised. If there are
+ * multiple <code>args</code> bound variables, an
+ * <code>AmbiguousBindingException</code> is raised. At this point, if
 * there remains more than one unbound argument we raise an
- * {@code AmbiguousBindingException}. If there are no unbound arguments
+ * <code>AmbiguousBindingException</code>. If there are no unbound arguments
 * remaining, we are done. If there is exactly one unbound argument
 * remaining, and only one candidate variable name unbound from
- * {@code this}, {@code target}, or {@code args}, it is
+ * <code>this</code>, <code>target</code>, or <code>args</code>, it is
 * assigned as the corresponding parameter name. If there are multiple
- * possibilities, an {@code AmbiguousBindingException} is raised.</li>
+ * possibilities, an <code>AmbiguousBindingException</code> is raised.</li>
 * </ol>
 *
- * <p>The behavior on raising an {@code IllegalArgumentException} or
- * {@code AmbiguousBindingException} is configurable to allow this discoverer
+ * <p>The behavior on raising an <code>IllegalArgumentException</code> or
+ * <code>AmbiguousBindingException</code> is configurable to allow this discoverer
 * to be used as part of a chain-of-responsibility. By default the condition will
- * be logged and the {@code getParameterNames(..)} method will simply return
- * {@code null}. If the {@link #setRaiseExceptions(boolean) raiseExceptions}
- * property is set to {@code true}, the conditions will be thrown as
- * {@code IllegalArgumentException} and {@code AmbiguousBindingException},
+ * be logged and the <code>getParameterNames(..)</code> method will simply return
+ * <code>null</code>. If the {@link #setRaiseExceptions(boolean) raiseExceptions}
+ * property is set to <code>true</code>, the conditions will be thrown as
+ * <code>IllegalArgumentException</code> and <code>AmbiguousBindingException</code>,
 * respectively.
 *
 * <p>Was that perfectly clear? ;)
 *
 * <p>Short version: If an unambiguous binding can be deduced, then it is.
- * If the advice requirements cannot possibly be satisfied, then {@code null}
+ * If the advice requirements cannot possibly be satisfied, then <code>null</code>
 * is returned. By setting the {@link #setRaiseExceptions(boolean) raiseExceptions}
- * property to {@code true}, descriptive exceptions will be thrown instead of
- * returning {@code null} in the case that the parameter names cannot be discovered.
+ * property to <code>true</code>, descriptive exceptions will be thrown instead of
+ * returning <code>null</code> in the case that the parameter names cannot be discovered.
 *
 * @author Adrian Colyer
- * @author Juergen Hoeller
 * @since 2.0
 */
 public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscoverer {
@@ -132,8 +131,8 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	private static final int STEP_REFERENCE_PCUT_BINDING = 7;
 	private static final int STEP_FINISHED = 8;

-	private static final Set<String> singleValuedAnnotationPcds = new HashSet<>();
-	private static final Set<String> nonReferencePointcutTokens = new HashSet<>();
+	private static final Set<String> singleValuedAnnotationPcds = new HashSet<String>();
+	private static final Set<String> nonReferencePointcutTokens = new HashSet<String>();


 	static {
@@ -143,8 +142,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 		singleValuedAnnotationPcds.add("@withincode");
 		singleValuedAnnotationPcds.add("@annotation");

-		Set<PointcutPrimitive> pointcutPrimitives = PointcutParser.getAllSupportedPointcutPrimitives();
-		for (PointcutPrimitive primitive : pointcutPrimitives) {
+		Set pointcutPrimitives = PointcutParser.getAllSupportedPointcutPrimitives();
+		for (Iterator iterator = pointcutPrimitives.iterator(); iterator.hasNext();) {
+			PointcutPrimitive primitive = (PointcutPrimitive) iterator.next();
 			nonReferencePointcutTokens.add(primitive.getName());
 		}
 		nonReferencePointcutTokens.add("&&");
@@ -156,23 +156,26 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}


-	/** The pointcut expression associated with the advice, as a simple String */
-	@Nullable
-	private String pointcutExpression;
-
 	private boolean raiseExceptions;

-	/** If the advice is afterReturning, and binds the return value, this is the parameter name used */
-	@Nullable
+	/**
+	 * If the advice is afterReturning, and binds the return value, this is the parameter name used.
+	 */
 	private String returningName;

-	/** If the advice is afterThrowing, and binds the thrown value, this is the parameter name used */
-	@Nullable
+	/**
+	 * If the advice is afterThrowing, and binds the thrown value, this is the parameter name used.
+	 */
 	private String throwingName;

-	private Class<?>[] argumentTypes = new Class<?>[0];
+	/**
+	 * The pointcut expression associated with the advice, as a simple String.
+	 */
+	private String pointcutExpression;

-	private String[] parameterNameBindings = new String[0];
+	private Class[] argumentTypes;
+
+	private String[] parameterNameBindings;

 	private int numberOfRemainingUnboundArguments;

@@ -181,39 +184,37 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Create a new discoverer that attempts to discover parameter names
 	 * from the given pointcut expression.
 	 */
-	public AspectJAdviceParameterNameDiscoverer(@Nullable String pointcutExpression) {
+	public AspectJAdviceParameterNameDiscoverer(String pointcutExpression) {
 		this.pointcutExpression = pointcutExpression;
 	}

-
 	/**
 	 * Indicate whether {@link IllegalArgumentException} and {@link AmbiguousBindingException}
 	 * must be thrown as appropriate in the case of failing to deduce advice parameter names.
-	 * @param raiseExceptions {@code true} if exceptions are to be thrown
+	 * @param raiseExceptions <code>true</code> if exceptions are to be thrown
 	 */
 	public void setRaiseExceptions(boolean raiseExceptions) {
 		this.raiseExceptions = raiseExceptions;
 	}

 	/**
-	 * If {@code afterReturning} advice binds the return value, the
+	 * If <code>afterReturning</code> advice binds the return value, the
 	 * returning variable name must be specified.
 	 * @param returningName the name of the returning variable
 	 */
-	public void setReturningName(@Nullable String returningName) {
+	public void setReturningName(String returningName) {
 		this.returningName = returningName;
 	}

 	/**
-	 * If {@code afterThrowing} advice binds the thrown value, the
+	 * If <code>afterThrowing</code> advice binds the thrown value, the
 	 * throwing variable name must be specified.
 	 * @param throwingName the name of the throwing variable
 	 */
-	public void setThrowingName(@Nullable String throwingName) {
+	public void setThrowingName(String throwingName) {
 		this.throwingName = throwingName;
 	}

-
 	/**
 	 * Deduce the parameter names for an advice method.
 	 * <p>See the {@link AspectJAdviceParameterNameDiscoverer class level javadoc}
@@ -221,8 +222,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * @param method the target {@link Method}
 	 * @return the parameter names
 	 */
-	@Override
-	@Nullable
 	public String[] getParameterNames(Method method) {
 		this.argumentTypes = method.getParameterTypes();
 		this.numberOfRemainingUnboundArguments = this.argumentTypes.length;
@@ -306,13 +305,11 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov

 	/**
 	 * An advice method can never be a constructor in Spring.
-	 * @return {@code null}
+	 * @return <code>null</code>
 	 * @throws UnsupportedOperationException if
-	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
+	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to <code>true</code>
 	 */
-	@Override
-	@Nullable
-	public String[] getParameterNames(Constructor<?> ctor) {
+	public String[] getParameterNames(Constructor ctor) {
 		if (this.raiseExceptions) {
 			throw new UnsupportedOperationException("An advice method can never be a constructor");
 		}
@@ -417,11 +414,11 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * <p>Some more support from AspectJ in doing this exercise would be nice... :)
 	 */
 	private void maybeBindAnnotationsFromPointcutExpression() {
-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
-			int firstParenIndex = toMatch.indexOf('(');
+			int firstParenIndex = toMatch.indexOf("(");
 			if (firstParenIndex != -1) {
 				toMatch = toMatch.substring(0, firstParenIndex);
 			}
@@ -476,9 +473,8 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	/*
 	 * If the token starts meets Java identifier conventions, it's in.
 	 */
-	@Nullable
-	private String maybeExtractVariableName(@Nullable String candidateToken) {
-		if (!StringUtils.hasLength(candidateToken)) {
+	private String maybeExtractVariableName(String candidateToken) {
+		if (candidateToken == null || candidateToken.equals("")) {
 			return null;
 		}
 		if (Character.isJavaIdentifierStart(candidateToken.charAt(0)) &&
@@ -497,10 +493,10 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}

 	/**
-	 * Given an args pointcut body (could be {@code args} or {@code at_args}),
+	 * Given an args pointcut body (could be <code>args</code> or <code>at_args</code>),
 	 * add any candidate variable names to the given list.
 	 */
-	private void maybeExtractVariableNamesFromArgs(@Nullable String argsSpec, List<String> varNames) {
+	private void maybeExtractVariableNamesFromArgs(String argsSpec, List<String> varNames) {
 		if (argsSpec == null) {
 			return;
 		}
@@ -524,7 +520,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at this(),target(),args() binding stage, with no way to determine between them");
 		}

-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			if (tokens[i].equals("this") ||
@@ -541,7 +537,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 			else if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
 				PointcutBody body = getPointcutBody(tokens, i);
 				i += body.numTokensConsumed;
-				List<String> candidateVarNames = new ArrayList<>();
+				List<String> candidateVarNames = new ArrayList<String>();
 				maybeExtractVariableNamesFromArgs(body.text, candidateVarNames);
 				// we may have found some var names that were bound in previous primitive args binding step,
 				// filter them out...
@@ -575,14 +571,14 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at reference pointcut binding stage, with no way to determine between them");
 		}

-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
 			if (toMatch.startsWith("!")) {
 				toMatch = toMatch.substring(1);
 			}
-			int firstParenIndex = toMatch.indexOf('(');
+			int firstParenIndex = toMatch.indexOf("(");
 			if (firstParenIndex != -1) {
 				toMatch = toMatch.substring(0, firstParenIndex);
 			}
@@ -656,7 +652,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 				}

 				if (tokens[currentIndex].endsWith(")")) {
-					sb.append(tokens[currentIndex], 0, tokens[currentIndex].length() - 1);
+					sb.append(tokens[currentIndex].substring(0, tokens[currentIndex].length() - 1));
 					return new PointcutBody(numTokensConsumed, sb.toString().trim());
 				}

@@ -687,7 +683,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 		}
 		if (numUnboundPrimitives == 1) {
 			// Look for arg variable and bind it if we find exactly one...
-			List<String> varNames = new ArrayList<>();
+			List<String> varNames = new ArrayList<String>();
 			String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 			for (int i = 0; i < tokens.length; i++) {
 				if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
@@ -704,7 +700,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 				// 1 primitive arg, and one candidate...
 				for (int i = 0; i < this.argumentTypes.length; i++) {
 					if (isUnbound(i) && this.argumentTypes[i].isPrimitive()) {
-						bindParameterName(i, varNames.get(0));
+						bindParameterName(i, (String) varNames.get(0));
 						break;
 					}
 				}
@@ -730,10 +726,10 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}

 	/*
-	 * Return {@code true} if the given argument type is a subclass
+	 * Return <code>true</code> if the given argument type is a subclass
 	 * of the given supertype.
 	 */
-	private boolean isSubtypeOf(Class<?> supertype, int argumentNumber) {
+	private boolean isSubtypeOf(Class supertype, int argumentNumber) {
 		return supertype.isAssignableFrom(this.argumentTypes[argumentNumber]);
 	}

@@ -759,9 +755,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov

 	/*
 	 * Find the argument index with the given type, and bind the given
-	 * {@code varName} in that position.
+	 * <code>varName</code> in that position.
 	 */
-	private void findAndBind(Class<?> argumentType, String varName) {
+	private void findAndBind(Class argumentType, String varName) {
 		for (int i = 0; i < this.argumentTypes.length; i++) {
 			if (isUnbound(i) && isSubtypeOf(argumentType, i)) {
 				bindParameterName(i, varName);
@@ -781,10 +777,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov

 		private int numTokensConsumed;

-		@Nullable
 		private String text;

-		public PointcutBody(int tokens, @Nullable String text) {
+		public PointcutBody(int tokens, String text) {
 			this.numTokensConsumed = tokens;
 			this.text = text;
 		}
@@ -795,7 +790,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Thrown in response to an ambiguous binding being detected when
 	 * trying to resolve a method's parameter names.
 	 */
-	@SuppressWarnings("serial")
 	public static class AmbiguousBindingException extends RuntimeException {

 		/**
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,7 +16,6 @@

 package org.springframework.aop.aspectj;

-import java.io.Serializable;
 import java.lang.reflect.Method;

 import org.aopalliance.intercept.MethodInterceptor;
@@ -30,18 +29,14 @@ import org.springframework.aop.AfterAdvice;
 * @author Rod Johnson
 * @since 2.0
 */
-@SuppressWarnings("serial")
-public class AspectJAfterAdvice extends AbstractAspectJAdvice
-		implements MethodInterceptor, AfterAdvice, Serializable {
+public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {

 	public AspectJAfterAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {

 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
-
-
-	@Override
+	
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();
@@ -51,12 +46,10 @@ public class AspectJAfterAdvice extends AbstractAspectJAdvice
 		}
 	}

-	@Override
 	public boolean isBeforeAdvice() {
 		return false;
 	}

-	@Override
 	public boolean isAfterAdvice() {
 		return true;
 	}
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import org.springframework.aop.AfterAdvice;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.TypeUtils;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after-returning advice method.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implements AfterReturningAdvice, AfterAdvice {
+
+	public AspectJAfterReturningAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+	@Override
+	public void setReturningName(String name) {
+		setReturningNameNoCheck(name);
+	}
+
+	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
+		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
+			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
+		}
+	}
+
+	/**
+	 * Following AspectJ semantics, if a returning clause was specified, then the
+	 * advice is only invoked if the returned value is an instance of the given
+	 * returning type and generic type parameters, if any, match the assignment
+	 * rules. If the returning type is Object, the advice is *always* invoked.
+	 * @param returnValue the return value of the target method
+	 * @return whether to invoke the advice method for the given return value
+	 */
+	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
+		Class type = getDiscoveredReturningType();
+		Type genericType = getDiscoveredReturningGenericType();
+		// If we aren't dealing with a raw type, check if  generic parameters are assignable.
+		return (ClassUtils.isAssignableValue(type, returnValue) &&
+				(genericType == null || genericType == type ||
+						TypeUtils.isAssignable(genericType, method.getGenericReturnType())));
+	}
+
+}
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,7 +16,6 @@

 package org.springframework.aop.aspectj;

-import java.io.Serializable;
 import java.lang.reflect.Method;

 import org.aopalliance.intercept.MethodInterceptor;
@@ -30,9 +29,7 @@ import org.springframework.aop.AfterAdvice;
 * @author Rod Johnson
 * @since 2.0
 */
-@SuppressWarnings("serial")
-public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
-		implements MethodInterceptor, AfterAdvice, Serializable {
+public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {

 	public AspectJAfterThrowingAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -40,13 +37,10 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

-
-	@Override
 	public boolean isBeforeAdvice() {
 		return false;
 	}

-	@Override
 	public boolean isAfterAdvice() {
 		return true;
 	}
@@ -56,16 +50,15 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 		setThrowingNameNoCheck(name);
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();
 		}
-		catch (Throwable ex) {
-			if (shouldInvokeOnThrowing(ex)) {
-				invokeAdviceMethod(getJoinPointMatch(), null, ex);
+		catch (Throwable t) {
+			if (shouldInvokeOnThrowing(t)) {
+				invokeAdviceMethod(getJoinPointMatch(), null, t);
 			}
-			throw ex;
+			throw t;
 		}
 	}

@@ -73,8 +66,9 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 	 * In AspectJ semantics, after throwing advice that specifies a throwing clause
 	 * is only invoked if the thrown exception is a subtype of the given throwing type.
 	 */
-	private boolean shouldInvokeOnThrowing(Throwable ex) {
-		return getDiscoveredThrowingType().isAssignableFrom(ex.getClass());
+	private boolean shouldInvokeOnThrowing(Throwable t) {
+		Class throwingType = getDiscoveredThrowingType();
+		return throwingType.isAssignableFrom(t.getClass());
 	}

 }
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -21,7 +21,6 @@ import org.aopalliance.aop.Advice;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.AfterAdvice;
 import org.springframework.aop.BeforeAdvice;
-import org.springframework.lang.Nullable;

 /**
 * Utility methods for dealing with AspectJ advisors.
@@ -33,7 +32,7 @@ import org.springframework.lang.Nullable;
 public abstract class AspectJAopUtils {

 	/**
-	 * Return {@code true} if the advisor is a form of before advice.
+	 * Return <code>true</code> if the advisor is a form of before advice.
 	 */
 	public static boolean isBeforeAdvice(Advisor anAdvisor) {
 		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
@@ -44,7 +43,7 @@ public abstract class AspectJAopUtils {
 	}

 	/**
-	 * Return {@code true} if the advisor is a form of after advice.
+	 * Return <code>true</code> if the advisor is a form of after advice.
 	 */
 	public static boolean isAfterAdvice(Advisor anAdvisor) {
 		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
@@ -57,9 +56,8 @@ public abstract class AspectJAopUtils {
 	/**
 	 * Return the AspectJPrecedenceInformation provided by this advisor or its advice.
 	 * If neither the advisor nor the advice have precedence information, this method
-	 * will return {@code null}.
+	 * will return <code>null</code>.
 	 */
-	@Nullable
 	public static AspectJPrecedenceInformation getAspectJPrecedenceInformationFor(Advisor anAdvisor) {
 		if (anAdvisor instanceof AspectJPrecedenceInformation) {
 			return (AspectJPrecedenceInformation) anAdvisor;
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,7 +16,6 @@

 package org.springframework.aop.aspectj;

-import java.io.Serializable;
 import java.lang.reflect.Method;

 import org.aopalliance.intercept.MethodInterceptor;
@@ -34,8 +33,7 @@ import org.springframework.aop.ProxyMethodInvocation;
 * @author Juergen Hoeller
 * @since 2.0
 */
-@SuppressWarnings("serial")
-public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor, Serializable {
+public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor {

 	public AspectJAroundAdvice(
 			Method aspectJAroundAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -43,13 +41,10 @@ public class AspectJAroundAdvice extends AbstractAspectJAdvice implements Method
 		super(aspectJAroundAdviceMethod, pointcut, aif);
 	}

-
-	@Override
 	public boolean isBeforeAdvice() {
 		return false;
 	}

-	@Override
 	public boolean isAfterAdvice() {
 		return false;
 	}
@@ -59,7 +54,7 @@ public class AspectJAroundAdvice extends AbstractAspectJAdvice implements Method
 		return true;
 	}

-	@Override
+
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		if (!(mi instanceof ProxyMethodInvocation)) {
 			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
@@ -0,0 +1,641 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.weaver.BCException;
+import org.aspectj.weaver.patterns.NamePattern;
+import org.aspectj.weaver.reflect.ReflectionWorld;
+import org.aspectj.weaver.reflect.ReflectionWorld.ReflectionWorldException;
+import org.aspectj.weaver.reflect.ShadowMatchImpl;
+import org.aspectj.weaver.tools.ContextBasedMatcher;
+import org.aspectj.weaver.tools.FuzzyBoolean;
+import org.aspectj.weaver.tools.JoinPointMatch;
+import org.aspectj.weaver.tools.MatchingContext;
+import org.aspectj.weaver.tools.PointcutDesignatorHandler;
+import org.aspectj.weaver.tools.PointcutExpression;
+import org.aspectj.weaver.tools.PointcutParameter;
+import org.aspectj.weaver.tools.PointcutParser;
+import org.aspectj.weaver.tools.PointcutPrimitive;
+import org.aspectj.weaver.tools.ShadowMatch;
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.IntroductionAwareMethodMatcher;
+import org.springframework.aop.MethodMatcher;
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.aop.framework.autoproxy.ProxyCreationContext;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+import org.springframework.aop.support.AbstractExpressionPointcut;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.BeanFactoryUtils;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * Spring {@link org.springframework.aop.Pointcut} implementation
+ * that uses the AspectJ weaver to evaluate a pointcut expression.
+ *
+ * <p>The pointcut expression value is an AspectJ expression. This can
+ * reference other pointcuts and use composition and other operations.
+ *
+ * <p>Naturally, as this is to be processed by Spring AOP's proxy-based model,
+ * only method execution pointcuts are supported.
+ *
+ * @author Rob Harrop
+ * @author Adrian Colyer
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @author Dave Syer
+ * @since 2.0
+ */
+public class AspectJExpressionPointcut extends AbstractExpressionPointcut
+		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
+
+	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
+
+	static {
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
+	}
+
+
+	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
+
+	private Class pointcutDeclarationScope;
+
+	private String[] pointcutParameterNames = new String[0];
+
+	private Class[] pointcutParameterTypes = new Class[0];
+
+	private BeanFactory beanFactory;
+
+	private transient PointcutExpression pointcutExpression;
+
+	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
+
+
+	/**
+	 * Create a new default AspectJExpressionPointcut.
+	 */
+	public AspectJExpressionPointcut() {
+	}
+
+	/**
+	 * Create a new AspectJExpressionPointcut with the given settings.
+	 * @param declarationScope the declaration scope for the pointcut
+	 * @param paramNames the parameter names for the pointcut
+	 * @param paramTypes the parameter types for the pointcut
+	 */
+	public AspectJExpressionPointcut(Class declarationScope, String[] paramNames, Class[] paramTypes) {
+		this.pointcutDeclarationScope = declarationScope;
+		if (paramNames.length != paramTypes.length) {
+			throw new IllegalStateException(
+					"Number of pointcut parameter names must match number of pointcut parameter types");
+		}
+		this.pointcutParameterNames = paramNames;
+		this.pointcutParameterTypes = paramTypes;
+	}
+
+
+	/**
+	 * Set the declaration scope for the pointcut.
+	 */
+	public void setPointcutDeclarationScope(Class pointcutDeclarationScope) {
+		this.pointcutDeclarationScope = pointcutDeclarationScope;
+	}
+
+	/**
+	 * Set the parameter names for the pointcut.
+	 */
+	public void setParameterNames(String[] names) {
+		this.pointcutParameterNames = names;
+	}
+
+	/**
+	 * Set the parameter types for the pointcut.
+	 */
+	public void setParameterTypes(Class[] types) {
+		this.pointcutParameterTypes = types;
+	}
+
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
+
+
+	public ClassFilter getClassFilter() {
+		checkReadyToMatch();
+		return this;
+	}
+
+	public MethodMatcher getMethodMatcher() {
+		checkReadyToMatch();
+		return this;
+	}
+
+
+	/**
+	 * Check whether this pointcut is ready to match,
+	 * lazily building the underlying AspectJ pointcut expression.
+	 */
+	private void checkReadyToMatch() {
+		if (getExpression() == null) {
+			throw new IllegalStateException("Must set property 'expression' before attempting to match");
+		}
+		if (this.pointcutExpression == null) {
+			this.pointcutExpression = buildPointcutExpression();
+		}
+	}
+
+	/**
+	 * Build the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression buildPointcutExpression() {
+		ClassLoader cl = (this.beanFactory instanceof ConfigurableBeanFactory ? ((ConfigurableBeanFactory) this.beanFactory)
+				.getBeanClassLoader() : Thread.currentThread()
+				.getContextClassLoader());
+		return buildPointcutExpression(cl);
+	}
+
+	/**
+	 * Build the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression buildPointcutExpression(ClassLoader classLoader) {
+		PointcutParser parser = initializePointcutParser(classLoader);
+		PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];
+		for (int i = 0; i < pointcutParameters.length; i++) {
+			pointcutParameters[i] = parser.createPointcutParameter(
+					this.pointcutParameterNames[i],
+					this.pointcutParameterTypes[i]);
+		}
+		return parser.parsePointcutExpression(
+				replaceBooleanOperators(getExpression()),
+				this.pointcutDeclarationScope, pointcutParameters);
+	}
+
+	/**
+	 * Initialize the underlying AspectJ pointcut parser.
+	 */
+	private PointcutParser initializePointcutParser(ClassLoader cl) {
+		PointcutParser parser = PointcutParser
+				.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
+						SUPPORTED_PRIMITIVES, cl);
+		parser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
+		return parser;
+	}
+
+
+	/**
+	 * If a pointcut expression has been specified in XML, the user cannot
+	 * write <code>and</code> as "&&" (though &amp;&amp; will work).
+	 * We also allow <code>and</code> between two pointcut sub-expressions.
+	 * <p>This method converts back to <code>&&</code> for the AspectJ pointcut parser.
+	 */
+	private String replaceBooleanOperators(String pcExpr) {
+		String result = StringUtils.replace(pcExpr, " and ", " && ");
+		result = StringUtils.replace(result, " or ", " || ");
+		result = StringUtils.replace(result, " not ", " ! ");
+		return result;
+	}
+
+
+	/**
+	 * Return the underlying AspectJ pointcut expression.
+	 */
+	public PointcutExpression getPointcutExpression() {
+		checkReadyToMatch();
+		return this.pointcutExpression;
+	}
+
+	public boolean matches(Class targetClass) {
+		checkReadyToMatch();
+		try {
+			return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
+		} catch (ReflectionWorldException e) {
+			logger.debug("PointcutExpression matching rejected target class", e);
+			try {
+				// Actually this is still a "maybe" - treat the pointcut as dynamic if we
+				// don't know enough yet
+				return getFallbackPointcutExpression(targetClass).couldMatchJoinPointsInType(targetClass);
+			} catch (BCException ex) {
+				logger.debug(
+						"Fallback PointcutExpression matching rejected target class",
+						ex);
+				return false;
+			}
+		} 
+		catch (BCException ex) {
+			logger.debug("PointcutExpression matching rejected target class", ex);
+			return false;
+		}
+	}
+
+	public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
+		checkReadyToMatch();
+		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
+		ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);
+
+		// Special handling for this, target, @this, @target, @annotation
+		// in Spring - we can optimize since we know we have exactly this class,
+		// and there will never be matching subclass at runtime.
+		if (shadowMatch.alwaysMatches()) {
+			return true;
+		}
+		else if (shadowMatch.neverMatches()) {
+			return false;
+		}
+		else {
+		  // the maybe case
+		  return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));
+		}
+	}
+
+	public boolean matches(Method method, Class targetClass) {
+		return matches(method, targetClass, false);
+	}
+
+	public boolean isRuntime() {
+		checkReadyToMatch();
+		return this.pointcutExpression.mayNeedDynamicTest();
+	}
+
+	public boolean matches(Method method, Class targetClass, Object[] args) {
+		checkReadyToMatch();
+		ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
+		ShadowMatch originalShadowMatch = getShadowMatch(method, method);
+
+		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
+		// consistent with return of MethodInvocationProceedingJoinPoint
+		ProxyMethodInvocation pmi = null;
+		Object targetObject = null;
+		Object thisObject = null;
+		try {
+			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+			targetObject = mi.getThis();
+			if (!(mi instanceof ProxyMethodInvocation)) {
+				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+			}
+			pmi = (ProxyMethodInvocation) mi;
+			thisObject = pmi.getProxy();
+		}
+		catch (IllegalStateException ex) {
+			// No current invocation...
+			// TODO: Should we really proceed here?
+			logger.debug("Couldn't access current invocation - matching with limited context: " + ex);
+		}
+
+		JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
+
+		/*
+		 * Do a final check to see if any this(TYPE) kind of residue match. For
+		 * this purpose, we use the original method's (proxy method's) shadow to
+		 * ensure that 'this' is correctly checked against. Without this check,
+		 * we get incorrect match on this(TYPE) where TYPE matches the target
+		 * type but not 'this' (as would be the case of JDK dynamic proxies).
+		 * <p>See SPR-2979 for the original bug.
+		 */
+		if (pmi != null) {  // there is a current invocation
+			RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(originalShadowMatch);
+			if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
+				return false;
+			}
+		}
+		if (joinPointMatch.matches() && pmi != null) {
+			bindParameters(pmi, joinPointMatch);
+		}
+		return joinPointMatch.matches();
+	}
+
+
+	protected String getCurrentProxiedBeanName() {
+		return ProxyCreationContext.getCurrentProxiedBeanName();
+	}
+
+
+	/**
+	 * Get a new pointcut expression based on a target class's loader, rather
+	 * than the default.
+	 */
+	private PointcutExpression getFallbackPointcutExpression(
+			Class<?> targetClass) {
+		ClassLoader classLoader = targetClass.getClassLoader();
+		return classLoader == null ? this.pointcutExpression : buildPointcutExpression(classLoader);
+	}
+
+	/**
+	 * A match test returned maybe - if there are any subtype sensitive variables
+	 * involved in the test (this, target, at_this, at_target, at_annotation) then
+	 * we say this is not a match as in Spring there will never be a different
+	 * runtime subtype.
+	 */
+	private boolean matchesIgnoringSubtypes(ShadowMatch shadowMatch) {
+		return !(getRuntimeTestWalker(shadowMatch).testsSubtypeSensitiveVars());
+	}
+
+	private boolean matchesTarget(ShadowMatch shadowMatch, Class targetClass) {
+		return getRuntimeTestWalker(shadowMatch).testTargetInstanceOfResidue(targetClass);
+	}
+
+	private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
+		if (shadowMatch instanceof DefensiveShadowMatch) {
+			return new RuntimeTestWalker(((DefensiveShadowMatch)shadowMatch).primary);
+		}
+		return new RuntimeTestWalker(shadowMatch);
+	}
+
+	private void bindParameters(ProxyMethodInvocation invocation, JoinPointMatch jpm) {
+		// Note: Can't use JoinPointMatch.getClass().getName() as the key, since
+		// Spring AOP does all the matching at a join point, and then all the invocations
+		// under this scenario, if we just use JoinPointMatch as the key, then
+		// 'last man wins' which is not what we want at all.
+		// Using the expression is guaranteed to be safe, since 2 identical expressions
+		// are guaranteed to bind in exactly the same way.
+		invocation.setUserAttribute(getExpression(), jpm);
+	}
+
+	private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
+		// Avoid lock contention for known Methods through concurrent access...
+		ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
+		if (shadowMatch == null) {
+			synchronized (this.shadowMatchCache) {
+				// Not found - now check again with full lock...
+				Method methodToMatch = targetMethod;
+				PointcutExpression fallbackPointcutExpression = null;
+				shadowMatch = this.shadowMatchCache.get(methodToMatch);
+				if (shadowMatch == null) {
+					try {
+						shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
+					}
+					catch (ReflectionWorld.ReflectionWorldException ex) {
+						// Failed to introspect target method, probably because it has been loaded
+						// in a special ClassLoader. Let's try the original method instead...
+						try {
+							fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+							shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
+						} catch (ReflectionWorld.ReflectionWorldException e) {
+							if (targetMethod == originalMethod) {
+								shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+							}
+							else {
+								try {
+									shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
+								}
+								catch (ReflectionWorld.ReflectionWorldException ex2) {
+									// Could neither introspect the target class nor the proxy class ->
+									// let's simply consider this method as non-matching.
+									methodToMatch = originalMethod;
+									fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+									try {
+										shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
+									} catch (ReflectionWorld.ReflectionWorldException e2) {
+										shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+									}
+								}
+							}
+						}
+					}
+					if (shadowMatch.maybeMatches() && fallbackPointcutExpression!=null) {
+						shadowMatch = new DefensiveShadowMatch(shadowMatch,
+								fallbackPointcutExpression.matchesMethodExecution(methodToMatch));
+					}
+					this.shadowMatchCache.put(targetMethod, shadowMatch);
+				}
+			}
+		}
+		return shadowMatch;
+	}
+
+
+	@Override
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AspectJExpressionPointcut)) {
+			return false;
+		}
+		AspectJExpressionPointcut otherPc = (AspectJExpressionPointcut) other;
+		return ObjectUtils.nullSafeEquals(this.getExpression(), otherPc.getExpression()) &&
+				ObjectUtils.nullSafeEquals(this.pointcutDeclarationScope, otherPc.pointcutDeclarationScope) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterNames, otherPc.pointcutParameterNames) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterTypes, otherPc.pointcutParameterTypes);
+	}
+
+	@Override
+	public int hashCode() {
+		int hashCode = ObjectUtils.nullSafeHashCode(this.getExpression());
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutDeclarationScope);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterNames);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterTypes);
+		return hashCode;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder();
+		sb.append("AspectJExpressionPointcut: ");
+		if (this.pointcutParameterNames != null && this.pointcutParameterTypes != null) {
+			sb.append("(");
+			for (int i = 0; i < this.pointcutParameterTypes.length; i++) {
+				sb.append(this.pointcutParameterTypes[i].getName());
+				sb.append(" ");
+				sb.append(this.pointcutParameterNames[i]);
+				if ((i+1) < this.pointcutParameterTypes.length) {
+					sb.append(", ");
+				}
+			}
+			sb.append(")");
+		}
+		sb.append(" ");
+		if (getExpression() != null) {
+			sb.append(getExpression());
+		}
+		else {
+			sb.append("<pointcut expression not set>");
+		}
+		return sb.toString();
+	}
+
+
+	/**
+	 * Handler for the Spring-specific <code>bean()</code> pointcut designator
+	 * extension to AspectJ.
+	 * <p>This handler must be added to each pointcut object that needs to
+	 * handle the <code>bean()</code> PCD. Matching context is obtained
+	 * automatically by examining a thread local variable and therefore a matching
+	 * context need not be set on the pointcut.
+	 */
+	private class BeanNamePointcutDesignatorHandler implements PointcutDesignatorHandler {
+
+		private static final String BEAN_DESIGNATOR_NAME = "bean";
+
+		public String getDesignatorName() {
+			return BEAN_DESIGNATOR_NAME;
+		}
+
+		public ContextBasedMatcher parse(String expression) {
+			return new BeanNameContextMatcher(expression);
+		}
+	}
+
+
+	/**
+	 * Matcher class for the BeanNamePointcutDesignatorHandler.
+	 * <p>Dynamic match tests for this matcher always return true,
+	 * since the matching decision is made at the proxy creation time.
+	 * For static match tests, this matcher abstains to allow the overall
+	 * pointcut to match even when negation is used with the bean() pointcut.
+	 */
+	private class BeanNameContextMatcher implements ContextBasedMatcher {
+
+		private final NamePattern expressionPattern;
+
+		public BeanNameContextMatcher(String expression) {
+			this.expressionPattern = new NamePattern(expression);
+		}
+
+		public boolean couldMatchJoinPointsInType(Class someClass) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		public boolean couldMatchJoinPointsInType(Class someClass, MatchingContext context) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		public boolean matchesDynamically(MatchingContext context) {
+			return true;
+		}
+
+		public FuzzyBoolean matchesStatically(MatchingContext context) {
+			return contextMatch(null);
+		}
+
+		public boolean mayNeedDynamicTest() {
+			return false;
+		}
+
+		private FuzzyBoolean contextMatch(Class targetType) {
+			String advisedBeanName = getCurrentProxiedBeanName();
+			if (advisedBeanName == null) {  // no proxy creation in progress
+				// abstain; can't return YES, since that will make pointcut with negation fail
+				return FuzzyBoolean.MAYBE; 
+			}
+			if (BeanFactoryUtils.isGeneratedBeanName(advisedBeanName)) {
+				return FuzzyBoolean.NO;
+			}
+			if (targetType != null) {
+				boolean isFactory = FactoryBean.class.isAssignableFrom(targetType);
+				return FuzzyBoolean.fromBoolean(
+						matchesBeanName(isFactory ? BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName : advisedBeanName));
+			}
+			else {
+				return FuzzyBoolean.fromBoolean(matchesBeanName(advisedBeanName) ||
+						matchesBeanName(BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName));
+			}
+		}
+
+		private boolean matchesBeanName(String advisedBeanName) {
+			if (this.expressionPattern.matches(advisedBeanName)) {
+				return true;
+			}
+			if (beanFactory != null) {
+				String[] aliases = beanFactory.getAliases(advisedBeanName);
+				for (String alias : aliases) {
+					if (this.expressionPattern.matches(alias)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+	}
+
+
+	//---------------------------------------------------------------------
+	// Serialization support
+	//---------------------------------------------------------------------
+
+	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+		// Rely on default serialization, just initialize state after deserialization.
+		ois.defaultReadObject();
+
+		// Initialize transient fields.
+		// pointcutExpression will be initialized lazily by checkReadyToMatch()
+		this.shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
+	}
+
+	private static class DefensiveShadowMatch implements ShadowMatch {
+
+		private final ShadowMatch primary;
+		private final ShadowMatch other;
+
+		public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
+			this.primary = primary;
+			this.other = other;
+		}
+
+		public boolean alwaysMatches() {
+			return primary.alwaysMatches();
+		}
+
+		public boolean maybeMatches() {
+			return primary.maybeMatches();
+		}
+
+		public boolean neverMatches() {
+			return primary.neverMatches();
+		}
+
+		public JoinPointMatch matchesJoinPoint(Object thisObject,
+				Object targetObject, Object[] args) {
+			try {
+				return primary.matchesJoinPoint(thisObject, targetObject, args);
+			} catch (ReflectionWorldException e) {
+				return other.matchesJoinPoint(thisObject, targetObject, args);
+			}
+		}
+
+		public void setMatchingContext(MatchingContext aMatchContext) {
+			primary.setMatchingContext(aMatchContext);
+			other.setMatchingContext(aMatchContext);
+		}
+
+	}
+
+}
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2006 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.support.AbstractGenericPointcutAdvisor;
+
+/**
+ * Spring AOP Advisor that can be used for any AspectJ pointcut expression.
+ * 
+ * @author Rob Harrop
+ * @since 2.0
+ */
+public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor {
+
+	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
+
+
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
+	public void setExpression(String expression) {
+		this.pointcut.setExpression(expression);
+	}
+
+	public void setLocation(String location) {
+		this.pointcut.setLocation(location);
+	}
+
+	public void setParameterTypes(Class[] types) {
+		this.pointcut.setParameterTypes(types);
+	}
+
+	public void setParameterNames(String[] names) {
+		this.pointcut.setParameterNames(names);
+	}
+
+	public String getLocation() {
+		return this.pointcut.getLocation();
+	}
+
+	public String getExpression() {
+		return this.pointcut.getExpression();
+	}
+
+}
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -16,11 +16,9 @@

 package org.springframework.aop.aspectj;

-import java.io.Serializable;
 import java.lang.reflect.Method;

 import org.springframework.aop.MethodBeforeAdvice;
-import org.springframework.lang.Nullable;

 /**
 * Spring AOP advice that wraps an AspectJ before method.
@@ -29,8 +27,7 @@ import org.springframework.lang.Nullable;
 * @author Adrian Colyer
 * @since 2.0
 */
-@SuppressWarnings("serial")
-public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {
+public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice {

 	public AspectJMethodBeforeAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -38,18 +35,14 @@ public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

-
-	@Override
-	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
+	public void before(Method method, Object[] args, Object target) throws Throwable {
 		invokeAdviceMethod(getJoinPointMatch(), null, null);
 	}

-	@Override
 	public boolean isBeforeAdvice() {
 		return true;
 	}

-	@Override
 	public boolean isAfterAdvice() {
 		return false;
 	}
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2008 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -21,8 +21,8 @@ import org.aopalliance.aop.Advice;
 import org.springframework.aop.Pointcut;
 import org.springframework.aop.PointcutAdvisor;
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;

 /**
 * AspectJPointcutAdvisor that adapts an {@link AbstractAspectJAdvice}
@@ -38,7 +38,6 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {

 	private final Pointcut pointcut;

-	@Nullable
 	private Integer order;


@@ -52,12 +51,23 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 		this.pointcut = advice.buildSafePointcut();
 	}

-
 	public void setOrder(int order) {
 		this.order = order;
 	}

-	@Override
+
+	public boolean isPerInstance() {
+		return true;
+	}
+
+	public Advice getAdvice() {
+		return this.advice;
+	}
+
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
 	public int getOrder() {
 		if (this.order != null) {
 			return this.order;
@@ -67,30 +77,6 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 		}
 	}

-	@Override
-	public boolean isPerInstance() {
-		return true;
-	}
-
-	@Override
-	public Advice getAdvice() {
-		return this.advice;
-	}
-
-	@Override
-	public Pointcut getPointcut() {
-		return this.pointcut;
-	}
-
-	/**
-	 * Return the name of the aspect (bean) in which the advice was declared.
-	 * @since 4.3.15
-	 * @see AbstractAspectJAdvice#getAspectName()
-	 */
-	public String getAspectName() {
-		return this.advice.getAspectName();
-	}
-

 	@Override
 	public boolean equals(Object other) {
@@ -101,12 +87,12 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 			return false;
 		}
 		AspectJPointcutAdvisor otherAdvisor = (AspectJPointcutAdvisor) other;
-		return this.advice.equals(otherAdvisor.advice);
+		return (ObjectUtils.nullSafeEquals(this.advice, otherAdvisor.advice));
 	}

 	@Override
 	public int hashCode() {
-		return AspectJPointcutAdvisor.class.hashCode() * 29 + this.advice.hashCode();
+		return AspectJPointcutAdvisor.class.hashCode();
 	}

 }
@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2018 the original author or authors.
+ * Copyright 2002-2006 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -36,12 +36,12 @@ public interface AspectJPrecedenceInformation extends Ordered {
 	// its advice for aspects with non-singleton instantiation models.

 	/**
-	 * Return the name of the aspect (bean) in which the advice was declared.
+	 * The name of the aspect (bean) in which the advice was declared.
 	 */
 	String getAspectName();

 	/**
-	 * Return the declaration order of the advice member within the aspect.
+	 * The declaration order of the advice member within the aspect.
 	 */
 	int getDeclarationOrder();

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2008 the original author or authors.
 *
 * Licensed 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
 *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -30,14 +30,14 @@ import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
 * @since 2.0
 */
 public abstract class AspectJProxyUtils {
-
+	
 	/**
 	 * Add special advisors if necessary to work with a proxy chain that contains AspectJ advisors.
 	 * This will expose the current Spring AOP invocation (necessary for some AspectJ pointcut matching)
 	 * and make available the current AspectJ JoinPoint. The call will have no effect if there are no
 	 * AspectJ advisors in the advisor chain.
 	 * @param advisors Advisors available
-	 * @return {@code true} if any special {@link Advisor Advisors} were added, otherwise {@code false}.
+	 * @return <code>true</code> if any special {@link Advisor Advisors} were added, otherwise <code>false</code>.
 	 */
 	public static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {
 		// Don't add advisors to an empty list; may indicate that proxying is just not required
@@ -64,8 +64,8 @@ public abstract class AspectJProxyUtils {
 	 */
 	private static boolean isAspectJAdvice(Advisor advisor) {
 		return (advisor instanceof InstantiationModelAwarePointcutAdvisor ||
-				advisor.getAdvice() instanceof AbstractAspectJAdvice ||
-				(advisor instanceof PointcutAdvisor &&
+			   advisor.getAdvice() instanceof AbstractAspectJAdvice ||
+			   (advisor instanceof PointcutAdvisor &&
 						 ((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut));
 	}

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed 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.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.bridge.AbortException;
+import org.aspectj.bridge.IMessage;
+import org.aspectj.bridge.IMessage.Kind;
+import org.aspectj.bridge.IMessageHandler;
+
+/**
+ * Implementation of AspectJ's {@link IMessageHandler} interface that
+ * routes AspectJ weaving messages through the same logging system as the
+ * regular Spring messages.
+ * 
+ * <p>Pass the option...
+ *
+ * <p><code class="code">-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler</code>
+ *
+ * <p>to the weaver; for example, specifying the following in a
+ * "<code>META-INF/aop.xml</code> file:
+ *
+ * <p><code class="code">&lt;weaver options="..."/&gt;</code>
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJWeaverMessageHandler implements IMessageHandler {
+
+	private static final String AJ_ID = "[AspectJ] ";
+	
+	private static final Log LOGGER = LogFactory.getLog("AspectJ Weaver");
+	
+
+	public boolean handleMessage(IMessage message) throws AbortException {
+		Kind messageKind = message.getKind();
+
+		if (LOGGER.isDebugEnabled() || LOGGER.isTraceEnabled()) {
+			if (messageKind == IMessage.DEBUG) {
+				LOGGER.debug(makeMessageFor(message));
+				return true;
+			}
+		} 
+		
+		if (LOGGER.isInfoEnabled()) {
+			if ((messageKind == IMessage.INFO) || (messageKind == IMessage.WEAVEINFO)) {
+				LOGGER.info(makeMessageFor(message));
+				return true;
+			}
+		} 
+		
+		if (LOGGER.isWarnEnabled()) {
+			if (messageKind == IMessage.WARNING) {
+				LOGGER.warn(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		if (LOGGER.isErrorEnabled()) {
+			if (messageKind == IMessage.ERROR) {
+				LOGGER.error(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		if (LOGGER.isFatalEnabled()) {
+			if (messageKind == IMessage.ABORT) {
+				LOGGER.fatal(makeMessageFor(message));
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	private String makeMessageFor(IMessage aMessage) {
+		return AJ_ID + aMessage.getMessage();
+	}
+
+	public boolean isIgnoring(Kind messageKind) {
+		// We want to see everything, and allow configuration of log levels dynamically.
+		return false;
+	}
+
+	public void dontIgnore(Kind messageKind) {
+		// We weren't ignoring anything anyway...
+	}
+
+	public void ignore(Kind kind) {
+		// We weren't ignoring anything anyway...
+	}
+
+}
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`implementation-class=org.springframework.build.gradle.TestSourceSetDependenciesPlugin`