Release version 3.2.7

Update changelog
Dropped explicit paragraph on web.xml version declaration
2026-06-08 17:33:33 +00:00 · 2014-01-28 14:38:30 -08:00 · 2014-01-28 13:53:01 -08:00 · 2014-01-28 17:32:08 +01:00 · 2014-01-28 17:25:12 +01:00 · 2014-01-28 12:41:36 +01:00
5340 changed files with 159243 additions and 324418 deletions
@@ -15,12 +15,10 @@ spring-test/test-output/
 .gradle
 argfile*
 pom.xml
-activemq-data/

 /build
 buildSrc/build
 /spring-*/build
-/src/asciidoc/build
 target/

 # Eclipse artifacts, including WTP generated manifests
@@ -32,8 +30,6 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 *.iml
 *.ipr
 *.iws
-.idea
 out
 test-output
 atlassian-ide-plugin.xml
-.gradletasknamecache
@@ -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,51 +0,0 @@
-= How to contribute to the reference
-
-The Spring Framework reference now uses http://asciidoctor.org/[asciidoctor]. This
-document describes how to contribute documentation updates.
-
-== Building with Gradle
-
-You can build the documentation using gradle using the `reference` task. For example, from
-the project root execute the following command:
-
-	./gradlew reference
-
-the output will be available at `spring-framework/build/reference/htmlsingle/index.html`
-
-== Live editing
-
-One of the nice features about using asciidoctor is the support for live editing.
-
-You will find a Guardfile already present at `spring-framework/src/asciidoc/Guardfile`.
-Make sure first to follow the setup instructions within the
-http://asciidoctor.org/docs/editing-asciidoc-with-live-preview/[Editing AsciiDoc with Live Preview]
-document. Once you have done that, there are additional gems to install to make it work
-(assuming that you are using http://livereload.com/[LiveReload]):
-
-	gem install guard-rspec guard-livereload
-
-When running `guard start` within the `src/asciidoc/` folder, any changes to the
-`src/asciidoc/index.adoc` file will automatically be written at
-`src/asciidoc/build/index.html`.
-
-== Troubleshooting
-
-* If you are using LiveReload, make sure to select _Allow access to file URLs_ in the
-  LiveEdit plugin options of your browser.
-* The icon used to enable _LiveReload_ can be a bit confusing. The dot is empty when it is
-  disabled and full when the plugin is active. Make sure to enable it on the tab
-  displaying the `index.html` file.
-* Ensure you are _not_ running guard start at all as two instances could not run at the
-  same time. To exit a current session in a clean way, just type e in the shell.
-
-== Documentation notes
-
-Some notes on documentation
-
-* Documentation is wrapped at 90 chars, ensure that you manually wrap your edits
-* Tabs are used for indentation, do not use spaces
-* Follow the existing style when inserting `source` blocks
-* http://asciidoctor.org/docs/asciidoc-syntax-quick-reference/[Asciidoctor Quick Reference]
-* http://asciidoctor.org/docs/user-manual/[Asciidoctor Manual]
-* http://asciidoctor.org/docs/asciidoc-writers-guide/[Asciidoctor Writers Guide]
-
@@ -1,28 +1,33 @@
 _Have something you'd like to contribute to the framework?  We welcome pull
-requests but ask that you carefully read this document first to understand how
+requests, but ask that you carefully read this document first to understand how
 best to submit them; what kind of changes are likely to be accepted; and what
 to expect from the Spring team when evaluating your submission._

 _Please refer back to this document as a checklist before issuing any pull
 request; this will save time for everyone!_

-## Take Your First Steps
+## Understand the basics

-### Understand the basics
-
-Not sure what a pull request is, or how to submit one? Take a look at GitHub's
+Not sure what a pull request is, or how to submit one?  Take a look at GitHub's
 excellent [help documentation][] first.


-### Search JIRA first; create an issue if necessary
+## Search JIRA first; create an issue if necessary

-Is there already an issue that addresses your concern? Do a bit of searching
-in our [JIRA issue tracker][] to see if you can find something similar. If you
-do not find something similar, please create a new JIRA issue before submitting
-a pull request unless the change is truly trivial -- for example: typo fixes,
-removing compiler warnings, etc.
+Is there already an issue that addresses your concern?  Do a bit of searching
+in our [JIRA issue tracker][] to see if you can find something similar. If not,
+please create a new issue before submitting a pull request unless the change is
+truly trivial, e.g. typo fixes, removing compiler warnings, etc.

-### Sign the Contributor License Agreement
+## Discuss non-trivial contribution ideas with committers
+
+If you're considering anything more than correcting a typo or fixing a minor
+bug, please discuss it on the [spring-framework-contrib][] mailing list before
+submitting a pull request. We're happy to provide guidance, but please spend an
+hour or two researching the subject on your own including searching the mailing
+list for prior discussions.
+
+## Sign the Contributor License Agreement

 If you have not previously done so, please fill out and submit the
 [SpringSource CLA form][]. You'll receive a token when this process is complete.
@@ -37,34 +42,31 @@ your pull request:
    I have signed and agree to the terms of the SpringSource Individual
    Contributor License Agreement.

-You do not need to include your token/id. Please add the above statement to all
+You do not need to include your token/id. Please add the statement above to all
 future pull requests as well, simply so that the Spring Framework team knows
 immediately that this process is complete.

-## Create a Branch

-### Branch from `master`
+## Create your branch from `3.2.x`

-Master currently represents work toward Spring Framework 4.0. Please submit
-all pull requests there, even bug fixes and minor improvements. Backports to
-`3.2.x` will be considered on a case-by-case basis.
+If your pull request addresses a bug or improvement, please create your branch
+from Spring Framework's `3.2.x` branch. `master` is reserved for work on new features
+for the next major version of the framework. Rest assured that if your pull
+request is accepted and merged into `3.2.x`, these changes will also eventually
+be merged into `master`.


-### Use short branch names
+## Use short branch names

 Branches used when submitting pull requests should preferably be named
 according to JIRA issues, e.g. 'SPR-1234'. Otherwise, use succinct, lower-case,
 dash (-) delimited names, such as 'fix-warnings', 'fix-typo', etc. In
 [fork-and-edit][] cases, the GitHub default 'patch-1' is fine as well. This is
 important, because branch names show up in the merge commits that result from
-accepting pull requests and should be as expressive and concise as possible.
+accepting pull requests, and should be as expressive and concise as possible.

-## Use Spring Framework Code Style

-The complete [Spring Framework Code Style][] reference is available on the wiki, but
-here's a quick summary:
-
-### Mind the whitespace
+## Mind the whitespace

 Please carefully follow the whitespace and formatting conventions already
 present in the framework.
@@ -76,16 +78,16 @@ present in the framework.
 1. Aim to wrap code at 90 characters, but favor readability over wrapping
 1. Preserve existing formatting; i.e. do not reformat code for its own sake
 1. Search the codebase using `git grep` and other tools to discover common
-    naming conventions, etc.
+   naming conventions, etc.
 1. Latin-1 (ISO-8859-1) encoding for Java sources; use `native2ascii` to convert
-    if necessary
+   if necessary


-### Add Apache license header to all new classes
+## Add Apache license header to all new classes

 ```java
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -103,42 +105,40 @@ present in the framework.
 package ...;
 ```

-### Update Apache license header in modified files as necessary
+## Update Apache license header to modified files as necessary

 Always check the date range in the license header. For example, if you've
-modified a file in 2014 whose header still reads:
+modified a file in 2013 whose header still reads

 ```java
 * Copyright 2002-2011 the original author or authors.
 ```

-Then be sure to update it to 2014 accordingly:
+then be sure to update it to 2013 appropriately

 ```java
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
 ```

-### Use @since tags for newly-added public API types and methods
+## Use @since tags for newly-added public API types and methods

-For example:
+e.g.

 ```java
 /**
 * ...
 *
 * @author First Last
- * @since 4.0
+ * @since 3.2
 * @see ...
 */
 ```

-## Prepare Your Commit
+## Submit JUnit test cases for all behavior changes

-### Submit JUnit test cases for all behavior changes
-
-Search the codebase to find related tests and add additional `@Test` methods
-as appropriate. It is also acceptable to submit test cases on a per JIRA issue
-basis, for example:
+Search the codebase to find related unit tests and add additional @Test methods
+within. It is also acceptable to submit test cases on a per JIRA issue basis,
+e.g.

 ```java
 package org.springframework.beans.factory.support;
@@ -163,15 +163,15 @@ public class Spr8954Tests {
 ```


-### Squash commits
+## Squash commits

-Use `git rebase --interactive --autosquash`, `git add --patch`, and other tools
-to "squash" multiple commits into a single atomic commit. In addition to the man
-pages for git, there are many resources online to help you understand how these
-tools work. The [Rewriting History section of Pro Git][] provides a good overview.
+Use `git rebase --interactive`, `git add --patch` and other tools to "squash"
+multiple commits into atomic changes. In addition to the man pages for git,
+there are many resources online to help you understand how these tools work.
+Here is one: http://book.git-scm.com/4_interactive_rebasing.html.


-### Use real name in git commits
+## Use real name in git commits

 Please configure git to use your real first and last name for any commits you
 intend to submit as pull requests. For example, this is not acceptable:
@@ -183,26 +183,26 @@ submitted against the SpringSource contributor license agreement:

    Author: First Last <user@mail.com>

-This helps ensure traceability against the CLA and also goes a long way to
+This helps ensure traceability against the CLA, and also goes a long way to
 ensuring useful output from tools like `git shortlog` and others.

-You can configure this via the account admin area in GitHub (useful for
-fork-and-edit cases); _globally_ on your machine with
+You can configure this globally via the account admin area GitHub (useful for
+fork-and-edit cases); globally with

    git config --global user.name "First Last"
    git config --global user.email user@mail.com

-or _locally_ for the `spring-framework` repository only by omitting the
-'--global' flag:
+or locally for the spring-framework repository only by omitting the '--global'
+flag:

    cd spring-framework
    git config user.name "First Last"
    git config user.email user@mail.com


-### Format commit messages
+## Format commit messages

-Please read and follow the [Commit Guidelines section of Pro Git][].
+Please read and follow the [commit guidelines section of Pro Git][].

 Most importantly, please format your commit messages in the following way
 (adapted from the commit template in the link above):
@@ -227,33 +227,31 @@ Most importantly, please format your commit messages in the following way


 1. Use imperative statements in the subject line, e.g. "Fix broken Javadoc link"
-1. Begin the subject line with a capitalized verb, e.g. "Add, Prune, Fix,
-    Introduce, Avoid, etc."
+1. Begin the subject line sentence with a capitalized verb, e.g. "Add, Prune,
+   Fix, Introduce, Avoid, etc."
 1. Do not end the subject line with a period
-1. Restrict the subject line to 50 characters or less if possible
+1. Keep the subject line to 50 characters or less if possible
 1. Wrap lines in the body at 72 characters or less
 1. Mention associated JIRA issue(s) at the end of the commit comment, prefixed
-    with "Issue: " as above
+   with "Issue: " as above
 1. In the body of the commit message, explain how things worked before this
-    commit, what has changed, and how things work now
+   commit, what has changed, and how things work now

 For examples of this style, issue a `git log --author=cbeams` in the
-`spring-framework` git repository. For convenience, here are several such commits:
+spring-framework git repository. For convenience, here are several such commits:

- https://github.com/spring-projects/spring-framework/commit/08e2669b84ec0faa2f7904441fe39ac70b65b078
- https://github.com/spring-projects/spring-framework/commit/1d9d3e6ff79ce9f0eca03b02cd1df705925575da
- https://github.com/spring-projects/spring-framework/commit/8e0b1c3a5f957af3049cfa0438317177e16d6de6
- https://github.com/spring-projects/spring-framework/commit/b787a68f2050df179f7036b209aa741230a02477
+https://github.com/SpringSource/spring-framework/commit/08e2669b84ec0faa2f7904441fe39ac70b65b078
+https://github.com/SpringSource/spring-framework/commit/1d9d3e6ff79ce9f0eca03b02cd1df705925575da
+https://github.com/SpringSource/spring-framework/commit/8e0b1c3a5f957af3049cfa0438317177e16d6de6
+https://github.com/SpringSource/spring-framework/commit/b787a68f2050df179f7036b209aa741230a02477

-## Run the Final Checklist
+## Run all tests prior to submission

-### Run all tests prior to submission
-
-See the [building from source][] section of the `README` for instructions. Make
+See the [building from source][] section of the README for instructions. Make
 sure that all tests pass prior to submitting your pull request.


-### Submit your pull request
+## Submit your pull request

 Subject line:

@@ -265,7 +263,7 @@ In the body:
 1. Explain your use case. What led you to submit this change? Why were existing
    mechanisms in the framework insufficient? Make a case that this is a
    general-purpose problem and that yours is a general-purpose solution, etc.
-1. Add any additional information and ask questions; start a conversation or
+1. Add any additional information and ask questions; start a conversation, or
    continue one from JIRA
 1. Mention the JIRA issue ID
 1. Also mention that you have submitted the CLA as described above
@@ -276,12 +274,12 @@ the commit message. This is fine, but please also include the items above in the
 body of the request.


-### Mention your pull request on the associated JIRA issue
+## Mention your pull request on the associated JIRA issue

 Add a comment to the associated JIRA issue(s) linking to your new pull request.


-### Expect discussion and rework
+## Expect discussion and rework

 The Spring team takes a very conservative approach to accepting contributions to
 the framework. This is to keep code quality and stability as high as possible,
@@ -293,15 +291,13 @@ strongly recommend discussing any serious submissions with the Spring Framework
 team _prior_ to engaging in serious development work.

 Note that you can always force push (`git push -f`) reworked / rebased commits
-against the branch used to submit your pull request. In other words, you do not
-need to issue a new pull request when asked to make changes.
+against the branch used to submit your pull request. i.e. you do not need to
+issue a new pull request when asked to make changes.

 [help documentation]: http://help.github.com/send-pull-requests
-[JIRA issue tracker]: https://jira.spring.io/browse/SPR
+[JIRA issue tracker]: https://jira.springsource.org/browse/SPR
 [spring-framework-contrib]: https://groups.google.com/forum/#!forum/spring-framework-contrib
 [SpringSource CLA form]: https://support.springsource.com/spring_committer_signup
 [fork-and-edit]: https://github.com/blog/844-forking-with-the-edit-button
-[Spring Framework Code Style]: https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Code-Style
-[Rewriting History section of Pro Git]: http://git-scm.com/book/en/Git-Tools-Rewriting-History
-[Commit Guidelines section of Pro Git]: http://git-scm.com/book/en/Distributed-Git-Contributing-to-a-Project#Commit-Guidelines
-[building from source]: https://github.com/spring-projects/spring-framework#building-from-source
+[commit guidelines section of Pro Git]: http://progit.org/book/ch5-2.html#commit_guidelines
+[building from source]: https://github.com/SpringSource/spring-framework#building-from-source
@@ -7,10 +7,12 @@ can focus on application-level business logic, without unnecessary ties to
 specific deployment environments.

 The framework also serves as the foundation for [Spring Integration][], [Spring
-Batch][] and the rest of the Spring [family of projects][]. Browse the repositories
-under the [Spring organization][] on GitHub for a full list.
+Batch][] and the rest of the Spring [family of projects][]. Browse the
+repositories under the [SpringSource organization][] on GitHub for a full list.

-## Downloading Artifacts
+[.NET][] and [Python][] variants are available as well.
+
+## Downloading artifacts
 See [downloading Spring artifacts][] for Maven repository information. Unable to
 use Maven or other transitive dependency management tools? See [building a
 distribution with dependencies][].
@@ -18,7 +20,7 @@ distribution with dependencies][].
 ## Documentation
 See the current [Javadoc][] and [reference docs][].

-## Getting Support
+## Getting support
 Check out the [Spring forums][] and the [spring][spring tag] and
 [spring-mvc][spring-mvc tag] tags on [Stack Overflow][]. [Commercial support][]
 is available too.
@@ -30,30 +32,23 @@ bug? Please consider submitting a reproduction project via the
 [spring-framework-issues][] GitHub repository. The [readme][] there provides
 simple step-by-step instructions.

-## Building from Source
+## Building from source
 The Spring Framework uses a [Gradle][]-based build system. In the instructions
 below, [`./gradlew`][] is invoked from the root of the source tree and serves as
-a cross-platform, self-contained bootstrap mechanism for the build.
+a cross-platform, self-contained bootstrap mechanism for the build. The only
+prerequisites are [Git][] and JDK 1.7+.

-### Prerequisites
+### check out sources
+`git clone git://github.com/SpringSource/spring-framework.git`

-[Git][] and [JDK 8 update 20 or later][JDK8 build]
+### compile and test, build all jars, distribution zips and docs
+`./gradlew build`

-Be sure that your `JAVA_HOME` environment variable points to the `jdk1.8.0` folder
-extracted from the JDK download.
-
-### Check out sources
-`git clone git@github.com:spring-projects/spring-framework.git`
-
-### Import sources into your IDE
-Run `./import-into-eclipse.sh` or read `import-into-idea.md` as appropriate.
-> **Note:** Per the prerequisites above, ensure that you have JDK 8 configured properly in your IDE.
-
-### Install all spring-\* jars into your local Maven cache
+### install all spring-\* jars into your local Maven cache
 `./gradlew install`

-### Compile and test; build all jars, distribution zips, and docs
-`./gradlew build`
+### import sources into your IDE
+Run `./import-into-eclipse.sh` or read `import-into-idea.md` as appropriate.

 ... and discover more commands with `./gradlew tasks`. See also the [Gradle
 build and release FAQ][].
@@ -61,41 +56,41 @@ build and release FAQ][].
 ## Contributing
 [Pull requests][] are welcome; see the [contributor guidelines][] for details.

-## Staying in Touch
-Follow [@SpringCentral][] as well as [@SpringFramework][] and its [team members][]
-on Twitter. In-depth articles can be found at [The Spring Blog][], and releases
-are announced via our [news feed][].
+## Staying in touch
+Follow [@springframework][] and its [team members][] on Twitter. In-depth
+articles can be found at the SpringSource [team blog][], and releases are
+announced via our [news feed][].

 ## License
 The Spring Framework is released under version 2.0 of the [Apache License][].

-[Spring Integration]: https://github.com/spring-projects/spring-integration
-[Spring Batch]: https://github.com/spring-projects/spring-batch
-[family of projects]: http://spring.io/projects
-[Spring organization]: https://github.com/spring-projects
-[downloading Spring artifacts]: https://github.com/spring-projects/spring-framework/wiki/Downloading-Spring-artifacts
-[building a distribution with dependencies]: https://github.com/spring-projects/spring-framework/wiki/Building-a-distribution-with-dependencies
-[Javadoc]: http://docs.spring.io/spring-framework/docs/current/javadoc-api/
-[reference docs]: http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/
-[Spring forums]: http://forum.spring.io/
+[Spring Integration]: https://github.com/SpringSource/spring-integration
+[Spring Batch]: https://github.com/SpringSource/spring-batch
+[family of projects]: http://springsource.org/projects
+[SpringSource organization]: https://github.com/SpringSource
+[.NET]: https://github.com/SpringSource/spring-net
+[Python]: https://github.com/SpringSource/spring-python
+[downloading Spring artifacts]: https://github.com/SpringSource/spring-framework/wiki/Downloading-Spring-artifacts
+[building a distribution with dependencies]: https://github.com/SpringSource/spring-framework/wiki/Building-a-distribution-with-dependencies
+[Javadoc]: http://static.springsource.org/spring-framework/docs/current/javadoc-api
+[reference docs]: http://static.springsource.org/spring-framework/docs/current/spring-framework-reference
+[Spring forums]: http://forum.springsource.org
 [spring tag]: http://stackoverflow.com/questions/tagged/spring
 [spring-mvc tag]: http://stackoverflow.com/questions/tagged/spring-mvc
 [Stack Overflow]: http://stackoverflow.com/faq
-[Commercial support]: http://spring.io/services
-[Spring Framework JIRA]: https://jira.spring.io/browse/SPR
-[the lifecycle of an issue]: https://github.com/spring-projects/spring-framework/wiki/The-Lifecycle-of-an-Issue
-[spring-framework-issues]: https://github.com/spring-projects/spring-framework-issues#readme
-[readme]: https://github.com/spring-projects/spring-framework-issues#readme
+[Commercial support]: http://springsource.com/support/springsupport
+[Spring Framework JIRA]: http://jira.springsource.org/browse/SPR
+[the lifecycle of an issue]: https://github.com/cbeams/spring-framework/wiki/The-Lifecycle-of-an-Issue
+[spring-framework-issues]: https://github.com/SpringSource/spring-framework-issues#readme
+[readme]: https://github.com/SpringSource/spring-framework-issues#readme
 [Gradle]: http://gradle.org
 [`./gradlew`]: http://vimeo.com/34436402
 [Git]: http://help.github.com/set-up-git-redirect
-[JDK8 build]: http://www.oracle.com/technetwork/java/javase/downloads
-[Gradle build and release FAQ]: https://github.com/spring-projects/spring-framework/wiki/Gradle-build-and-release-FAQ
+[Gradle build and release FAQ]: https://github.com/SpringSource/spring-framework/wiki/Gradle-build-and-release-FAQ
 [Pull requests]: http://help.github.com/send-pull-requests
-[contributor guidelines]: https://github.com/spring-projects/spring-framework/blob/master/CONTRIBUTING.md
-[@SpringFramework]: https://twitter.com/springframework
-[@SpringCentral]: https://twitter.com/springcentral
-[team members]: https://twitter.com/springframework/lists/team/members
-[The Spring Blog]: http://spring.io/blog/
-[news feed]: http://spring.io/blog/category/news
+[contributor guidelines]: https://github.com/SpringSource/spring-framework/blob/master/CONTRIBUTING.md
+[@springframework]: http://twitter.com/springframework
+[team members]: http://twitter.com/springframework/team/members
+[team blog]: http://blog.springsource.org
+[news feed]: http://www.springsource.org/news-events
 [Apache License]: http://www.apache.org/licenses/LICENSE-2.0
@@ -21,17 +21,20 @@ import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ProjectDependency;
 import org.gradle.api.artifacts.maven.Conf2ScopeMapping
 import org.gradle.api.plugins.MavenPlugin
+import org.gradle.api.tasks.*
 import org.gradle.plugins.ide.eclipse.EclipsePlugin
+import org.gradle.plugins.ide.eclipse.model.EclipseClasspath;
 import org.gradle.plugins.ide.idea.IdeaPlugin
 import org.gradle.api.invocation.*

+
 /**
 * Gradle plugin that allows projects to merged together. Primarily developed to
- * allow Spring to support multiple incompatible versions of third-party
+ * allow Spring to support multiple multiple incompatible versions of third-party
 * dependencies (for example Hibernate v3 and v4).
 * <p>
 * The 'merge' extension should be used to define how projects are merged, for example:
- * <pre class="code">
+ * <pre>
 * configure(subprojects) {
 *     apply plugin: MergePlugin
 * }
@@ -68,18 +71,18 @@ class MergePlugin implements Plugin<Project> {
 		Configuration runtimeMerge = project.configurations.create("runtimeMerge")

 		// Ensure the IDE can reference merged projects
-		project.eclipse.classpath.plusConfigurations += [ runtimeMerge ]
-		project.idea.module.scopes.PROVIDED.plus += [ runtimeMerge ]
+		project.eclipse.classpath.plusConfigurations += [runtimeMerge]
+		project.idea.module.scopes.PROVIDED.plus += runtimeMerge

 		// Hook to perform the actual merge logic
 		project.afterEvaluate{
-			if (it.merge.into != null) {
+			if(it.merge.into != null) {
 				setup(it)
 			}
 		}

 		// Hook to build runtimeMerge dependencies
-		if (!attachedProjectsEvaluated) {
+		if(!attachedProjectsEvaluated) {
 			project.gradle.projectsEvaluated{
 				postProcessProjects(it)
 			}
@@ -99,7 +102,7 @@ class MergePlugin implements Plugin<Project> {
 		// invoking a task will invoke the task with the same name on 'into' project
 		["sourcesJar", "jar", "javadocJar", "javadoc", "install", "artifactoryPublish"].each {
 			def task = project.tasks.findByPath(it)
-			if (task) {
+			if(task) {
 				task.enabled = false
 				task.dependsOn(project.merge.into.tasks.findByPath(it))
 			}
@@ -117,7 +120,7 @@ class MergePlugin implements Plugin<Project> {
 	private void setupMaven(Project project) {
 		project.configurations.each { configuration ->
 			Conf2ScopeMapping mapping = project.conf2ScopeMappings.getMapping([configuration])
-			if (mapping.scope) {
+			if(mapping.scope) {
 				Configuration intoConfiguration = project.merge.into.configurations.create(
 					project.name + "-" + configuration.name)
 				configuration.excludeRules.each {
@@ -128,7 +131,7 @@ class MergePlugin implements Plugin<Project> {
 				configuration.dependencies.each {
 					def intoCompile = project.merge.into.configurations.getByName("compile")
 					// Protect against changing a compile scope dependency (SPR-10218)
-					if (!intoCompile.dependencies.contains(it)) {
+					if(!intoCompile.dependencies.contains(it)) {
 						intoConfiguration.dependencies.add(it)
 					}
 				}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -21,6 +21,7 @@ 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.
@@ -40,10 +41,11 @@ class TestSourceSetDependenciesPlugin implements Plugin<Project> {
 		}
 	}

-	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
-		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
+	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies,
+			Project project) {
+		for(def configurationName in ["compile", "optional", "provided", "testCompile"]) {
 			Configuration configuration = project.getConfigurations().findByName(configurationName)
-			if (configuration) {
+			if(configuration) {
 				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
 					projectDependencies.add(it)
 					collectProjectDependencies(projectDependencies, it.dependencyProject)
@@ -1 +1 @@
-version=4.1.10.BUILD-SNAPSHOT
+version=3.2.7.RELEASE
@@ -5,19 +5,13 @@ 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) {
+		if(matcher) {
 			def projectName = matcher[0][1]
 			def path = "/${projectName}"
 			if(!classpath.entries.find { e -> e instanceof ProjectDependency && e.path == path }) {
@@ -47,20 +41,10 @@ eclipse.classpath.file.whenMerged { classpath ->
 	}
 }

-// 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
+// Allow projects to be used as WPT modules
 eclipse.project.natures "org.eclipse.wst.common.project.facet.core.nature"

+
 // Include project specific settings
 task eclipseSettings(type: Copy) {
 	from rootProject.files(
@@ -97,6 +81,7 @@ tasks["eclipse"].dependsOn(eclipseSettings, eclipseWstComponent)


 // Filter 'build' folder
+
 eclipse.project.file.withXml {
 	def node = it.asNode()

@@ -22,34 +22,30 @@ def customizePom(pom, gradleProject) {
 		generatedPom.project {
 			name = gradleProject.description
 			description = gradleProject.description
-			url = "https://github.com/spring-projects/spring-framework"
+			url = "https://github.com/SpringSource/spring-framework"
 			organization {
-				name = "Spring IO"
-				url = "https://projects.spring.io/spring-framework"
+				name = "SpringSource"
+				url = "http://springsource.org/spring-framework"
 			}
 			licenses {
 				license {
 					name "The Apache Software License, Version 2.0"
-					url "https://www.apache.org/licenses/LICENSE-2.0.txt"
+					url "http://www.apache.org/licenses/LICENSE-2.0.txt"
 					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"
+				url = "https://github.com/SpringSource/spring-framework"
+				connection = "scm:git:git://github.com/SpringSource/spring-framework"
+				developerConnection = "scm:git:git://github.com/SpringSource/spring-framework"
 			}
 			developers {
 				developer {
 					id = "jhoeller"
 					name = "Juergen Hoeller"
-					email = "jhoeller@pivotal.io"
+					email = "jhoeller@gopivotal.com"
 				}
 			}
-			issueManagement {
-				system = "Jira"
-				url = "https://jira.springsource.org/browse/SPR"
-			}
 		}
 	}
 }
@@ -1,6 +1,6 @@
-#Wed Apr 30 13:06:57 CEST 2014
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
+#Tue Jul 30 09:29:28 PDT 2013
 zipStoreBase=GRADLE_USER_HOME
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.6-bin.zip
+distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-1.12-all.zip
+distributionBase=GRADLE_USER_HOME
@@ -7,7 +7,7 @@
 ##############################################################################

 # 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"
+GRADLE_OPTS="-XX:MaxPermSize=1024m -Xmx1024m $GRADLE_OPTS"
 DEFAULT_JVM_OPTS=""

 APP_NAME="Gradle"
@@ -9,7 +9,7 @@
 if "%OS%"=="Windows_NT" setlocal

@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 GRADLE_OPTS=-XX:MaxPermSize=1024m -Xmx1024m -XX:MaxHeapSize=256m %GRADLE_OPTS%
 set DEFAULT_JVM_OPTS=

 set DIRNAME=%~dp0
@@ -17,7 +17,7 @@ echo been tested against STS %STS_TEST_VERSION%), but at the minimum you will
 echo need Eclipse + AJDT.
 echo.
 echo If you need to download and install STS, please do that now by
-echo visiting https://spring.io/tools/sts/all 
+echo visiting http://springsource.org/downloads/sts
 echo.
 echo Otherwise, press enter and we'll begin.

@@ -1,37 +1,22 @@
+STS_TEST_VERSION='2.9.2.RELEASE'
+
 cd `dirname $0`
 clear
 cat <<EOM

------------------------------------------------------------------------
-Spring Framework - Eclipse/STS Project Import Guide
+-----------------------------------------------------------------------
+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 will guide you through the process of importing the
+Spring Framework sources into Eclipse/STS. It is recommended that you
+have a recent version of the SpringSource Tool Suite (this script has
+been tested against STS $STS_TEST_VERSION), but at the minimum you will
+need Eclipse + AJDT.

-This script has been tested against:
+If you need to download and install STS, please do that now by
+visiting http://springsource.org/downloads/sts

- STS:     3.6.3.RELEASE (Eclipse Luna SR1 4.4.1)
- AJDT:    2.2.4.e44x-20141118-0700 (Luna 4.4)
-
-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
-
-If you need to install a recent CI build for AJDT (i.e., so that the
-spring-aspects module properly compiles in Eclipse/STS), click on the
-"Artifacts" tab of a successful CI build and copy the link to the
-"update site" which you can then use to install or update AJDT within
-Eclipse/STS.
-
- AJDT CI builds: https://build.spring.io/browse/AJDT-AE44
-
-Once Eclipse/STS is installed, press enter, and we'll begin.
+Otherwise, press enter and we'll begin.
 EOM

 read
@@ -46,14 +31,14 @@ COMMAND="./gradlew 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 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:

@@ -68,16 +53,16 @@ $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.
+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
@@ -88,13 +73,13 @@ COMMAND="./gradlew :eclipse"

 cat <<EOM

------------------------------------------------------------------------
-STEP 3: Generate root project Eclipse metadata
+-----------------------------------------------------------------------
+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.
+Unfortunately, Eclipse does not allow for importing project
+hierarchies, so we had to skip root project metadata generation in the
+during step 1. In this step we simply generate root project metadata
+so you can import it in the next step.

 The command run will be:

@@ -108,11 +93,11 @@ 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.
+root project.

 Press enter when complete, and move on to the final step.
 EOM
@@ -120,14 +105,14 @@ 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.
+- 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.

@@ -1,22 +1,21 @@
-The following has been tested against Intellij IDEA 13.1
+The following has been tested against Intellij IDEA 12.0

 ## Steps

 _Within your locally cloned spring-framework working directory:_

-1. Pre-compile `spring-oxm` with `./gradlew cleanIdea :spring-oxm:compileTestJava`
-2. Import into IDEA (File->import project->import from external model->Gradle)
-3. Set the Project JDK as appropriate (1.8+)
-4. Exclude the `spring-aspects` module (Go to File->Project Structure->Modules)
+1. Generate IDEA metadata with `./gradlew :spring-oxm:compileTestJava cleanIdea idea`
+2. Import into IDEA as usual
+3. Set the Project JDK as appropriate
+4. Add git support
 5. Code away

 ## Known issues

-1. `spring-oxm` should be pre-compiled since it's using repackaged dependencies (see *RepackJar tasks)
-2. `spring-aspects` does not compile out of the box due to references to aspect types unknown to IDEA.
+1. `spring-aspects` does not compile out of the box due to references to aspect types unknown to IDEA.
 See http://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the 'spring-aspects'
-should be excluded from the overall project to avoid compilation errors.
-3. While all JUnit tests pass from the command line with Gradle, many will fail when run from IDEA.
+module has been excluded from the overall project to avoid compilation errors.
+2. While all JUnit tests pass from the command line with Gradle, many will fail when run from IDEA.
 Resolving this is a work in progress. If attempting to run all JUnit tests from within IDEA, you will
 likely need to set the following VM options to avoid out of memory errors:
    -XX:MaxPermSize=2048m -Xmx2048m -XX:MaxHeapSize=2048m
@@ -3,7 +3,6 @@ rootProject.name = "spring"
 include "spring-aop"
 include "spring-aspects"
 include "spring-beans"
-include "spring-beans-groovy"
 include "spring-context"
 include "spring-context-support"
 include "spring-core"
@@ -12,17 +11,17 @@ include "spring-instrument"
 include "spring-instrument-tomcat"
 include "spring-jdbc"
 include "spring-jms"
-include "spring-messaging"
 include "spring-orm"
 include "spring-orm-hibernate4"
 include "spring-oxm"
+include "spring-struts"
 include "spring-test"
+include "spring-test-mvc"
 include "spring-tx"
 include "spring-web"
 include "spring-webmvc"
 include "spring-webmvc-portlet"
-include "spring-webmvc-tiles2"
-include "spring-websocket"
+include "spring-webmvc-tiles3"
 include "spring-framework-bom"

 // Exposes gradle buildSrc for IDE support
@@ -34,6 +34,6 @@ public interface IntroductionInfo {
 	 * Return the additional interfaces introduced by this Advisor or Advice.
 	 * @return the introduced interfaces
 	 */
-	Class<?>[] getInterfaces();
+	Class[] getInterfaces();

 }
@@ -39,7 +39,6 @@ public interface TargetSource extends TargetClassAware {
 	 * target class.
 	 * @return the type of targets returned by this {@link TargetSource}
 	 */
-	@Override
 	Class<?> getTargetClass();

 	/**
@@ -34,8 +34,7 @@ class TrueClassFilter implements ClassFilter, Serializable {
 	private TrueClassFilter() {
 	}

-	@Override
-	public boolean matches(Class<?> clazz) {
+	public boolean matches(Class clazz) {
 		return true;
 	}

@@ -35,18 +35,15 @@ class TrueMethodMatcher implements MethodMatcher, Serializable {
 	private TrueMethodMatcher() {
 	}

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

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

-	@Override
-	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
+	public boolean matches(Method method, Class targetClass, Object[] args) {
 		// Should never be invoked as isRuntime returns false.
 		throw new UnsupportedOperationException();
 	}
@@ -34,12 +34,10 @@ class TruePointcut implements Pointcut, Serializable {
 	private TruePointcut() {
 	}

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

-	@Override
 	public MethodMatcher getMethodMatcher() {
 		return MethodMatcher.TRUE;
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -37,8 +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.core.PrioritizedParameterNameDiscoverer;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -119,9 +120,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/** Non-null if after returning advice binds the return value */
 	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
@@ -202,7 +203,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		return this.aspectInstanceFactory.getAspectClassLoader();
 	}

-	@Override
 	public int getOrder() {
 		return this.aspectInstanceFactory.getOrder();
 	}
@@ -212,7 +212,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		this.aspectName = name;
 	}

-	@Override
 	public String getAspectName() {
 		return this.aspectName;
 	}
@@ -224,7 +223,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		this.declarationOrder = order;
 	}

-	@Override
 	public int getDeclarationOrder() {
 		return this.declarationOrder;
 	}
@@ -240,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]);
@@ -253,7 +251,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (argumentNames != null) {
 			if (aspectJAdviceMethod.getParameterTypes().length == argumentNames.length + 1) {
 				// May need to add implicit join point arg name...
-				Class<?> firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
+				Class firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
 				if (firstArgType == JoinPoint.class ||
 						firstArgType == ProceedingJoinPoint.class ||
 						firstArgType == JoinPoint.StaticPart.class) {
@@ -292,7 +290,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}

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

@@ -326,7 +324,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}

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

@@ -364,7 +362,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}

 		int numUnboundArgs = this.adviceInvocationArgumentCount;
-		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		Class[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
 			numUnboundArgs--;
 		}
@@ -380,7 +378,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		this.argumentsIntrospected = true;
 	}

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

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

-	private boolean maybeBindJoinPointStaticPart(Class<?> candidateParameterType) {
+	private boolean maybeBindJoinPointStaticPart(Class candidateParameterType) {
 		if (candidateParameterType.equals(JoinPoint.StaticPart.class)) {
 			this.joinPointStaticPartArgumentIndex = 0;
 			return true;
@@ -434,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);
@@ -509,8 +509,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			numParametersToRemove++;
 		}
 		String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
-		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
-		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		Class[] pointcutParameterTypes = new Class[pointcutParameterNames.length];
+		Class[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();

 		int index = 0;
 		for (int i = 0; i < this.argumentNames.length; i++) {
@@ -678,8 +678,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			this.adviceMethod = adviceMethod;
 		}

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

@@ -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;

@@ -141,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("&&");
@@ -171,7 +173,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 */
 	private String pointcutExpression;

-	private Class<?>[] argumentTypes;
+	private Class[] argumentTypes;

 	private String[] parameterNameBindings;

@@ -220,7 +222,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * @param method the target {@link Method}
 	 * @return the parameter names
 	 */
-	@Override
 	public String[] getParameterNames(Method method) {
 		this.argumentTypes = method.getParameterTypes();
 		this.numberOfRemainingUnboundArguments = this.argumentTypes.length;
@@ -308,8 +309,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * @throws UnsupportedOperationException if
 	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
 	 */
-	@Override
-	public String[] getParameterNames(Constructor<?> ctor) {
+	public String[] getParameterNames(Constructor ctor) {
 		if (this.raiseExceptions) {
 			throw new UnsupportedOperationException("An advice method can never be a constructor");
 		}
@@ -729,7 +729,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Return {@code true} 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]);
 	}

@@ -757,7 +757,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Find the argument index with the given type, and bind the given
 	 * {@code varName} 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);
@@ -37,7 +37,6 @@ public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodI
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();
@@ -47,12 +46,10 @@ public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodI
 		}
 	}

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

-	@Override
 	public boolean isAfterAdvice() {
 		return true;
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * 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.
@@ -40,12 +40,10 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implement
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

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

-	@Override
 	public boolean isAfterAdvice() {
 		return true;
 	}
@@ -55,7 +53,6 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implement
 		setReturningNameNoCheck(name);
 	}

-	@Override
 	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
 		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
 			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
@@ -71,34 +68,12 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implement
 	 * @return whether to invoke the advice method for the given return value
 	 */
 	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
-		Class<?> type = getDiscoveredReturningType();
+		Class type = getDiscoveredReturningType();
 		Type genericType = getDiscoveredReturningGenericType();
-		// If we aren't dealing with a raw type, check if generic parameters are assignable.
-		return (matchesReturnValue(type, method, returnValue) &&
+		// 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())));
 	}

-	/**
-	 * Following AspectJ semantics, if a return value is null (or return type is void),
-	 * then the return type of target method should be used to determine whether advice
-	 * is invoked or not. Also, even if the return type is void, if the type of argument
-	 * declared in the advice method is Object, then the advice must still get invoked.
-	 * @param type the type of argument declared in advice method
-	 * @param method the advice method
-	 * @param returnValue the return value of the target method
-	 * @return whether to invoke the advice method for the given return value and type
-	 */
-	private boolean matchesReturnValue(Class<?> type, Method method, Object returnValue) {
-		if (returnValue != null) {
-			return ClassUtils.isAssignableValue(type, returnValue);
-		}
-		else if (type.equals(Object.class) && method.getReturnType().equals(void.class)) {
-			return true;
-		}
-		else{
-			return ClassUtils.isAssignable(type, method.getReturnType());
-		}
-	}
-
 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -37,12 +37,10 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

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

-	@Override
 	public boolean isAfterAdvice() {
 		return true;
 	}
@@ -52,7 +50,6 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements
 		setThrowingNameNoCheck(name);
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();
@@ -70,7 +67,8 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements
 	 * is only invoked if the thrown exception is a subtype of the given throwing type.
 	 */
 	private boolean shouldInvokeOnThrowing(Throwable t) {
-		return getDiscoveredThrowingType().isAssignableFrom(t.getClass());
+		Class throwingType = getDiscoveredThrowingType();
+		return throwingType.isAssignableFrom(t.getClass());
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -41,12 +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;
 	}
@@ -57,7 +55,6 @@ public class AspectJAroundAdvice extends AbstractAspectJAdvice implements Method
 	}


-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		if (!(mi instanceof ProxyMethodInvocation)) {
 			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,7 +19,6 @@ package org.springframework.aop.aspectj;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.lang.reflect.Method;
-import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
@@ -30,6 +29,7 @@ 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;
@@ -108,8 +108,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 	private BeanFactory beanFactory;

-	private transient ClassLoader pointcutClassLoader;
-
 	private transient PointcutExpression pointcutExpression;

 	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
@@ -159,19 +157,16 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		this.pointcutParameterTypes = types;
 	}

-	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 	}


-	@Override
 	public ClassFilter getClassFilter() {
 		checkReadyToMatch();
 		return this;
 	}

-	@Override
 	public MethodMatcher getMethodMatcher() {
 		checkReadyToMatch();
 		return this;
@@ -187,13 +182,20 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			throw new IllegalStateException("Must set property 'expression' before attempting to match");
 		}
 		if (this.pointcutExpression == null) {
-			this.pointcutClassLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
-					((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
-					ClassUtils.getDefaultClassLoader());
-			this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
+			this.pointcutExpression = buildPointcutExpression();
 		}
 	}

+	/**
+	 * Build the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression buildPointcutExpression() {
+		ClassLoader cl = (this.beanFactory instanceof ConfigurableBeanFactory ?
+				((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
+				ClassUtils.getDefaultClassLoader());
+		return buildPointcutExpression(cl);
+	}
+
 	/**
 	 * Build the underlying AspectJ pointcut expression.
 	 */
@@ -204,7 +206,8 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			pointcutParameters[i] = parser.createPointcutParameter(
 					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
 		}
-		return parser.parsePointcutExpression(replaceBooleanOperators(getExpression()),
+		return parser.parsePointcutExpression(
+				replaceBooleanOperators(getExpression()),
 				this.pointcutDeclarationScope, pointcutParameters);
 	}

@@ -242,29 +245,28 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return this.pointcutExpression;
 	}

-	@Override
 	public boolean matches(Class<?> targetClass) {
 		checkReadyToMatch();
 		try {
+			return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
+		}
+		catch (ReflectionWorldException rwe) {
+			logger.debug("PointcutExpression matching rejected target class", rwe);
 			try {
-				return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
-			}
-			catch (ReflectionWorldException ex) {
-				logger.debug("PointcutExpression matching rejected target class - trying fallback expression", ex);
 				// Actually this is still a "maybe" - treat the pointcut as dynamic if we don't know enough yet
-				PointcutExpression fallbackExpression = getFallbackPointcutExpression(targetClass);
-				if (fallbackExpression != null) {
-					return fallbackExpression.couldMatchJoinPointsInType(targetClass);
-				}
+				return getFallbackPointcutExpression(targetClass).couldMatchJoinPointsInType(targetClass);
+			}
+			catch (BCException bce) {
+				logger.debug("Fallback PointcutExpression matching rejected target class", bce);
+				return false;
 			}
 		}
 		catch (BCException ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
+			return false;
 		}
-		return false;
 	}

-	@Override
 	public boolean matches(Method method, Class<?> targetClass, boolean beanHasIntroductions) {
 		checkReadyToMatch();
 		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
@@ -293,18 +295,15 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		}
 	}

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

-	@Override
 	public boolean isRuntime() {
 		checkReadyToMatch();
 		return this.pointcutExpression.mayNeedDynamicTest();
 	}

-	@Override
 	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
 		checkReadyToMatch();
 		ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
@@ -327,41 +326,29 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		catch (IllegalStateException ex) {
 			// No current invocation...
 			// TODO: Should we really proceed here?
-			if (logger.isDebugEnabled()) {
-				logger.debug("Could not access current invocation - matching with limited context: " + ex);
-			}
+			logger.debug("Couldn't access current invocation - matching with limited context: " + ex);
 		}

-		try {
-			JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
+		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()) {
-					bindParameters(pmi, joinPointMatch);
-				}
+		/*
+		 * 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;
 			}
-
-			return joinPointMatch.matches();
-		}
-		catch (Throwable ex) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("Failed to evaluate join point for arguments " + Arrays.asList(args) +
-						" - falling back to non-match", ex);
+			if (joinPointMatch.matches()) {
+				bindParameters(pmi, joinPointMatch);
 			}
-			return false;
 		}
+		return joinPointMatch.matches();
 	}

 	protected String getCurrentProxiedBeanName() {
@@ -370,19 +357,12 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut


 	/**
-	 * Get a new pointcut expression based on a target class's loader rather than the default.
+	 * Get a new pointcut expression based on a target class's loader, rather
+	 * than the default.
 	 */
 	private PointcutExpression getFallbackPointcutExpression(Class<?> targetClass) {
-		try {
-			ClassLoader classLoader = targetClass.getClassLoader();
-			if (classLoader != null && classLoader != this.pointcutClassLoader) {
-				return buildPointcutExpression(classLoader);
-			}
-		}
-		catch (Throwable ex) {
-			logger.debug("Failed to create fallback PointcutExpression", ex);
-		}
-		return null;
+		ClassLoader classLoader = targetClass.getClassLoader();
+		return (classLoader != null ? buildPointcutExpression(classLoader) : this.pointcutExpression);
 	}

 	private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
@@ -408,51 +388,46 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		if (shadowMatch == null) {
 			synchronized (this.shadowMatchCache) {
 				// Not found - now check again with full lock...
-				PointcutExpression fallbackExpression = null;
 				Method methodToMatch = targetMethod;
-				shadowMatch = this.shadowMatchCache.get(targetMethod);
+				PointcutExpression fallbackPointcutExpression = null;
+				shadowMatch = this.shadowMatchCache.get(methodToMatch);
 				if (shadowMatch == null) {
 					try {
-						shadowMatch = this.pointcutExpression.matchesMethodExecution(methodToMatch);
+						shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
 					}
-					catch (ReflectionWorldException ex) {
+					catch (ReflectionWorld.ReflectionWorldException ex) {
 						// Failed to introspect target method, probably because it has been loaded
-						// in a special ClassLoader. Let's try the declaring ClassLoader instead...
+						// in a special ClassLoader. Let's try the original method instead...
 						try {
-							fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
-							if (fallbackExpression != null) {
-								shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
+							fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+							shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
+						}
+						catch (ReflectionWorld.ReflectionWorldException ex2) {
+							if (targetMethod == originalMethod) {
+								shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
 							}
-						}
-						catch (ReflectionWorldException ex2) {
-							fallbackExpression = null;
-						}
-					}
-					if (shadowMatch == null && targetMethod != originalMethod) {
-						methodToMatch = originalMethod;
-						try {
-							shadowMatch = this.pointcutExpression.matchesMethodExecution(methodToMatch);
-						}
-						catch (ReflectionWorldException ex3) {
-							// Could neither introspect the target class nor the proxy class ->
-							// let's try the original method's declaring class before we give up...
-							try {
-								fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
-								if (fallbackExpression != null) {
-									shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
+							else {
+								try {
+									shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
+								}
+								catch (ReflectionWorld.ReflectionWorldException ex3) {
+									// 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 ex4) {
+										shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+									}
 								}
 							}
-							catch (ReflectionWorldException ex4) {
-								fallbackExpression = null;
-							}
 						}
 					}
-					if (shadowMatch == null) {
-						shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
-					}
-					else if (shadowMatch.maybeMatches() && fallbackExpression != null) {
+					if (shadowMatch.maybeMatches() && fallbackPointcutExpression != null) {
 						shadowMatch = new DefensiveShadowMatch(shadowMatch,
-								fallbackExpression.matchesMethodExecution(methodToMatch));
+								fallbackPointcutExpression.matchesMethodExecution(methodToMatch));
 					}
 					this.shadowMatchCache.put(targetMethod, shadowMatch);
 				}
@@ -525,12 +500,10 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut

 		private static final String BEAN_DESIGNATOR_NAME = "bean";

-		@Override
 		public String getDesignatorName() {
 			return BEAN_DESIGNATOR_NAME;
 		}

-		@Override
 		public ContextBasedMatcher parse(String expression) {
 			return new BeanNameContextMatcher(expression);
 		}
@@ -552,36 +525,27 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			this.expressionPattern = new NamePattern(expression);
 		}

-		@Override
-		@SuppressWarnings("rawtypes")
-		@Deprecated
 		public boolean couldMatchJoinPointsInType(Class someClass) {
 			return (contextMatch(someClass) == FuzzyBoolean.YES);
 		}

-		@Override
-		@SuppressWarnings("rawtypes")
-		@Deprecated
 		public boolean couldMatchJoinPointsInType(Class someClass, MatchingContext context) {
 			return (contextMatch(someClass) == FuzzyBoolean.YES);
 		}

-		@Override
 		public boolean matchesDynamically(MatchingContext context) {
 			return true;
 		}

-		@Override
 		public FuzzyBoolean matchesStatically(MatchingContext context) {
 			return contextMatch(null);
 		}

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

-		private FuzzyBoolean contextMatch(Class<?> targetType) {
+		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
@@ -643,22 +607,18 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			this.other = other;
 		}

-		@Override
 		public boolean alwaysMatches() {
 			return this.primary.alwaysMatches();
 		}

-		@Override
 		public boolean maybeMatches() {
 			return this.primary.maybeMatches();
 		}

-		@Override
 		public boolean neverMatches() {
 			return this.primary.neverMatches();
 		}

-		@Override
 		public JoinPointMatch matchesJoinPoint(Object thisObject, Object targetObject, Object[] args) {
 			try {
 				return this.primary.matchesJoinPoint(thisObject, targetObject, args);
@@ -668,7 +628,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			}
 		}

-		@Override
 		public void setMatchingContext(MatchingContext aMatchContext) {
 			this.primary.setMatchingContext(aMatchContext);
 			this.other.setMatchingContext(aMatchContext);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -31,7 +31,6 @@ public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdv
 	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();


-	@Override
 	public Pointcut getPointcut() {
 		return this.pointcut;
 	}
@@ -40,24 +39,24 @@ public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdv
 		this.pointcut.setExpression(expression);
 	}

-	public String getExpression() {
-		return this.pointcut.getExpression();
-	}
-
 	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 void setParameterTypes(Class<?>[] types) {
-		this.pointcut.setParameterTypes(types);
-	}
-
-	public void setParameterNames(String... names) {
-		this.pointcut.setParameterNames(names);
+	public String getExpression() {
+		return this.pointcut.getExpression();
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -35,17 +35,14 @@ public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}

-	@Override
 	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,5 +1,5 @@
 /*
- * 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.
@@ -56,22 +56,18 @@ 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;
 	}

-	@Override
 	public int getOrder() {
 		if (this.order != null) {
 			return this.order;
@@ -48,7 +48,6 @@ public class AspectJWeaverMessageHandler implements IMessageHandler {
 	private static final Log logger = LogFactory.getLog("AspectJ Weaver");


-	@Override
 	public boolean handleMessage(IMessage message) throws AbortException {
 		Kind messageKind = message.getKind();
 		if (messageKind == IMessage.DEBUG) {
@@ -88,18 +87,15 @@ public class AspectJWeaverMessageHandler implements IMessageHandler {
 		return AJ_ID + aMessage.getMessage();
 	}

-	@Override
 	public boolean isIgnoring(Kind messageKind) {
 		// We want to see everything, and allow configuration of log levels dynamically.
 		return false;
 	}

-	@Override
 	public void dontIgnore(Kind messageKind) {
 		// We weren't ignoring anything anyway...
 	}

-	@Override
 	public void ignore(Kind kind) {
 		// We weren't ignoring anything anyway...
 	}
@@ -34,7 +34,7 @@ import org.springframework.aop.support.DelegatingIntroductionInterceptor;
 */
 public class DeclareParentsAdvisor implements IntroductionAdvisor {

-	private final Class<?> introducedInterface;
+	private final Class introducedInterface;

 	private final ClassFilter typePatternClassFilter;

@@ -47,7 +47,7 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param defaultImpl the default implementation class
 	 */
-	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> defaultImpl) {
+	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Class defaultImpl) {
 		this(interfaceType, typePattern, defaultImpl,
 			 new DelegatePerTargetObjectIntroductionInterceptor(defaultImpl, interfaceType));
 	}
@@ -58,7 +58,7 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param delegateRef the delegate implementation object
 	 */
-	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Object delegateRef) {
+	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Object delegateRef) {
 		this(interfaceType, typePattern, delegateRef.getClass(),
 			 new DelegatingIntroductionInterceptor(delegateRef));
 	}
@@ -71,14 +71,13 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param implementationClass implementation class
 	 * @param advice delegation advice
 	 */
-	private DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> implementationClass, Advice advice) {
+	private DeclareParentsAdvisor(Class interfaceType, String typePattern, Class implementationClass, Advice advice) {
 		this.introducedInterface = interfaceType;
 		ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);

 		// Excludes methods implemented.
 		ClassFilter exclusion = new ClassFilter() {
-			@Override
-			public boolean matches(Class<?> clazz) {
+			public boolean matches(Class clazz) {
 				return !(introducedInterface.isAssignableFrom(clazz));
 			}
 		};
@@ -88,29 +87,24 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	}


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

-	@Override
 	public void validateInterfaces() throws IllegalArgumentException {
 		// Do nothing
 	}

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

-	@Override
 	public Advice getAdvice() {
 		return this.advice;
 	}

-	@Override
-	public Class<?>[] getInterfaces() {
-		return new Class<?>[] {this.introducedInterface};
+	public Class[] getInterfaces() {
+		return new Class[] {this.introducedInterface};
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 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.
@@ -27,8 +27,7 @@ import org.aspectj.lang.reflect.SourceLocation;
 import org.aspectj.runtime.internal.AroundClosure;

 import org.springframework.aop.ProxyMethodInvocation;
-import org.springframework.core.DefaultParameterNameDiscoverer;
-import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
 import org.springframework.util.Assert;

 /**
@@ -52,8 +51,6 @@ import org.springframework.util.Assert;
 */
 public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {

-	private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
-
 	private final ProxyMethodInvocation methodInvocation;

 	private Object[] defensiveCopyOfArgs;
@@ -75,17 +72,14 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		this.methodInvocation = methodInvocation;
 	}

-	@Override
 	public void set$AroundClosure(AroundClosure aroundClosure) {
 		throw new UnsupportedOperationException();
 	}

-	@Override
 	public Object proceed() throws Throwable {
 		return this.methodInvocation.invocableClone().proceed();
 	}

-	@Override
 	public Object proceed(Object[] arguments) throws Throwable {
 		Assert.notNull(arguments, "Argument array passed to proceed cannot be null");
 		if (arguments.length != this.methodInvocation.getArguments().length) {
@@ -100,7 +94,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	/**
 	 * Returns the Spring AOP proxy. Cannot be {@code null}.
 	 */
-	@Override
 	public Object getThis() {
 		return this.methodInvocation.getProxy();
 	}
@@ -108,12 +101,10 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	/**
 	 * Returns the Spring AOP target. May be {@code null} if there is no target.
 	 */
-	@Override
 	public Object getTarget() {
 		return this.methodInvocation.getThis();
 	}

-	@Override
 	public Object[] getArgs() {
 		if (this.defensiveCopyOfArgs == null) {
 			Object[] argsSource = this.methodInvocation.getArguments();
@@ -123,7 +114,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		return this.defensiveCopyOfArgs;
 	}

-	@Override
 	public Signature getSignature() {
 		if (this.signature == null) {
 			this.signature = new MethodSignatureImpl();
@@ -131,7 +121,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		return signature;
 	}

-	@Override
 	public SourceLocation getSourceLocation() {
 		if (this.sourceLocation == null) {
 			this.sourceLocation = new SourceLocationImpl();
@@ -139,33 +128,27 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		return this.sourceLocation;
 	}

-	@Override
 	public String getKind() {
 		return ProceedingJoinPoint.METHOD_EXECUTION;
 	}

-	@Override
 	public int getId() {
 		// TODO: It's just an adapter but returning 0 might still have side effects...
 		return 0;
 	}

-	@Override
 	public JoinPoint.StaticPart getStaticPart() {
 		return this;
 	}

-	@Override
 	public String toShortString() {
 		return "execution(" + getSignature().toShortString() + ")";
 	}

-	@Override
 	public String toLongString() {
 		return "execution(" + getSignature().toLongString() + ")";
 	}

-	@Override
 	public String toString() {
 		return "execution(" + getSignature().toString() + ")";
 	}
@@ -178,72 +161,59 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,

 		private volatile String[] parameterNames;

-		@Override
 		public String getName() {
 			return methodInvocation.getMethod().getName();
 		}

-		@Override
 		public int getModifiers() {
 			return methodInvocation.getMethod().getModifiers();
 		}

-		@Override
-		public Class<?> getDeclaringType() {
+		public Class getDeclaringType() {
 			return methodInvocation.getMethod().getDeclaringClass();
 		}

-		@Override
 		public String getDeclaringTypeName() {
 			return methodInvocation.getMethod().getDeclaringClass().getName();
 		}

-		@Override
-		public Class<?> getReturnType() {
+		public Class getReturnType() {
 			return methodInvocation.getMethod().getReturnType();
 		}

-		@Override
 		public Method getMethod() {
 			return methodInvocation.getMethod();
 		}

-		@Override
-		public Class<?>[] getParameterTypes() {
+		public Class[] getParameterTypes() {
 			return methodInvocation.getMethod().getParameterTypes();
 		}

-		@Override
 		public String[] getParameterNames() {
 			if (this.parameterNames == null) {
-				this.parameterNames = parameterNameDiscoverer.getParameterNames(getMethod());
+				this.parameterNames = (new LocalVariableTableParameterNameDiscoverer()).getParameterNames(getMethod());
 			}
 			return this.parameterNames;
 		}

-		@Override
-		public Class<?>[] getExceptionTypes() {
+		public Class[] getExceptionTypes() {
 			return methodInvocation.getMethod().getExceptionTypes();
 		}

-		@Override
 		public String toShortString() {
 			return toString(false, false, false, false);
 		}

-		@Override
 		public String toLongString() {
 			return toString(true, true, true, true);
 		}

-		@Override
 		public String toString() {
 			return toString(false, true, false, true);
 		}

 		private String toString(boolean includeModifier, boolean includeReturnTypeAndArgs,
 				boolean useLongReturnAndArgumentTypeName, boolean useLongTypeName) {
-
 			StringBuilder sb = new StringBuilder();
 			if (includeModifier) {
 				sb.append(Modifier.toString(getModifiers()));
@@ -257,15 +227,14 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 			sb.append(".");
 			sb.append(getMethod().getName());
 			sb.append("(");
-			Class<?>[] parametersTypes = getParameterTypes();
+			Class[] parametersTypes = getParameterTypes();
 			appendTypes(sb, parametersTypes, includeReturnTypeAndArgs, useLongReturnAndArgumentTypeName);
 			sb.append(")");
 			return sb.toString();
 		}

-		private void appendTypes(StringBuilder sb, Class<?>[] types, boolean includeArgs,
-				boolean useLongReturnAndArgumentTypeName) {
-
+		private void appendTypes(StringBuilder sb, Class<?>[] types,
+				boolean includeArgs, boolean useLongReturnAndArgumentTypeName) {
 			if (includeArgs) {
 				for (int size = types.length, i = 0; i < size; i++) {
 					appendType(sb, types[i], useLongReturnAndArgumentTypeName);
@@ -298,26 +267,21 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	 */
 	private class SourceLocationImpl implements SourceLocation {

-		@Override
-		public Class<?> getWithinType() {
+		public Class getWithinType() {
 			if (methodInvocation.getThis() == null) {
 				throw new UnsupportedOperationException("No source location joinpoint available: target is null");
 			}
 			return methodInvocation.getThis().getClass();
 		}

-		@Override
 		public String getFileName() {
 			throw new UnsupportedOperationException();
 		}

-		@Override
 		public int getLine() {
 			throw new UnsupportedOperationException();
 		}

-		@Override
-		@Deprecated
 		public int getColumn() {
 			throw new UnsupportedOperationException();
 		}
@@ -50,7 +50,7 @@ import org.springframework.util.ReflectionUtils;
 * migrate to {@code ShadowMatch.getVariablesInvolvedInRuntimeTest()}
 * or some similar operation.
 *
- * <p>See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=151593"/>Bug 151593</a>
+ * <p>See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=151593"/>.
 *
 * @author Adrian Colyer
 * @author Ramnivas Laddad
@@ -120,44 +120,35 @@ class RuntimeTestWalker {
 		protected static final int AT_TARGET_VAR = 4;
 		protected static final int AT_ANNOTATION_VAR = 8;

-		@Override
 		public void visit(And e) {
 			e.getLeft().accept(this);
 			e.getRight().accept(this);
 		}

-		@Override
 		public void visit(Or e) {
 			e.getLeft().accept(this);
 			e.getRight().accept(this);
 		}

-		@Override
 		public void visit(Not e) {
 			e.getBody().accept(this);
 		}

-		@Override
 		public void visit(Instanceof i) {
 		}

-		@Override
 		public void visit(Literal literal) {
 		}

-		@Override
 		public void visit(Call call) {
 		}

-		@Override
 		public void visit(FieldGetCall fieldGetCall) {
 		}

-		@Override
 		public void visit(HasAnnotation hasAnnotation) {
 		}

-		@Override
 		public void visit(MatchingContextBasedTest matchingContextTest) {
 		}

@@ -29,14 +29,14 @@ import org.springframework.util.Assert;
 */
 public class SimpleAspectInstanceFactory implements AspectInstanceFactory {

-	private final Class<?> aspectClass;
+	private final Class aspectClass;


 	/**
 	 * Create a new SimpleAspectInstanceFactory for the given aspect class.
 	 * @param aspectClass the aspect class
 	 */
-	public SimpleAspectInstanceFactory(Class<?> aspectClass) {
+	public SimpleAspectInstanceFactory(Class aspectClass) {
 		Assert.notNull(aspectClass, "Aspect class must not be null");
 		this.aspectClass = aspectClass;
 	}
@@ -44,12 +44,11 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	/**
 	 * Return the specified aspect class (never {@code null}).
 	 */
-	public final Class<?> getAspectClass() {
+	public final Class getAspectClass() {
 		return this.aspectClass;
 	}


-	@Override
 	public final Object getAspectInstance() {
 		try {
 			return this.aspectClass.newInstance();
@@ -62,7 +61,6 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 		}
 	}

-	@Override
 	public ClassLoader getAspectClassLoader() {
 		return this.aspectClass.getClassLoader();
 	}
@@ -75,7 +73,6 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	 * @see org.springframework.core.Ordered
 	 * @see #getOrderForAspectClass
 	 */
-	@Override
 	public int getOrder() {
 		return getOrderForAspectClass(this.aspectClass);
 	}
@@ -44,12 +44,10 @@ public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
 	}


-	@Override
 	public final Object getAspectInstance() {
 		return this.aspectInstance;
 	}

-	@Override
 	public ClassLoader getAspectClassLoader() {
 		return this.aspectInstance.getClass().getClassLoader();
 	}
@@ -62,7 +60,6 @@ public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
 	 * @see org.springframework.core.Ordered
 	 * @see #getOrderForAspectClass
 	 */
-	@Override
 	public int getOrder() {
 		if (this.aspectInstance instanceof Ordered) {
 			return ((Ordered) this.aspectInstance).getOrder();
@@ -93,8 +93,7 @@ public class TypePatternClassFilter implements ClassFilter {
 	 * @return whether the advice should apply to this candidate target class
 	 * @throws IllegalStateException if no {@link #setTypePattern(String)} has been set
 	 */
-	@Override
-	public boolean matches(Class<?> clazz) {
+	public boolean matches(Class clazz) {
 		if (this.aspectJTypePatternMatcher == null) {
 			throw new IllegalStateException("No 'typePattern' has been set via ctor/setter.");
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -41,6 +41,7 @@ import org.aspectj.lang.reflect.PerClauseKind;
 import org.springframework.aop.aspectj.AspectJExpressionPointcut;
 import org.springframework.aop.framework.AopConfigException;
 import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.core.PrioritizedParameterNameDiscoverer;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.StringUtils;

@@ -58,6 +59,9 @@ import org.springframework.util.StringUtils;
 */
 public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {

+	protected static final ParameterNameDiscoverer ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER =
+			new AspectJAnnotationParameterNameDiscoverer();
+
 	private static final String AJC_MAGIC = "ajc$";


@@ -66,11 +70,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 * (there <i>should</i> only be one anyway...)
 	 */
 	@SuppressWarnings("unchecked")
-	protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
-		Class<?>[] classesToLookFor = new Class<?>[] {
+	protected static AspectJAnnotation findAspectJAnnotationOnMethod(Method method) {
+		Class<? extends Annotation>[] classesToLookFor = new Class[] {
 				Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
-		for (Class<?> c : classesToLookFor) {
-			AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) c);
+		for (Class<? extends Annotation> c : classesToLookFor) {
+			AspectJAnnotation foundAnnotation = findAnnotation(method, c);
 			if (foundAnnotation != null) {
 				return foundAnnotation;
 			}
@@ -92,16 +96,21 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	/** Logger available to subclasses */
 	protected final Log logger = LogFactory.getLog(getClass());

-	protected final ParameterNameDiscoverer parameterNameDiscoverer = new AspectJAnnotationParameterNameDiscoverer();
+	protected final ParameterNameDiscoverer parameterNameDiscoverer;


+	protected AbstractAspectJAdvisorFactory() {
+		PrioritizedParameterNameDiscoverer prioritizedParameterNameDiscoverer = new PrioritizedParameterNameDiscoverer();
+		prioritizedParameterNameDiscoverer.addDiscoverer(ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER);
+		this.parameterNameDiscoverer = prioritizedParameterNameDiscoverer;
+	}
+
 	/**
 	 * We consider something to be an AspectJ aspect suitable for use by the Spring AOP system
 	 * if it has the @Aspect annotation, and was not compiled by ajc. The reason for this latter test
 	 * is that aspects written in the code-style (AspectJ language) also have the annotation present
 	 * when compiled by ajc with the -1.5 flag, yet they cannot be consumed by Spring AOP.
 	 */
-	@Override
 	public boolean isAspect(Class<?> clazz) {
 		return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
 	}
@@ -126,7 +135,6 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		return false;
 	}

-	@Override
 	public void validate(Class<?> aspectClass) throws AopConfigException {
 		// If the parent has the annotation and isn't abstract it's an error
 		if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
@@ -155,7 +163,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 * formal parameters for the pointcut.
 	 */
 	protected AspectJExpressionPointcut createPointcutExpression(
-			Method annotatedMethod, Class<?> declarationScope, String[] pointcutParameterNames) {
+			Method annotatedMethod, Class declarationScope, String[] pointcutParameterNames) {

 		Class<?> [] pointcutParameterTypes = new Class<?>[0];
 		if (pointcutParameterNames != null) {
@@ -209,8 +217,8 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac

 		private static final String[] EXPRESSION_PROPERTIES = new String[] {"value", "pointcut"};

-		private static Map<Class<?>, AspectJAnnotationType> annotationTypes =
-				new HashMap<Class<?>, AspectJAnnotationType>();
+		private static Map<Class, AspectJAnnotationType> annotationTypes =
+				new HashMap<Class, AspectJAnnotationType>();

 		static {
 			annotationTypes.put(Pointcut.class,AspectJAnnotationType.AtPointcut);
@@ -244,7 +252,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}

 		private AspectJAnnotationType determineAnnotationType(A annotation) {
-			for (Class<?> type : annotationTypes.keySet()) {
+			for (Class type : annotationTypes.keySet()) {
 				if (type.isInstance(annotation)) {
 					return annotationTypes.get(type);
 				}
@@ -301,12 +309,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	 */
 	private static class AspectJAnnotationParameterNameDiscoverer implements ParameterNameDiscoverer {

-		@Override
 		public String[] getParameterNames(Method method) {
 			if (method.getParameterTypes().length == 0) {
 				return new String[0];
 			}
-			AspectJAnnotation<?> annotation = findAspectJAnnotationOnMethod(method);
+			AspectJAnnotation annotation = findAspectJAnnotationOnMethod(method);
 			if (annotation == null) {
 				return null;
 			}
@@ -323,8 +330,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 			}
 		}

-		@Override
-		public String[] getParameterNames(Constructor<?> ctor) {
+		public String[] getParameterNames(Constructor ctor) {
 			throw new UnsupportedOperationException("Spring AOP cannot handle constructor advice");
 		}
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 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.
@@ -50,7 +50,7 @@ import org.springframework.util.ClassUtils;
 public class AspectJProxyFactory extends ProxyCreatorSupport {

 	/** Cache for singleton aspect instances */
-	private static final Map<Class<?>, Object> aspectCache = new HashMap<Class<?>, Object>();
+	private static final Map<Class, Object> aspectCache = new HashMap<Class, Object>();

 	private final AspectJAdvisorFactory aspectFactory = new ReflectiveAspectJAdvisorFactory();

@@ -76,7 +76,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * Create a new {@code AspectJProxyFactory}.
 	 * No target, only interfaces. Must add interceptors.
 	 */
-	public AspectJProxyFactory(Class<?>... interfaces) {
+	public AspectJProxyFactory(Class[] interfaces) {
 		setInterfaces(interfaces);
 	}

@@ -89,7 +89,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * @param aspectInstance the AspectJ aspect instance
 	 */
 	public void addAspect(Object aspectInstance) {
-		Class<?> aspectClass = aspectInstance.getClass();
+		Class aspectClass = aspectInstance.getClass();
 		String aspectName = aspectClass.getName();
 		AspectMetadata am = createAspectMetadata(aspectClass, aspectName);
 		if (am.getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON) {
@@ -104,7 +104,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * Add an aspect of the supplied type to the end of the advice chain.
 	 * @param aspectClass the AspectJ aspect class
 	 */
-	public void addAspect(Class<?> aspectClass) {
+	public void addAspect(Class aspectClass) {
 		String aspectName = aspectClass.getName();
 		AspectMetadata am = createAspectMetadata(aspectClass, aspectName);
 		MetadataAwareAspectInstanceFactory instanceFactory = createAspectInstanceFactory(am, aspectClass, aspectName);
@@ -128,7 +128,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	/**
 	 * Create an {@link AspectMetadata} instance for the supplied aspect type.
 	 */
-	private AspectMetadata createAspectMetadata(Class<?> aspectClass, String aspectName) {
+	private AspectMetadata createAspectMetadata(Class aspectClass, String aspectName) {
 		AspectMetadata am = new AspectMetadata(aspectClass, aspectName);
 		if (!am.getAjType().isAspect()) {
 			throw new IllegalArgumentException("Class [" + aspectClass.getName() + "] is not a valid aspect type");
@@ -142,7 +142,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * a {@link PrototypeAspectInstanceFactory} is returned.
 	 */
 	private MetadataAwareAspectInstanceFactory createAspectInstanceFactory(
-			AspectMetadata am, Class<?> aspectClass, String aspectName) {
+			AspectMetadata am, Class aspectClass, String aspectName) {

 		MetadataAwareAspectInstanceFactory instanceFactory = null;
 		if (am.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
@@ -161,7 +161,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * Get the singleton aspect instance for the supplied aspect type. An instance
 	 * is created if one cannot be found in the instance cache.
 	 */
-	private Object getSingletonAspectInstance(Class<?> aspectClass) {
+	private Object getSingletonAspectInstance(Class aspectClass) {
 		synchronized (aspectCache) {
 			Object instance = aspectCache.get(aspectClass);
 			if (instance != null) {
@@ -45,7 +45,7 @@ public class AspectMetadata {
 	/**
 	 * AspectJ reflection information (AspectJ 5 / Java 5 specific).
 	 */
-	private final AjType<?> ajType;
+	private final AjType ajType;

 	/**
 	 * Spring AOP pointcut corresponding to the per clause of the
@@ -71,9 +71,9 @@ public class AspectMetadata {
 		this.aspectName = aspectName;

 		Class<?> currClass = aspectClass;
-		AjType<?> ajType = null;
+		AjType ajType = null;
 		while (!currClass.equals(Object.class)) {
-			AjType<?> ajTypeToCheck = AjTypeSystem.getAjType(currClass);
+			AjType ajTypeToCheck = AjTypeSystem.getAjType(currClass);
 			if (ajTypeToCheck.isAspect()) {
 				ajType = ajTypeToCheck;
 				break;
@@ -124,14 +124,14 @@ public class AspectMetadata {
 	/**
 	 * Return AspectJ reflection information.
 	 */
-	public AjType<?> getAjType() {
+	public AjType getAjType() {
 		return this.ajType;
 	}

 	/**
 	 * Return the aspect class.
 	 */
-	public Class<?> getAspectClass() {
+	public Class getAspectClass() {
 		return this.ajType.getJavaClass();
 	}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,7 +19,8 @@ package org.springframework.aop.aspectj.annotation;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.core.Ordered;
-import org.springframework.core.annotation.OrderUtils;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.Order;
 import org.springframework.util.ClassUtils;

 /**
@@ -65,19 +66,17 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @param name the name of the bean
 	 * @param type the type that should be introspected by AspectJ
 	 */
-	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class<?> type) {
+	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class type) {
 		this.beanFactory = beanFactory;
 		this.name = name;
 		this.aspectMetadata = new AspectMetadata(type, name);
 	}


-	@Override
 	public Object getAspectInstance() {
 		return this.beanFactory.getBean(this.name);
 	}

-	@Override
 	public ClassLoader getAspectClassLoader() {
 		if (this.beanFactory instanceof ConfigurableBeanFactory) {
 			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
@@ -87,7 +86,6 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 		}
 	}

-	@Override
 	public AspectMetadata getAspectMetadata() {
 		return this.aspectMetadata;
 	}
@@ -102,14 +100,16 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @see org.springframework.core.Ordered
 	 * @see org.springframework.core.annotation.Order
 	 */
-	@Override
 	public int getOrder() {
 		Class<?> type = this.beanFactory.getType(this.name);
 		if (type != null) {
 			if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
 				return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
 			}
-			return OrderUtils.getOrder(type, Ordered.LOWEST_PRECEDENCE);
+			Order order = AnnotationUtils.findAnnotation(type, Order.class);
+			if (order != null) {
+				return order.value();
+			}
 		}
 		return Ordered.LOWEST_PRECEDENCE;
 	}
@@ -96,7 +96,7 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 					// We must be careful not to instantiate beans eagerly as in this
 					// case they would be cached by the Spring container but would not
 					// have been weaved
-					Class<?> beanType = this.beanFactory.getType(beanName);
+					Class beanType = this.beanFactory.getType(beanName);
 					if (beanType == null) {
 						continue;
 					}
@@ -134,7 +134,7 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 		}

 		if (aspectNames.isEmpty()) {
-			return Collections.emptyList();
+			return Collections.EMPTY_LIST;
 		}
 		List<Advisor> advisors = new LinkedList<Advisor>();
 		for (String aspectName : aspectNames) {
@@ -97,7 +97,6 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	 * The pointcut for Spring AOP to use. Actual behaviour of the pointcut will change
 	 * depending on the state of the advice.
 	 */
-	@Override
 	public Pointcut getPointcut() {
 		return this.pointcut;
 	}
@@ -107,7 +106,6 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	 * are much richer. In AspectJ terminology, all a return of {@code true}
 	 * means here is that the aspect is not a SINGLETON.
 	 */
-	@Override
 	public boolean isPerInstance() {
 		return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON);
 	}
@@ -122,7 +120,6 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	/**
 	 * Lazily instantiate advice if necessary.
 	 */
-	@Override
 	public synchronized Advice getAdvice() {
 		if (this.instantiatedAdvice == null) {
 			this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
@@ -130,12 +127,10 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		return this.instantiatedAdvice;
 	}

-	@Override
 	public boolean isLazy() {
 		return this.lazy;
 	}

-	@Override
 	public synchronized boolean isAdviceInstantiated() {
 		return (this.instantiatedAdvice != null);
 	}
@@ -154,22 +149,18 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		return this.declaredPointcut;
 	}

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

-	@Override
 	public String getAspectName() {
 		return this.aspectName;
 	}

-	@Override
 	public int getDeclarationOrder() {
 		return this.declarationOrder;
 	}

-	@Override
 	public boolean isBeforeAdvice() {
 		if (this.isBeforeAdvice == null) {
 			determineAdviceType();
@@ -177,7 +168,6 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		return this.isBeforeAdvice;
 	}

-	@Override
 	public boolean isAfterAdvice() {
 		if (this.isAfterAdvice == null) {
 			determineAdviceType();
@@ -249,14 +239,13 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		}

 		@Override
-		public boolean matches(Method method, Class<?> targetClass) {
+		public boolean matches(Method method, Class targetClass) {
 			// We're either instantiated and matching on declared pointcut, or uninstantiated matching on either pointcut
 			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass)) ||
 					this.preInstantiationPointcut.getMethodMatcher().matches(method, targetClass);
 		}

-		@Override
-		public boolean matches(Method method, Class<?> targetClass, Object[] args) {
+		public boolean matches(Method method, Class targetClass, Object[] args) {
 			// This can match only on declared pointcut.
 			return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass));
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2009 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.
@@ -42,7 +42,6 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 	}


-	@Override
 	public synchronized Object getAspectInstance() {
 		if (this.materialized == null) {
 			synchronized (this) {
@@ -58,17 +57,14 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 		return (this.materialized != null);
 	}

-	@Override
 	public ClassLoader getAspectClassLoader() {
 		return this.maaif.getAspectClassLoader();
 	}

-	@Override
 	public AspectMetadata getAspectMetadata() {
 		return this.maaif.getAspectMetadata();
 	}

-	@Override
 	public int getOrder() {
 		return this.maaif.getOrder();
 	}
@@ -75,7 +75,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 				new InstanceComparator<Annotation>(
 						Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
 				new Converter<Method, Annotation>() {
-					@Override
 					public Annotation convert(Method method) {
 						AspectJAnnotation<?> annotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
 						return annotation == null ? null : annotation.getAnnotation();
@@ -83,7 +82,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 				}));
 		comparator.addComparator(new ConvertingComparator<Method, String>(
 				new Converter<Method, String>() {
-					@Override
 					public String convert(Method method) {
 						return method.getName();
 					}
@@ -92,7 +90,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	}


-	@Override
 	public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory maaif) {
 		final Class<?> aspectClass = maaif.getAspectMetadata().getAspectClass();
 		final String aspectName = maaif.getAspectMetadata().getAspectName();
@@ -131,7 +128,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	private List<Method> getAdvisorMethods(Class<?> aspectClass) {
 		final List<Method> methods = new LinkedList<Method>();
 		ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
-			@Override
 			public void doWith(Method method) throws IllegalArgumentException {
 				// Exclude pointcuts
 				if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
@@ -168,7 +164,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	}


-	@Override
 	public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif,
 			int declarationOrderInAspect, String aspectName) {

@@ -190,13 +185,12 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 			return null;
 		}
 		AspectJExpressionPointcut ajexp =
-				new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
+				new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);
 		ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
 		return ajexp;
 	}


-	@Override
 	public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut ajexp,
 			MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName) {

@@ -278,7 +272,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto

 		public SyntheticInstantiationAdvisor(final MetadataAwareAspectInstanceFactory aif) {
 			super(aif.getAspectMetadata().getPerClausePointcut(), new MethodBeforeAdvice() {
-				@Override
 				public void before(Method method, Object[] args, Object target) {
 					// Simply instantiate the aspect
 					aif.getAspectInstance();
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -18,7 +18,8 @@ package org.springframework.aop.aspectj.annotation;

 import org.springframework.aop.aspectj.SimpleAspectInstanceFactory;
 import org.springframework.core.Ordered;
-import org.springframework.core.annotation.OrderUtils;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.Order;

 /**
 * Implementation of {@link MetadataAwareAspectInstanceFactory} that
@@ -39,20 +40,30 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 	 * @param aspectClass the aspect class
 	 * @param aspectName the aspect name
 	 */
-	public SimpleMetadataAwareAspectInstanceFactory(Class<?> aspectClass, String aspectName) {
+	public SimpleMetadataAwareAspectInstanceFactory(Class aspectClass, String aspectName) {
 		super(aspectClass);
 		this.metadata = new AspectMetadata(aspectClass, aspectName);
 	}


-	@Override
 	public final AspectMetadata getAspectMetadata() {
 		return this.metadata;
 	}

+	/**
+	 * Determine a fallback order for the case that the aspect instance
+	 * does not express an instance-specific order through implementing
+	 * the {@link org.springframework.core.Ordered} interface.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
+	 * @param aspectClass the aspect class
+	 */
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
-		return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE);
+		Order order = AnnotationUtils.findAnnotation(aspectClass, Order.class);
+		if (order != null) {
+			return order.value();
+		}
+		return Ordered.LOWEST_PRECEDENCE;
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -18,7 +18,8 @@ package org.springframework.aop.aspectj.annotation;

 import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
 import org.springframework.core.Ordered;
-import org.springframework.core.annotation.OrderUtils;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.core.annotation.Order;

 /**
 * Implementation of {@link MetadataAwareAspectInstanceFactory} that is backed
@@ -47,14 +48,23 @@ public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspect
 	}


-	@Override
 	public final AspectMetadata getAspectMetadata() {
 		return this.metadata;
 	}

+	/**
+	 * Check whether the aspect class carries an
+	 * {@link org.springframework.core.annotation.Order} annotation,
+	 * falling back to {@code Ordered.LOWEST_PRECEDENCE}.
+	 * @see org.springframework.core.annotation.Order
+	 */
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
-		return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE);
+		Order order = AnnotationUtils.findAnnotation(aspectClass, Order.class);
+		if (order != null) {
+			return order.value();
+		}
+		return Ordered.LOWEST_PRECEDENCE;
 	}

 }
@@ -1,6 +1,10 @@
+
 /**
+ *
 * Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
 *
 * <p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
+ *
 */
 package org.springframework.aop.aspectj.annotation;
+
@@ -46,7 +46,7 @@ import org.springframework.util.ClassUtils;
@SuppressWarnings("serial")
 public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {

-	private static final Comparator<Advisor> DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();
+	private static final Comparator DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();


 	/**
@@ -98,7 +98,7 @@ public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProx
 	}

 	@Override
-	protected boolean shouldSkip(Class<?> beanClass, String beanName) {
+	protected boolean shouldSkip(Class beanClass, String beanName) {
 		// TODO: Consider optimization by caching the list of the aspect names
 		List<Advisor> candidateAdvisors = findCandidateAdvisors();
 		for (Advisor advisor : candidateAdvisors) {
@@ -126,13 +126,11 @@ public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProx
 			this.comparator = comparator;
 		}

-		@Override
 		public int compareTo(Object obj) {
 			Advisor otherAdvisor = ((PartiallyComparableAdvisorHolder) obj).advisor;
 			return this.comparator.compare(this.advisor, otherAdvisor);
 		}

-		@Override
 		public int fallbackCompareTo(Object obj) {
 			return 0;
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -29,13 +29,15 @@ import org.springframework.util.Assert;
 *
 * <p>Given two pieces of advice, {@code a} and {@code b}:
 * <ul>
- * <li>if {@code a} and {@code b} are defined in different aspects, then the advice
- * in the aspect with the lowest order value has the highest precedence</li>
- * <li>if {@code a} and {@code b} are defined in the same aspect, then if one of
- * {@code a} or {@code b} is a form of after advice, then the advice declared last
- * in the aspect has the highest precedence. If neither {@code a} nor {@code b} is
- * a form of after advice, then the advice declared first in the aspect has the
- * highest precedence.</li>
+ *   <li>if {@code a} and {@code b} are defined in different
+ *   aspects, then the advice in the aspect with the lowest order
+ *   value has the highest precedence</li>
+ *   <li>if {@code a} and {@code b} are defined in the same
+ *   aspect, then if one of {@code a} or {@code b} is a form of
+ *   after advice, then the advice declared last in the aspect has the
+ *   highest precedence. If neither {@code a} nor {@code b} is a
+ *   form of after advice, then the advice declared first in the aspect has
+ *   the highest precedence.</li>
 * </ul>
 *
 * <p>Important: Note that unlike a normal comparator a return of 0 means
@@ -46,15 +48,12 @@ import org.springframework.util.Assert;
 * @author Juergen Hoeller
 * @since 2.0
 */
-class AspectJPrecedenceComparator implements Comparator<Advisor> {
+class AspectJPrecedenceComparator implements Comparator {

 	private static final int HIGHER_PRECEDENCE = -1;
-
 	private static final int SAME_PRECEDENCE = 0;
-
 	private static final int LOWER_PRECEDENCE = 1;

-
 	private final Comparator<? super Advisor> advisorComparator;


@@ -76,11 +75,18 @@ class AspectJPrecedenceComparator implements Comparator<Advisor> {
 	}


-	@Override
-	public int compare(Advisor o1, Advisor o2) {
-		int advisorPrecedence = this.advisorComparator.compare(o1, o2);
-		if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(o1, o2)) {
-			advisorPrecedence = comparePrecedenceWithinAspect(o1, o2);
+	public int compare(Object o1, Object o2) {
+		if (!(o1 instanceof Advisor && o2 instanceof Advisor)) {
+			throw new IllegalArgumentException(
+					"AspectJPrecedenceComparator can only compare the order of Advisors, " +
+					"but was passed [" + o1 + "] and [" + o2 + "]");
+		}
+
+		Advisor advisor1 = (Advisor) o1;
+		Advisor advisor2 = (Advisor) o2;
+		int advisorPrecedence = this.advisorComparator.compare(advisor1, advisor2);
+		if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(advisor1, advisor2)) {
+			advisorPrecedence = comparePrecedenceWithinAspect(advisor1, advisor2);
 		}
 		return advisorPrecedence;
 	}
@@ -1,5 +1,9 @@
+
 /**
+ *
 * Base classes enabling auto-proxying based on AspectJ.
 * Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
+ *
 */
 package org.springframework.aop.aspectj.autoproxy;
+
@@ -1,4 +1,5 @@
 /**
+ *
 * AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
 * annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
 * implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
@@ -7,5 +8,7 @@
 * <p>Note that use of this package does <i>not</i> require the use of the {@code ajc} compiler
 * or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
 * functionality, with consistent semantics, with the proxy-based Spring AOP framework.
+ *
 */
 package org.springframework.aop.aspectj;
+
@@ -58,7 +58,6 @@ import org.springframework.util.StringUtils;
 */
 public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implements BeanDefinitionDecorator {

-	@Override
 	public final BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definitionHolder, ParserContext parserContext) {
 		BeanDefinitionRegistry registry = parserContext.getRegistry();

@@ -91,7 +91,6 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 	}


-	@Override
 	public String getName() {
 		return this.advisorBeanName;
 	}
@@ -111,7 +110,6 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 		return this.beanReferences;
 	}

-	@Override
 	public Object getSource() {
 		return this.advisorDefinition.getSource();
 	}
@@ -54,7 +54,7 @@ public abstract class AopConfigUtils {
 	/**
 	 * Stores the auto proxy creator classes in escalation order.
 	 */
-	private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<Class<?>>();
+	private static final List<Class> APC_PRIORITY_LIST = new ArrayList<Class>();

 	/**
 	 * Setup the escalation list.
@@ -105,7 +105,7 @@ public abstract class AopConfigUtils {
 	}


-	private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
+	private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, Object source) {
 		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
 		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
 			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
@@ -126,13 +126,13 @@ public abstract class AopConfigUtils {
 		return beanDefinition;
 	}

-	private static int findPriorityForClass(Class<?> clazz) {
+	private static int findPriorityForClass(Class clazz) {
 		return APC_PRIORITY_LIST.indexOf(clazz);
 	}

 	private static int findPriorityForClass(String className) {
 		for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
-			Class<?> clazz = APC_PRIORITY_LIST.get(i);
+			Class clazz = APC_PRIORITY_LIST.get(i);
 			if (clazz.getName().equals(className)) {
 				return i;
 			}
@@ -59,7 +59,6 @@ public class AopNamespaceHandler extends NamespaceHandlerSupport {
 	 * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
 	 * and '{@code scoped-proxy}' tags.
 	 */
-	@Override
 	public void init() {
 		// In 2.0 XSD as well as in 2.1 XSD.
 		registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -79,6 +79,28 @@ public abstract class AopNamespaceUtils {
 		registerComponentIfNecessary(beanDefinition, parserContext);
 	}

+	/**
+	 * @deprecated since Spring 2.5, in favor of
+	 * {@link #registerAutoProxyCreatorIfNecessary(ParserContext, Element)} and
+	 * {@link AopConfigUtils#registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry, Object)}
+	 */
+	@Deprecated
+	public static void registerAutoProxyCreatorIfNecessary(ParserContext parserContext, Object source) {
+		BeanDefinition beanDefinition = AopConfigUtils.registerAutoProxyCreatorIfNecessary(
+				parserContext.getRegistry(), source);
+		registerComponentIfNecessary(beanDefinition, parserContext);
+	}
+
+	/**
+	 * @deprecated since Spring 2.5, in favor of
+	 * {@link AopConfigUtils#forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry)}
+	 */
+	@Deprecated
+	public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
+		AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
+	}
+
+
 	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
 		if (sourceElement != null) {
 			boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
@@ -37,7 +37,6 @@ import org.springframework.beans.factory.xml.ParserContext;
 */
 class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {

-	@Override
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
 		extendBeanDefinition(element, parserContext);
@@ -95,7 +95,6 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	private ParseState parseState = new ParseState();


-	@Override
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		CompositeComponentDefinition compositeDef =
 				new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
@@ -405,7 +404,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	/**
 	 * Gets the advice implementation class corresponding to the supplied {@link Element}.
 	 */
-	private Class<?> getAdviceClass(Element adviceElement, ParserContext parserContext) {
+	private Class getAdviceClass(Element adviceElement, ParserContext parserContext) {
 		String elementName = parserContext.getDelegate().getLocalName(adviceElement);
 		if (BEFORE.equals(elementName)) {
 			return AspectJMethodBeforeAdvice.class;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2009 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.
@@ -57,7 +57,6 @@ public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFacto
 		this.methodName = methodName;
 	}

-	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		if (!StringUtils.hasText(this.targetBeanName)) {
 			throw new IllegalArgumentException("Property 'targetBeanName' is required");
@@ -66,7 +65,7 @@ public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFacto
 			throw new IllegalArgumentException("Property 'methodName' is required");
 		}

-		Class<?> beanClass = beanFactory.getType(this.targetBeanName);
+		Class beanClass = beanFactory.getType(this.targetBeanName);
 		if (beanClass == null) {
 			throw new IllegalArgumentException("Can't determine type of bean with name '" + this.targetBeanName + "'");
 		}
@@ -79,17 +78,14 @@ public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFacto
 	}


-	@Override
 	public Method getObject() throws Exception {
 		return this.method;
 	}

-	@Override
 	public Class<Method> getObjectType() {
 		return Method.class;
 	}

-	@Override
 	public boolean isSingleton() {
 		return true;
 	}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -46,7 +46,6 @@ public class PointcutComponentDefinition extends AbstractComponentDefinition {
 	}


-	@Override
 	public String getName() {
 		return this.pointcutBeanName;
 	}
@@ -61,7 +60,6 @@ public class PointcutComponentDefinition extends AbstractComponentDefinition {
 		return new BeanDefinition[] {this.pointcutDefinition};
 	}

-	@Override
 	public Object getSource() {
 		return this.pointcutDefinition.getSource();
 	}
@@ -39,7 +39,6 @@ class ScopedProxyBeanDefinitionDecorator implements BeanDefinitionDecorator {
 	private static final String PROXY_TARGET_CLASS = "proxy-target-class";


-	@Override
 	public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definition, ParserContext parserContext) {
 		boolean proxyTargetClass = true;
 		if (node instanceof Element) {
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -47,7 +47,6 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 		this.aspectBeanName = aspectBeanName;
 	}

-	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 		if (!StringUtils.hasText(this.aspectBeanName)) {
@@ -60,12 +59,10 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 	 * Look up the aspect bean from the {@link BeanFactory} and returns it.
 	 * @see #setAspectBeanName
 	 */
-	@Override
 	public Object getAspectInstance() {
 		return this.beanFactory.getBean(this.aspectBeanName);
 	}

-	@Override
 	public ClassLoader getAspectClassLoader() {
 		if (this.beanFactory instanceof ConfigurableBeanFactory) {
 			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
@@ -75,7 +72,6 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 		}
 	}

-	@Override
 	public int getOrder() {
 		if (this.beanFactory.isSingleton(this.aspectBeanName) &&
 				this.beanFactory.isTypeMatch(this.aspectBeanName, Ordered.class)) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2011 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.
@@ -50,7 +50,6 @@ class SpringConfiguredBeanDefinitionParser implements BeanDefinitionParser {
 			"org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect";


-	@Override
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		if (!parserContext.getRegistry().containsBeanDefinition(BEAN_CONFIGURER_ASPECT_BEAN_NAME)) {
 			RootBeanDefinition def = new RootBeanDefinition();
@@ -1,5 +1,9 @@
+
 /**
+ *
 * Support package for declarative AOP configuration,
 * with XML schema being the primary configuration format.
+ *
 */
 package org.springframework.aop.config;
+
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -21,7 +21,10 @@ import java.util.concurrent.ConcurrentHashMap;

 import org.springframework.aop.Advisor;
 import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.util.ClassUtils;

 /**
 * Base class for {@link BeanPostProcessor} implementations that apply a
@@ -31,13 +34,22 @@ import org.springframework.beans.factory.config.BeanPostProcessor;
 * @since 3.2
 */
@SuppressWarnings("serial")
-public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
+public abstract class AbstractAdvisingBeanPostProcessor extends ProxyConfig
+		implements BeanPostProcessor, BeanClassLoaderAware, Ordered {

 	protected Advisor advisor;

 	protected boolean beforeExistingAdvisors = false;

-	private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<Class<?>, Boolean>(64);
+	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
+
+	/**
+	 * This should run after all other post-processors, so that it can just add
+	 * an advisor to existing proxies rather than double-proxy.
+	 */
+	private int order = Ordered.LOWEST_PRECEDENCE;
+
+	private final Map<Class, Boolean> eligibleBeans = new ConcurrentHashMap<Class, Boolean>(64);


 	/**
@@ -53,23 +65,31 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 		this.beforeExistingAdvisors = beforeExistingAdvisors;
 	}

+	public void setBeanClassLoader(ClassLoader beanClassLoader) {
+		this.beanClassLoader = beanClassLoader;
+	}
+
+	public void setOrder(int order) {
+		this.order = order;
+	}
+
+	public int getOrder() {
+		return this.order;
+	}
+

-	@Override
 	public Object postProcessBeforeInitialization(Object bean, String beanName) {
 		return bean;
 	}

-	@Override
 	public Object postProcessAfterInitialization(Object bean, String beanName) {
 		if (bean instanceof AopInfrastructureBean) {
 			// Ignore AOP infrastructure such as scoped proxies.
 			return bean;
 		}
-
-		if (bean instanceof Advised) {
-			Advised advised = (Advised) bean;
-			if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
-				// Add our local Advisor to the existing proxy's Advisor chain...
+		if (isEligible(bean, beanName)) {
+			if (bean instanceof Advised) {
+				Advised advised = (Advised) bean;
 				if (this.beforeExistingAdvisors) {
 					advised.addAdvisor(0, this.advisor);
 				}
@@ -78,50 +98,32 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 				}
 				return bean;
 			}
-		}
-
-		if (isEligible(bean, beanName)) {
-			ProxyFactory proxyFactory = new ProxyFactory();
-			proxyFactory.copyFrom(this);
-			proxyFactory.setTarget(bean);
-			if (!proxyFactory.isProxyTargetClass()) {
-				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
+			else {
+				ProxyFactory proxyFactory = new ProxyFactory(bean);
+				// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
+				proxyFactory.copyFrom(this);
+				proxyFactory.addAdvisor(this.advisor);
+				return proxyFactory.getProxy(this.beanClassLoader);
 			}
-			proxyFactory.addAdvisor(this.advisor);
-			return proxyFactory.getProxy(getProxyClassLoader());
 		}
-
-		// No async proxy needed.
-		return bean;
+		else {
+			// No async proxy needed.
+			return bean;
+		}
 	}

 	/**
 	 * Check whether the given bean is eligible for advising with this
 	 * post-processor's {@link Advisor}.
-	 * <p>Delegates to {@link #isEligible(Class)} for target class checking.
+	 * <p>Implements caching of {@code canApply} results per bean target class.
 	 * Can be overridden e.g. to specifically exclude certain beans by name.
-	 * <p>Note: Only called for regular bean instances but not for existing
-	 * proxy instances which implement {@link Advised} and allow for adding
-	 * the local {@link Advisor} to the existing proxy's {@link Advisor} chain.
-	 * For the latter, {@link #isEligible(Class)} is being called directly,
-	 * with the actual target class behind the existing proxy (as determined
-	 * by {@link AopUtils#getTargetClass(Object)}).
 	 * @param bean the bean instance
 	 * @param beanName the name of the bean
-	 * @see #isEligible(Class)
-	 */
-	protected boolean isEligible(Object bean, String beanName) {
-		return isEligible(bean.getClass());
-	}
-
-	/**
-	 * Check whether the given class is eligible for advising with this
-	 * post-processor's {@link Advisor}.
-	 * <p>Implements caching of {@code canApply} results per bean target class.
-	 * @param targetClass the class to check against
+	 * @see AopUtils#getTargetClass(Object)
 	 * @see AopUtils#canApply(Advisor, Class)
 	 */
-	protected boolean isEligible(Class<?> targetClass) {
+	protected boolean isEligible(Object bean, String beanName) {
+		Class<?> targetClass = AopUtils.getTargetClass(bean);
 		Boolean eligible = this.eligibleBeans.get(targetClass);
 		if (eligible != null) {
 			return eligible;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2011 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.
@@ -122,7 +122,6 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 		this.proxyClassLoader = classLoader;
 	}

-	@Override
 	public void setBeanClassLoader(ClassLoader classLoader) {
 		if (this.proxyClassLoader == null) {
 			this.proxyClassLoader = classLoader;
@@ -130,7 +129,6 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 	}


-	@Override
 	public void afterPropertiesSet() {
 		if (this.target == null) {
 			throw new IllegalArgumentException("Property 'target' is required");
@@ -192,7 +190,6 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 	}


-	@Override
 	public Object getObject() {
 		if (this.proxy == null) {
 			throw new FactoryBeanNotInitializedException();
@@ -200,7 +197,6 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 		return this.proxy;
 	}

-	@Override
 	public Class<?> getObjectType() {
 		if (this.proxy != null) {
 			return this.proxy.getClass();
@@ -217,7 +213,6 @@ public abstract class AbstractSingletonProxyFactoryBean extends ProxyConfig
 		return null;
 	}

-	@Override
 	public final boolean isSingleton() {
 		return true;
 	}
@@ -58,6 +58,7 @@ import org.springframework.util.CollectionUtils;
 * @author Juergen Hoeller
 * @see org.springframework.aop.framework.AopProxy
 */
+@SuppressWarnings("unchecked")
 public class AdvisedSupport extends ProxyConfig implements Advised {

 	/** use serialVersionUID from Spring 2.0 for interoperability */
@@ -87,7 +88,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * Interfaces to be implemented by the proxy. Held in List to keep the order
 	 * of registration, to create JDK proxy with specified order of interfaces.
 	 */
-	private List<Class<?>> interfaces = new ArrayList<Class<?>>();
+	private List<Class> interfaces = new ArrayList<Class>();

 	/**
 	 * List of Advisors. If an Advice is added, it will be wrapped
@@ -113,7 +114,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * Create a AdvisedSupport instance with the given parameters.
 	 * @param interfaces the proxied interfaces
 	 */
-	public AdvisedSupport(Class<?>[] interfaces) {
+	public AdvisedSupport(Class[] interfaces) {
 		this();
 		setInterfaces(interfaces);
 	}
@@ -136,12 +137,10 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		setTargetSource(new SingletonTargetSource(target));
 	}

-	@Override
 	public void setTargetSource(TargetSource targetSource) {
 		this.targetSource = (targetSource != null ? targetSource : EMPTY_TARGET_SOURCE);
 	}

-	@Override
 	public TargetSource getTargetSource() {
 		return this.targetSource;
 	}
@@ -163,17 +162,14 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		this.targetSource = EmptyTargetSource.forClass(targetClass);
 	}

-	@Override
 	public Class<?> getTargetClass() {
 		return this.targetSource.getTargetClass();
 	}

-	@Override
 	public void setPreFiltered(boolean preFiltered) {
 		this.preFiltered = preFiltered;
 	}

-	@Override
 	public boolean isPreFiltered() {
 		return this.preFiltered;
 	}
@@ -201,7 +197,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	public void setInterfaces(Class<?>... interfaces) {
 		Assert.notNull(interfaces, "Interfaces must not be null");
 		this.interfaces.clear();
-		for (Class<?> ifc : interfaces) {
+		for (Class ifc : interfaces) {
 			addInterface(ifc);
 		}
 	}
@@ -232,14 +228,12 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		return this.interfaces.remove(intf);
 	}

-	@Override
 	public Class<?>[] getProxiedInterfaces() {
-		return this.interfaces.toArray(new Class<?>[this.interfaces.size()]);
+		return this.interfaces.toArray(new Class[this.interfaces.size()]);
 	}

-	@Override
 	public boolean isInterfaceProxied(Class<?> intf) {
-		for (Class<?> proxyIntf : this.interfaces) {
+		for (Class proxyIntf : this.interfaces) {
 			if (intf.isAssignableFrom(proxyIntf)) {
 				return true;
 			}
@@ -248,18 +242,15 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


-	@Override
 	public final Advisor[] getAdvisors() {
 		return this.advisorArray;
 	}

-	@Override
 	public void addAdvisor(Advisor advisor) {
 		int pos = this.advisors.size();
 		addAdvisor(pos, advisor);
 	}

-	@Override
 	public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
 		if (advisor instanceof IntroductionAdvisor) {
 			validateIntroductionAdvisor((IntroductionAdvisor) advisor);
@@ -267,7 +258,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		addAdvisorInternal(pos, advisor);
 	}

-	@Override
 	public boolean removeAdvisor(Advisor advisor) {
 		int index = indexOf(advisor);
 		if (index == -1) {
@@ -279,7 +269,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		}
 	}

-	@Override
 	public void removeAdvisor(int index) throws AopConfigException {
 		if (isFrozen()) {
 			throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
@@ -303,13 +292,11 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		adviceChanged();
 	}

-	@Override
 	public int indexOf(Advisor advisor) {
 		Assert.notNull(advisor, "Advisor must not be null");
 		return this.advisors.indexOf(advisor);
 	}

-	@Override
 	public boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException {
 		Assert.notNull(a, "Advisor a must not be null");
 		Assert.notNull(b, "Advisor b must not be null");
@@ -322,6 +309,16 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		return true;
 	}

+	/**
+	 * Add all of the given advisors to this proxy configuration.
+	 * @param advisors the advisors to register
+	 * @deprecated as of Spring 3.0, in favor of {@link #addAdvisors}
+	 */
+	@Deprecated
+	public void addAllAdvisors(Advisor[] advisors) {
+		addAdvisors(Arrays.asList(advisors));
+	}
+
 	/**
 	 * Add all of the given advisors to this proxy configuration.
 	 * @param advisors the advisors to register
@@ -354,8 +351,8 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
 		advisor.validateInterfaces();
 		// If the advisor passed validation, we can make the change.
-		Class<?>[] ifcs = advisor.getInterfaces();
-		for (Class<?> ifc : ifcs) {
+		Class[] ifcs = advisor.getInterfaces();
+		for (Class ifc : ifcs) {
 			addInterface(ifc);
 		}
 	}
@@ -391,7 +388,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


-	@Override
 	public void addAdvice(Advice advice) throws AopConfigException {
 		int pos = this.advisors.size();
 		addAdvice(pos, advice);
@@ -400,7 +396,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	/**
 	 * Cannot add introductions this way unless the advice implements IntroductionInfo.
 	 */
-	@Override
 	public void addAdvice(int pos, Advice advice) throws AopConfigException {
 		Assert.notNull(advice, "Advice must not be null");
 		if (advice instanceof IntroductionInfo) {
@@ -417,7 +412,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		}
 	}

-	@Override
 	public boolean removeAdvice(Advice advice) throws AopConfigException {
 		int index = indexOf(advice);
 		if (index == -1) {
@@ -429,7 +423,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		}
 	}

-	@Override
 	public int indexOf(Advice advice) {
 		Assert.notNull(advice, "Advice must not be null");
 		for (int i = 0; i < this.advisors.size(); i++) {
@@ -462,7 +455,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @param adviceClass the advice class to check
 	 * @return the count of the interceptors of this class or subclasses
 	 */
-	public int countAdvicesOfType(Class<?> adviceClass) {
+	public int countAdvicesOfType(Class adviceClass) {
 		int count = 0;
 		if (adviceClass != null) {
 			for (Advisor advisor : this.advisors) {
@@ -482,7 +475,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @param targetClass the target class
 	 * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 	 */
-	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
+	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
 		MethodCacheKey cacheKey = new MethodCacheKey(method);
 		List<Object> cached = this.methodCache.get(cacheKey);
 		if (cached == null) {
@@ -520,7 +513,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 		copyFrom(other);
 		this.targetSource = targetSource;
 		this.advisorChainFactory = other.advisorChainFactory;
-		this.interfaces = new ArrayList<Class<?>>(other.interfaces);
+		this.interfaces = new ArrayList<Class>(other.interfaces);
 		for (Advisor advisor : advisors) {
 			if (advisor instanceof IntroductionAdvisor) {
 				validateIntroductionAdvisor((IntroductionAdvisor) advisor);
@@ -561,7 +554,6 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	}


-	@Override
 	public String toProxyConfigString() {
 		return toString();
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -32,10 +32,10 @@ public interface AdvisorChainFactory {
 	 * for the given advisor chain configuration.
 	 * @param config the AOP configuration in the form of an Advised object
 	 * @param method the proxied method
-	 * @param targetClass the target class (may be {@code null} to indicate a proxy without
-	 * target object, in which case the method's declaring class is the next best option)
+	 * @param targetClass the target class
 	 * @return List of MethodInterceptors (may also include InterceptorAndDynamicMethodMatchers)
 	 */
-	List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, Class<?> targetClass);
+	List<Object> getInterceptorsAndDynamicInterceptionAdvice(
+			Advised config, Method method, Class targetClass);

 }
@@ -78,13 +78,13 @@ public abstract class AopProxyUtils {
 	 * @see Advised
 	 * @see org.springframework.aop.SpringProxy
 	 */
-	public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
-		Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
+	public static Class[] completeProxiedInterfaces(AdvisedSupport advised) {
+		Class[] specifiedInterfaces = advised.getProxiedInterfaces();
 		if (specifiedInterfaces.length == 0) {
 			// No user-specified interfaces: check whether target class is an interface.
-			Class<?> targetClass = advised.getTargetClass();
+			Class targetClass = advised.getTargetClass();
 			if (targetClass != null && targetClass.isInterface()) {
-				specifiedInterfaces = new Class<?>[] {targetClass};
+				specifiedInterfaces = new Class[] {targetClass};
 			}
 		}
 		boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
@@ -96,7 +96,7 @@ public abstract class AopProxyUtils {
 		if (addAdvised) {
 			nonUserIfcCount++;
 		}
-		Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
+		Class[] proxiedInterfaces = new Class[specifiedInterfaces.length + nonUserIfcCount];
 		System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
 		if (addSpringProxy) {
 			proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
@@ -115,8 +115,8 @@ public abstract class AopProxyUtils {
 	 * in the original order (never {@code null} or empty)
 	 * @see Advised
 	 */
-	public static Class<?>[] proxiedUserInterfaces(Object proxy) {
-		Class<?>[] proxyInterfaces = proxy.getClass().getInterfaces();
+	public static Class[] proxiedUserInterfaces(Object proxy) {
+		Class[] proxyInterfaces = proxy.getClass().getInterfaces();
 		int nonUserIfcCount = 0;
 		if (proxy instanceof SpringProxy) {
 			nonUserIfcCount++;
@@ -124,7 +124,7 @@ public abstract class AopProxyUtils {
 		if (proxy instanceof Advised) {
 			nonUserIfcCount++;
 		}
-		Class<?>[] userInterfaces = new Class<?>[proxyInterfaces.length - nonUserIfcCount];
+		Class[] userInterfaces = new Class[proxyInterfaces.length - nonUserIfcCount];
 		System.arraycopy(proxyInterfaces, 0, userInterfaces, 0, userInterfaces.length);
 		Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
 		return userInterfaces;
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -37,7 +37,6 @@ import org.springframework.aop.RawTargetAccess;
 import org.springframework.aop.TargetSource;
 import org.springframework.aop.support.AopUtils;
 import org.springframework.cglib.core.CodeGenerationException;
-import org.springframework.cglib.core.SpringNamingPolicy;
 import org.springframework.cglib.proxy.Callback;
 import org.springframework.cglib.proxy.CallbackFilter;
 import org.springframework.cglib.proxy.Dispatcher;
@@ -46,7 +45,7 @@ import org.springframework.cglib.proxy.Factory;
 import org.springframework.cglib.proxy.MethodInterceptor;
 import org.springframework.cglib.proxy.MethodProxy;
 import org.springframework.cglib.proxy.NoOp;
-import org.springframework.cglib.transform.impl.UndeclaredThrowableStrategy;
+import org.springframework.cglib.transform.impl.MemorySafeUndeclaredThrowableStrategy;
 import org.springframework.core.SmartClassLoader;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -80,7 +79,7 @@ import org.springframework.util.ObjectUtils;
 * @see DefaultAopProxyFactory
 */
@SuppressWarnings("serial")
-class CglibAopProxy implements AopProxy, Serializable {
+final class CglibAopProxy implements AopProxy, Serializable {

 	// Constants for CGLIB callback array indices
 	private static final int AOP_PROXY = 0;
@@ -93,7 +92,7 @@ class CglibAopProxy implements AopProxy, Serializable {


 	/** Logger available to subclasses; static to optimize serialization */
-	protected static final Log logger = LogFactory.getLog(CglibAopProxy.class);
+	protected final static Log logger = LogFactory.getLog(CglibAopProxy.class);

 	/** Keeps track of the Classes that we have validated for final methods */
 	private static final Map<Class<?>, Boolean> validatedClasses = new WeakHashMap<Class<?>, Boolean>();
@@ -102,9 +101,9 @@ class CglibAopProxy implements AopProxy, Serializable {
 	/** The configuration used to configure this proxy */
 	protected final AdvisedSupport advised;

-	protected Object[] constructorArgs;
+	private Object[] constructorArgs;

-	protected Class<?>[] constructorArgTypes;
+	private Class<?>[] constructorArgTypes;

 	/** Dispatcher used for methods on Advised */
 	private final transient AdvisedDispatcher advisedDispatcher;
@@ -147,12 +146,10 @@ class CglibAopProxy implements AopProxy, Serializable {
 	}


-	@Override
 	public Object getProxy() {
 		return getProxy(null);
 	}

-	@Override
 	public Object getProxy(ClassLoader classLoader) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
@@ -172,7 +169,7 @@ class CglibAopProxy implements AopProxy, Serializable {
 			}

 			// Validate the class, writing log messages as necessary.
-			validateClassIfNecessary(proxySuperClass, classLoader);
+			validateClassIfNecessary(proxySuperClass);

 			// Configure CGLIB Enhancer...
 			Enhancer enhancer = createEnhancer();
@@ -184,22 +181,31 @@ class CglibAopProxy implements AopProxy, Serializable {
 				}
 			}
 			enhancer.setSuperclass(proxySuperClass);
+			enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
 			enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
-			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
-			enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
+			enhancer.setInterceptDuringConstruction(false);

 			Callback[] callbacks = getCallbacks(rootClass);
-			Class<?>[] types = new Class<?>[callbacks.length];
+			enhancer.setCallbacks(callbacks);
+			enhancer.setCallbackFilter(new ProxyCallbackFilter(
+					this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
+
+			Class<?>[] types = new Class[callbacks.length];
 			for (int x = 0; x < types.length; x++) {
 				types[x] = callbacks[x].getClass();
 			}
-			// fixedInterceptorMap only populated at this point, after getCallbacks call above
-			enhancer.setCallbackFilter(new ProxyCallbackFilter(
-					this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
 			enhancer.setCallbackTypes(types);

 			// Generate the proxy class and create a proxy instance.
-			return createProxyClassAndInstance(enhancer, callbacks);
+			Object proxy;
+			if (this.constructorArgs != null) {
+				proxy = enhancer.create(this.constructorArgTypes, this.constructorArgs);
+			}
+			else {
+				proxy = enhancer.create();
+			}
+
+			return proxy;
 		}
 		catch (CodeGenerationException ex) {
 			throw new AopConfigException("Could not generate CGLIB subclass of class [" +
@@ -219,14 +225,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 		}
 	}

-	protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
-		enhancer.setInterceptDuringConstruction(false);
-		enhancer.setCallbacks(callbacks);
-		return (this.constructorArgs != null ?
-				enhancer.create(this.constructorArgTypes, this.constructorArgs) :
-				enhancer.create());
-	}
-
 	/**
 	 * Creates the CGLIB {@link Enhancer}. Subclasses may wish to override this to return a custom
 	 * {@link Enhancer} implementation.
@@ -239,11 +237,11 @@ class CglibAopProxy implements AopProxy, Serializable {
 	 * Checks to see whether the supplied {@code Class} has already been validated and
 	 * validates it if not.
 	 */
-	private void validateClassIfNecessary(Class<?> proxySuperClass, ClassLoader proxyClassLoader) {
-		if (logger.isInfoEnabled()) {
+	private void validateClassIfNecessary(Class<?> proxySuperClass) {
+		if (logger.isWarnEnabled()) {
 			synchronized (validatedClasses) {
 				if (!validatedClasses.containsKey(proxySuperClass)) {
-					doValidateClass(proxySuperClass, proxyClassLoader);
+					doValidateClass(proxySuperClass);
 					validatedClasses.put(proxySuperClass, Boolean.TRUE);
 				}
 			}
@@ -251,28 +249,19 @@ class CglibAopProxy implements AopProxy, Serializable {
 	}

 	/**
-	 * Checks for final methods on the given {@code Class}, as well as package-visible
-	 * methods across ClassLoaders, and writes warnings to the log for each one found.
+	 * Checks for final methods on the {@code Class} and writes warnings to the log
+	 * for each one found.
 	 */
-	private void doValidateClass(Class<?> proxySuperClass, ClassLoader proxyClassLoader) {
-		if (!Object.class.equals(proxySuperClass)) {
-			Method[] methods = proxySuperClass.getDeclaredMethods();
+	private void doValidateClass(Class<?> proxySuperClass) {
+		if (logger.isWarnEnabled()) {
+			Method[] methods = proxySuperClass.getMethods();
 			for (Method method : methods) {
-				int mod = method.getModifiers();
-				if (!Modifier.isStatic(mod)) {
-					if (Modifier.isFinal(mod)) {
-						logger.info("Unable to proxy method [" + method + "] because it is final: " +
-								"All calls to this method via a proxy will NOT be routed to the target instance.");
-					}
-					else if (!Modifier.isPublic(mod) && !Modifier.isProtected(mod) && !Modifier.isPrivate(mod) &&
-							proxyClassLoader != null && proxySuperClass.getClassLoader() != proxyClassLoader) {
-						logger.info("Unable to proxy method [" + method + "] because it is package-visible " +
-								"across different ClassLoaders: All calls to this method via a proxy will " +
-								"NOT be routed to the target instance.");
-					}
+				if (!Object.class.equals(method.getDeclaringClass()) && !Modifier.isStatic(method.getModifiers()) &&
+						Modifier.isFinal(method.getModifiers())) {
+					logger.warn("Unable to proxy method [" + method + "] because it is final: " +
+							"All calls to this method via a proxy will be routed directly to the proxy.");
 				}
 			}
-			doValidateClass(proxySuperClass.getSuperclass(), proxyClassLoader);
 		}
 	}

@@ -304,13 +293,13 @@ class CglibAopProxy implements AopProxy, Serializable {
 		Callback targetDispatcher = isStatic ?
 				new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp();

-		Callback[] mainCallbacks = new Callback[] {
-				aopInterceptor,  // for normal advice
-				targetInterceptor,  // invoke target without considering advice, if optimized
-				new SerializableNoOp(),  // no override for methods mapped to this
-				targetDispatcher, this.advisedDispatcher,
-				new EqualsInterceptor(this.advised),
-				new HashCodeInterceptor(this.advised)
+		Callback[] mainCallbacks = new Callback[]{
+			aopInterceptor, // for normal advice
+			targetInterceptor, // invoke target without considering advice, if optimized
+			new SerializableNoOp(), // no override for methods mapped to this
+			targetDispatcher, this.advisedDispatcher,
+			new EqualsInterceptor(this.advised),
+			new HashCodeInterceptor(this.advised)
 		};

 		Callback[] callbacks;
@@ -323,7 +312,8 @@ class CglibAopProxy implements AopProxy, Serializable {
 			Callback[] fixedCallbacks = new Callback[methods.length];
 			this.fixedInterceptorMap = new HashMap<String, Integer>(methods.length);

-			// TODO: small memory optimisation here (can skip creation for methods with no advice)
+			// TODO: small memory optimisation here (can skip creation for
+			// methods with no advice)
 			for (int x = 0; x < methods.length; x++) {
 				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
 				fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
@@ -350,15 +340,16 @@ class CglibAopProxy implements AopProxy, Serializable {
 	 */
 	private static Object processReturnType(Object proxy, Object target, Method method, Object retVal) {
 		// Massage return value if necessary
-		if (retVal != null && retVal == target && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
-			// Special case: it returned "this". Note that we can't help
-			// if the target sets a reference to itself in another returned object.
+		if (retVal != null && retVal == target &&
+				!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
+			// Special case: it returned "this".
+			// Note that we can't help if the target sets a reference
+			// to itself in another returned object.
 			retVal = proxy;
 		}
 		Class<?> returnType = method.getReturnType();
 		if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
-			throw new AopInvocationException(
-					"Null return value from advice does not match primitive return type for: " + method);
+				throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
 		}
 		return retVal;
 	}
@@ -398,7 +389,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.target = target;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			Object retVal = methodProxy.invoke(this.target, args);
 			return processReturnType(proxy, this.target, method, retVal);
@@ -418,7 +408,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.target = target;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			Object oldProxy = null;
 			try {
@@ -446,7 +435,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.targetSource = targetSource;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			Object target = this.targetSource.getTarget();
 			try {
@@ -471,7 +459,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.targetSource = targetSource;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			Object oldProxy = null;
 			Object target = this.targetSource.getTarget();
@@ -501,7 +488,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.target = target;
 		}

-		@Override
 		public Object loadObject() {
 			return this.target;
 		}
@@ -519,7 +505,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.advised = advised;
 		}

-		@Override
 		public Object loadObject() throws Exception {
 			return this.advised;
 		}
@@ -538,7 +523,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.advised = advised;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) {
 			Object other = args[0];
 			if (proxy == other) {
@@ -571,7 +555,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.advised = advised;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) {
 			return CglibAopProxy.class.hashCode() * 13 + this.advised.getTargetSource().hashCode();
 		}
@@ -595,7 +578,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 			this.targetClass = targetClass;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			MethodInvocation invocation = new CglibMethodInvocation(proxy, this.target, method, args,
 					this.targetClass, this.adviceChain, methodProxy);
@@ -613,13 +595,12 @@ class CglibAopProxy implements AopProxy, Serializable {
 	 */
 	private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

-		private final AdvisedSupport advised;
+		private AdvisedSupport advised;

 		public DynamicAdvisedInterceptor(AdvisedSupport advised) {
 			this.advised = advised;
 		}

-		@Override
 		public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
 			Object oldProxy = null;
 			boolean setProxyContext = false;
@@ -631,8 +612,8 @@ class CglibAopProxy implements AopProxy, Serializable {
 					oldProxy = AopContext.setCurrentProxy(proxy);
 					setProxyContext = true;
 				}
-				// May be null. Get as late as possible to minimize the time we
-				// "own" the target, in case it comes from a pool...
+				// May be null Get as late as possible to minimize the time we
+				// "own" the target, in case it comes from a pool.
 				target = getTarget();
 				if (target != null) {
 					targetClass = target.getClass();
@@ -698,14 +679,13 @@ class CglibAopProxy implements AopProxy, Serializable {

 		private final MethodProxy methodProxy;

-		private final boolean publicMethod;
+		private boolean protectedMethod;

 		public CglibMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
 				Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {
-
 			super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);
 			this.methodProxy = methodProxy;
-			this.publicMethod = Modifier.isPublic(method.getModifiers());
+			this.protectedMethod = Modifier.isProtected(method.getModifiers());
 		}

 		/**
@@ -714,11 +694,11 @@ class CglibAopProxy implements AopProxy, Serializable {
 		 */
 		@Override
 		protected Object invokeJoinpoint() throws Throwable {
-			if (this.publicMethod) {
-				return this.methodProxy.invoke(this.target, this.arguments);
+			if (this.protectedMethod) {
+				return super.invokeJoinpoint();
 			}
 			else {
-				return super.invokeJoinpoint();
+				return this.methodProxy.invoke(this.target, this.arguments);
 			}
 		}
 	}
@@ -777,7 +757,6 @@ class CglibAopProxy implements AopProxy, Serializable {
 		 * DynamicUnadvisedInterceptor already considers this.</dd>
 		 * </dl>
 		 */
-		@Override
 		public int accept(Method method) {
 			if (AopUtils.isFinalizeMethod(method)) {
 				logger.debug("Found finalize() method - using NO_OVERRIDE");
@@ -822,7 +801,8 @@ class CglibAopProxy implements AopProxy, Serializable {
 					if (logger.isDebugEnabled()) {
 						logger.debug("Method has advice and optimisations are enabled: " + method);
 					}
-					// We know that we are optimising so we can use the FixedStaticChainInterceptors.
+					// We know that we are optimising so we can use the
+					// FixedStaticChainInterceptors.
 					int index = this.fixedInterceptorMap.get(key);
 					return (index + this.fixedInterceptorOffset);
 				}
@@ -838,8 +818,8 @@ class CglibAopProxy implements AopProxy, Serializable {
 				// of the target type. If so we know it never needs to have return type
 				// massage and can use a dispatcher.
 				// If the proxy is being exposed, then must use the interceptor the
-				// correct one is already configured. If the target is not static, then
-				// cannot use a dispatcher because the target cannot be released.
+				// correct one is already configured. If the target is not static cannot
+				// use a Dispatcher because the target can not then be released.
 				if (exposeProxy || !isStatic) {
 					return INVOKE_TARGET;
 				}
@@ -871,7 +851,7 @@ class CglibAopProxy implements AopProxy, Serializable {

 		@Override
 		public boolean equals(Object other) {
-			if (this == other) {
+			if (other == this) {
 				return true;
 			}
 			if (!(other instanceof ProxyCallbackFilter)) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -46,25 +46,22 @@ import org.springframework.aop.support.MethodMatchers;
@SuppressWarnings("serial")
 public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

-	@Override
 	public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
-			Advised config, Method method, Class<?> targetClass) {
+			Advised config, Method method, Class targetClass) {

-		// This is somewhat tricky... We have to process introductions first,
+		// This is somewhat tricky... we have to process introductions first,
 		// but we need to preserve order in the ultimate list.
 		List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
-		Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
-		boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
+		boolean hasIntroductions = hasMatchingIntroductions(config, targetClass);
 		AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
-
 		for (Advisor advisor : config.getAdvisors()) {
 			if (advisor instanceof PointcutAdvisor) {
 				// Add it conditionally.
 				PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
-				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
+				if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
 					MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
 					MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
-					if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
+					if (MethodMatchers.matches(mm, method, targetClass, hasIntroductions)) {
 						if (mm.isRuntime()) {
 							// Creating a new object instance in the getInterceptors() method
 							// isn't a problem as we normally cache created chains.
@@ -80,7 +77,7 @@ public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializ
 			}
 			else if (advisor instanceof IntroductionAdvisor) {
 				IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
-				if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
+				if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) {
 					Interceptor[] interceptors = registry.getInterceptors(advisor);
 					interceptorList.addAll(Arrays.asList(interceptors));
 				}
@@ -90,19 +87,18 @@ public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializ
 				interceptorList.addAll(Arrays.asList(interceptors));
 			}
 		}
-
 		return interceptorList;
 	}

 	/**
 	 * Determine whether the Advisors contain matching introductions.
 	 */
-	private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {
+	private static boolean hasMatchingIntroductions(Advised config, Class targetClass) {
 		for (int i = 0; i < config.getAdvisors().length; i++) {
 			Advisor advisor = config.getAdvisors()[i];
 			if (advisor instanceof IntroductionAdvisor) {
 				IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
-				if (ia.getClassFilter().matches(actualClass)) {
+				if (ia.getClassFilter().matches(targetClass)) {
 					return true;
 				}
 			}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -21,18 +21,21 @@ import java.io.Serializable;
 import org.springframework.aop.SpringProxy;

 /**
- * Default {@link AopProxyFactory} implementation, creating either a CGLIB proxy
- * or a JDK dynamic proxy.
+ * Default {@link AopProxyFactory} implementation,
+ * creating either a CGLIB proxy or a JDK dynamic proxy.
 *
- * <p>Creates a CGLIB proxy if one the following is true for a given
- * {@link AdvisedSupport} instance:
+ * <p>Creates a CGLIB proxy if one the following is true
+ * for a given {@link AdvisedSupport} instance:
 * <ul>
- * <li>the {@code optimize} flag is set
- * <li>the {@code proxyTargetClass} flag is set
+ * <li>the "optimize" flag is set
+ * <li>the "proxyTargetClass" flag is set
 * <li>no proxy interfaces have been specified
 * </ul>
 *
- * <p>In general, specify {@code proxyTargetClass} to enforce a CGLIB proxy,
+ * <p>Note that the CGLIB library classes have to be present on
+ * the class path if an actual CGLIB proxy needs to be created.
+ *
+ * <p>In general, specify "proxyTargetClass" to enforce a CGLIB proxy,
 * or specify one or more interfaces to use a JDK dynamic proxy.
 *
 * @author Rod Johnson
@@ -45,10 +48,10 @@ import org.springframework.aop.SpringProxy;
@SuppressWarnings("serial")
 public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

-	@Override
+
 	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
 		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
-			Class<?> targetClass = config.getTargetClass();
+			Class targetClass = config.getTargetClass();
 			if (targetClass == null) {
 				throw new AopConfigException("TargetSource cannot determine target class: " +
 						"Either an interface or a target is required for proxy creation.");
@@ -56,7 +59,7 @@ public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
 			if (targetClass.isInterface()) {
 				return new JdkDynamicAopProxy(config);
 			}
-			return new ObjenesisCglibAopProxy(config);
+			return CglibProxyFactory.createCglibProxy(config);
 		}
 		else {
 			return new JdkDynamicAopProxy(config);
@@ -69,7 +72,20 @@ public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
 	 * (or no proxy interfaces specified at all).
 	 */
 	private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
-		Class<?>[] interfaces = config.getProxiedInterfaces();
+		Class[] interfaces = config.getProxiedInterfaces();
 		return (interfaces.length == 0 || (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0])));
 	}
+
+
+	/**
+	 * Inner factory class used to just introduce a CGLIB dependency
+	 * when actually creating a CGLIB proxy.
+	 */
+	private static class CglibProxyFactory {
+
+		public static AopProxy createCglibProxy(AdvisedSupport advisedSupport) {
+			return new CglibAopProxy(advisedSupport);
+		}
+	}
+
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -75,7 +75,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 */

 	/** We use a static Log to avoid serialization issues */
-	private static final Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);
+	private static Log logger = LogFactory.getLog(JdkDynamicAopProxy.class);

 	/** Config used to configure this proxy */
 	private final AdvisedSupport advised;
@@ -106,17 +106,15 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	}


-	@Override
 	public Object getProxy() {
 		return getProxy(ClassUtils.getDefaultClassLoader());
 	}

-	@Override
 	public Object getProxy(ClassLoader classLoader) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
 		}
-		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
+		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
 		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
 		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
 	}
@@ -126,8 +124,8 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 * on the supplied set of interfaces.
 	 * @param proxiedInterfaces the interfaces to introspect
 	 */
-	private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
-		for (Class<?> proxiedInterface : proxiedInterfaces) {
+	private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
+		for (Class proxiedInterface : proxiedInterfaces) {
 			Method[] methods = proxiedInterface.getDeclaredMethods();
 			for (Method method : methods) {
 				if (AopUtils.isEqualsMethod(method)) {
@@ -149,14 +147,13 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 * <p>Callers will see exactly the exception thrown by the target,
 	 * unless a hook method throws an exception.
 	 */
-	@Override
 	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 		MethodInvocation invocation;
 		Object oldProxy = null;
 		boolean setProxyContext = false;

 		TargetSource targetSource = this.advised.targetSource;
-		Class<?> targetClass = null;
+		Class targetClass = null;
 		Object target = null;

 		try {
@@ -215,10 +212,8 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 				// is type-compatible. Note that we can't help if the target sets
 				// a reference to itself in another returned object.
 				retVal = proxy;
-			}
-			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
-				throw new AopInvocationException(
-						"Null return value from advice does not match primitive return type for: " + method);
+			} else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
+				throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
 			}
 			return retVal;
 		}
@@ -1,84 +0,0 @@
-/*
- * Copyright 2002-2015 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.framework;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
-import org.springframework.cglib.proxy.Callback;
-import org.springframework.cglib.proxy.Enhancer;
-import org.springframework.cglib.proxy.Factory;
-import org.springframework.objenesis.ObjenesisStd;
-
-/**
- * Objenesis-based extension of {@link CglibAopProxy} to create proxy instances
- * without invoking the constructor of the class.
- *
- * @author Oliver Gierke
- * @author Juergen Hoeller
- * @since 4.0
- */
-@SuppressWarnings("serial")
-class ObjenesisCglibAopProxy extends CglibAopProxy {
-
-	private static final Log logger = LogFactory.getLog(ObjenesisCglibAopProxy.class);
-
-	private final ObjenesisStd objenesis;
-
-
-	/**
-	 * Create a new ObjenesisCglibAopProxy for the given AOP configuration.
-	 * @param config the AOP configuration as AdvisedSupport object
-	 */
-	public ObjenesisCglibAopProxy(AdvisedSupport config) {
-		super(config);
-		this.objenesis = new ObjenesisStd(true);
-	}
-
-
-	@Override
-	@SuppressWarnings("unchecked")
-	protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
-		Class<?> proxyClass = enhancer.createClass();
-		Object proxyInstance = null;
-
-		try {
-			proxyInstance = this.objenesis.newInstance(proxyClass);
-		}
-		catch (Throwable ex) {
-			logger.debug("Unable to instantiate proxy using Objenesis, " +
-					"falling back to regular proxy construction", ex);
-		}
-
-		if (proxyInstance == null) {
-			// Regular instantiation via default constructor...
-			try {
-				proxyInstance = (this.constructorArgs != null ?
-						proxyClass.getConstructor(this.constructorArgTypes).newInstance(this.constructorArgs) :
-						proxyClass.newInstance());
-			}
-			catch (Throwable ex) {
-				throw new AopConfigException("Unable to instantiate proxy using Objenesis, " +
-						"and regular proxy instantiation via default constructor fails as well", ex);
-			}
-		}
-
-		((Factory) proxyInstance).setCallbacks(callbacks);
-		return proxyInstance;
-	}
-
-}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 the original author or authors.
+ * Copyright 2002-2013 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.
@@ -19,6 +19,7 @@ package org.springframework.aop.framework;
 import org.aopalliance.intercept.Interceptor;

 import org.springframework.aop.TargetSource;
+import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;

 /**
@@ -46,8 +47,9 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @param target the target object to be proxied
 	 */
 	public ProxyFactory(Object target) {
-		setTarget(target);
+		Assert.notNull(target, "Target object must not be null");
 		setInterfaces(ClassUtils.getAllInterfaces(target));
+		setTarget(target);
 	}

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -133,7 +133,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @see #setInterfaces
 	 * @see AbstractSingletonProxyFactoryBean#setProxyInterfaces
 	 */
-	public void setProxyInterfaces(Class<?>[] proxyInterfaces) throws ClassNotFoundException {
+	public void setProxyInterfaces(Class[] proxyInterfaces) throws ClassNotFoundException {
 		setInterfaces(proxyInterfaces);
 	}

@@ -154,7 +154,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @see org.aopalliance.aop.Advice
 	 * @see org.springframework.aop.target.SingletonTargetSource
 	 */
-	public void setInterceptorNames(String... interceptorNames) {
+	public void setInterceptorNames(String[] interceptorNames) {
 		this.interceptorNames = interceptorNames;
 	}

@@ -218,14 +218,12 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 		this.classLoaderConfigured = (classLoader != null);
 	}

-	@Override
 	public void setBeanClassLoader(ClassLoader classLoader) {
 		if (!this.classLoaderConfigured) {
 			this.proxyClassLoader = classLoader;
 		}
 	}

-	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 		checkInterceptorNames();
@@ -239,7 +237,6 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * {@code getObject()} for a proxy.
 	 * @return a fresh AOP proxy reflecting the current state of this factory
 	 */
-	@Override
 	public Object getObject() throws BeansException {
 		initializeAdvisorChain();
 		if (isSingleton()) {
@@ -260,14 +257,13 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * a single one), the target bean type, or the TargetSource's target class.
 	 * @see org.springframework.aop.TargetSource#getTargetClass
 	 */
-	@Override
 	public Class<?> getObjectType() {
 		synchronized (this) {
 			if (this.singletonInstance != null) {
 				return this.singletonInstance.getClass();
 			}
 		}
-		Class<?>[] ifcs = getProxiedInterfaces();
+		Class[] ifcs = getProxiedInterfaces();
 		if (ifcs.length == 1) {
 			return ifcs[0];
 		}
@@ -282,7 +278,6 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 		}
 	}

-	@Override
 	public boolean isSingleton() {
 		return this.singleton;
 	}
@@ -297,7 +292,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @return the merged interface as Class
 	 * @see java.lang.reflect.Proxy#getProxyClass
 	 */
-	protected Class<?> createCompositeInterface(Class<?>[] interfaces) {
+	protected Class createCompositeInterface(Class[] interfaces) {
 		return ClassUtils.createCompositeInterface(interfaces, this.proxyClassLoader);
 	}

@@ -311,7 +306,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 			this.targetSource = freshTargetSource();
 			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
 				// Rely on AOP infrastructure to tell us what interfaces to proxy.
-				Class<?> targetClass = getTargetClass();
+				Class targetClass = getTargetClass();
 				if (targetClass == null) {
 					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
 				}
@@ -401,7 +396,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @return {@code true} if it's an Advisor or Advice
 	 */
 	private boolean isNamedBeanAnAdvisorOrAdvice(String beanName) {
-		Class<?> namedBeanClass = this.beanFactory.getType(beanName);
+		Class namedBeanClass = this.beanFactory.getType(beanName);
 		if (namedBeanClass != null) {
 			return (Advisor.class.isAssignableFrom(namedBeanClass) || Advice.class.isAssignableFrom(namedBeanClass));
 		}
@@ -643,12 +638,10 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 			return beanName;
 		}

-		@Override
 		public Advice getAdvice() {
 			throw new UnsupportedOperationException("Cannot invoke methods: " + this.message);
 		}

-		@Override
 		public boolean isPerInstance() {
 			throw new UnsupportedOperationException("Cannot invoke methods: " + this.message);
 		}
@@ -1,145 +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.aop.framework;
-
-import org.springframework.beans.factory.Aware;
-import org.springframework.beans.factory.BeanClassLoaderAware;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.InitializingBean;
-import org.springframework.core.Ordered;
-import org.springframework.util.ClassUtils;
-import org.springframework.util.ObjectUtils;
-
-/**
- * Base class with common functionality for proxy processors, in particular
- * ClassLoader management and the {@link #evaluateProxyInterfaces} algorithm.
- *
- * @author Juergen Hoeller
- * @since 4.1
- * @see AbstractAdvisingBeanPostProcessor
- * @see org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
- */
-@SuppressWarnings("serial")
-public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {
-
-	/**
-	 * This should run after all other processors, so that it can just add
-	 * an advisor to existing proxies rather than double-proxy.
-	 */
-	private int order = Ordered.LOWEST_PRECEDENCE;
-
-	private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();
-
-	private boolean classLoaderConfigured = false;
-
-
-	/**
-	 * Set the ordering which will apply to this class's implementation
-	 * of Ordered, used when applying multiple processors.
-	 * <p>Default value is {@code Integer.MAX_VALUE}, meaning that it's non-ordered.
-	 * @param order the ordering value
-	 */
-	public void setOrder(int order) {
-		this.order = order;
-	}
-
-	@Override
-	public int getOrder() {
-		return this.order;
-	}
-
-	/**
-	 * Set the ClassLoader to generate the proxy class in.
-	 * <p>Default is the bean ClassLoader, i.e. the ClassLoader used by the containing
-	 * {@link org.springframework.beans.factory.BeanFactory} for loading all bean classes.
-	 * This can be overridden here for specific proxies.
-	 */
-	public void setProxyClassLoader(ClassLoader classLoader) {
-		this.proxyClassLoader = classLoader;
-		this.classLoaderConfigured = (classLoader != null);
-	}
-
-	/**
-	 * Return the configured proxy ClassLoader for this processor.
-	 */
-	protected ClassLoader getProxyClassLoader() {
-		return this.proxyClassLoader;
-	}
-
-	@Override
-	public void setBeanClassLoader(ClassLoader classLoader) {
-		if (!this.classLoaderConfigured) {
-			this.proxyClassLoader = classLoader;
-		}
-	}
-
-
-	/**
-	 * Check the interfaces on the given bean class and apply them to the {@link ProxyFactory},
-	 * if appropriate.
-	 * <p>Calls {@link #isConfigurationCallbackInterface} and {@link #isInternalLanguageInterface}
-	 * to filter for reasonable proxy interfaces, falling back to a target-class proxy otherwise.
-	 * @param beanClass the class of the bean
-	 * @param proxyFactory the ProxyFactory for the bean
-	 */
-	protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
-		Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
-		boolean hasReasonableProxyInterface = false;
-		for (Class<?> ifc : targetInterfaces) {
-			if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
-					ifc.getMethods().length > 0) {
-				hasReasonableProxyInterface = true;
-				break;
-			}
-		}
-		if (hasReasonableProxyInterface) {
-			// Must allow for introductions; can't just set interfaces to the target's interfaces only.
-			for (Class<?> ifc : targetInterfaces) {
-				proxyFactory.addInterface(ifc);
-			}
-		}
-		else {
-			proxyFactory.setProxyTargetClass(true);
-		}
-	}
-
-	/**
-	 * Determine whether the given interface is just a container callback and
-	 * therefore not to be considered as a reasonable proxy interface.
-	 * <p>If no reasonable proxy interface is found for a given bean, it will get
-	 * proxied with its full target class, assuming that as the user's intention.
-	 * @param ifc the interface to check
-	 * @return whether the given interface is just a container callback
-	 */
-	protected boolean isConfigurationCallbackInterface(Class<?> ifc) {
-		return (ifc.equals(InitializingBean.class) || ifc.equals(DisposableBean.class) ||
-				ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));
-	}
-
-	/**
-	 * Determine whether the given interface is a well-known internal language interface
-	 * and therefore not to be considered as a reasonable proxy interface.
-	 * <p>If no reasonable proxy interface is found for a given bean, it will get
-	 * proxied with its full target class, assuming that as the user's intention.
-	 * @param ifc the interface to check
-	 * @return whether the given interface is an internal language interface
-	 */
-	protected boolean isInternalLanguageInterface(Class<?> ifc) {
-		return ifc.getName().equals("groovy.lang.GroovyObject");
-	}
-
-}
@@ -68,7 +68,7 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea

 	protected Object[] arguments;

-	private final Class<?> targetClass;
+	private final Class targetClass;

 	/**
 	 * Lazily initialized map of user-specific attributes for this invocation.
@@ -79,7 +79,7 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 * List of MethodInterceptor and InterceptorAndDynamicMethodMatcher
 	 * that need dynamic checks.
 	 */
-	protected final List<?> interceptorsAndDynamicMethodMatchers;
+	protected final List interceptorsAndDynamicMethodMatchers;

 	/**
 	 * Index from 0 of the current interceptor we're invoking.
@@ -103,7 +103,7 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 */
 	protected ReflectiveMethodInvocation(
 			Object proxy, Object target, Method method, Object[] arguments,
-			Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
+			Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {

 		this.proxy = proxy;
 		this.target = target;
@@ -114,17 +114,14 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	}


-	@Override
 	public final Object getProxy() {
 		return this.proxy;
 	}

-	@Override
 	public final Object getThis() {
 		return this.target;
 	}

-	@Override
 	public final AccessibleObject getStaticPart() {
 		return this.method;
 	}
@@ -134,23 +131,19 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 * May or may not correspond with a method invoked on an underlying
 	 * implementation of that interface.
 	 */
-	@Override
 	public final Method getMethod() {
 		return this.method;
 	}

-	@Override
 	public final Object[] getArguments() {
 		return (this.arguments != null ? this.arguments : new Object[0]);
 	}

-	@Override
 	public void setArguments(Object[] arguments) {
 		this.arguments = arguments;
 	}


-	@Override
 	public Object proceed() throws Throwable {
 		//	We start with an index of -1 and increment early.
 		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
@@ -199,7 +192,6 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 * current interceptor index.
 	 * @see java.lang.Object#clone()
 	 */
-	@Override
 	public MethodInvocation invocableClone() {
 		Object[] cloneArguments = null;
 		if (this.arguments != null) {
@@ -218,7 +210,6 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	 * current interceptor index.
 	 * @see java.lang.Object#clone()
 	 */
-	@Override
 	public MethodInvocation invocableClone(Object[] arguments) {
 		// Force initialization of the user attributes Map,
 		// for having a shared Map reference in the clone.
@@ -239,7 +230,6 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 	}


-	@Override
 	public void setUserAttribute(String key, Object value) {
 		if (value != null) {
 			if (this.userAttributes == null) {
@@ -254,7 +244,6 @@ public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Clonea
 		}
 	}

-	@Override
 	public Object getUserAttribute(String key) {
 		return (this.userAttributes != null ? this.userAttributes.get(key) : null);
 	}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -48,12 +48,10 @@ public class AdvisorAdapterRegistrationManager implements BeanPostProcessor {
 	}


-	@Override
 	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 		return bean;
 	}

-	@Override
 	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
 		if (bean instanceof AdvisorAdapter){
 			this.advisorAdapterRegistry.registerAdvisorAdapter((AdvisorAdapter) bean);
@@ -34,12 +34,10 @@ import org.springframework.aop.AfterReturningAdvice;
@SuppressWarnings("serial")
 class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {

-	@Override
 	public boolean supportsAdvice(Advice advice) {
 		return (advice instanceof AfterReturningAdvice);
 	}

-	@Override
 	public MethodInterceptor getInterceptor(Advisor advisor) {
 		AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();
 		return new AfterReturningAdviceInterceptor(advice);
@@ -47,7 +47,6 @@ public class AfterReturningAdviceInterceptor implements MethodInterceptor, After
 		this.advice = advice;
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		Object retVal = mi.proceed();
 		this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
@@ -53,7 +53,6 @@ public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Se
 	}


-	@Override
 	public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
 		if (adviceObject instanceof Advisor) {
 			return (Advisor) adviceObject;
@@ -75,7 +74,6 @@ public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Se
 		throw new UnknownAdviceTypeException(advice);
 	}

-	@Override
 	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
 		List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
 		Advice advice = advisor.getAdvice();
@@ -93,7 +91,6 @@ public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Se
 		return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
 	}

-	@Override
 	public void registerAdvisorAdapter(AdvisorAdapter adapter) {
 		this.adapters.add(adapter);
 	}
@@ -34,12 +34,10 @@ import org.springframework.aop.MethodBeforeAdvice;
@SuppressWarnings("serial")
 class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

-	@Override
 	public boolean supportsAdvice(Advice advice) {
 		return (advice instanceof MethodBeforeAdvice);
 	}

-	@Override
 	public MethodInterceptor getInterceptor(Advisor advisor) {
 		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
 		return new MethodBeforeAdviceInterceptor(advice);
@@ -46,7 +46,6 @@ public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Seriali
 		this.advice = advice;
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );
 		return mi.proceed();
@@ -34,12 +34,10 @@ import org.springframework.aop.ThrowsAdvice;
@SuppressWarnings("serial")
 class ThrowsAdviceAdapter implements AdvisorAdapter, Serializable {

-	@Override
 	public boolean supportsAdvice(Advice advice) {
 		return (advice instanceof ThrowsAdvice);
 	}

-	@Override
 	public MethodInterceptor getInterceptor(Advisor advisor) {
 		return new ThrowsAdviceInterceptor(advisor.getAdvice());
 	}
@@ -61,7 +61,7 @@ public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
 	private final Object throwsAdvice;

 	/** Methods on throws advice, keyed by exception class */
-	private final Map<Class<?>, Method> exceptionHandlerMap = new HashMap<Class<?>, Method>();
+	private final Map<Class, Method> exceptionHandlerMap = new HashMap<Class, Method>();


 	/**
@@ -104,7 +104,7 @@ public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
 	 * @return a handler for the given exception type
 	 */
 	private Method getExceptionHandler(Throwable exception) {
-		Class<?> exceptionClass = exception.getClass();
+		Class exceptionClass = exception.getClass();
 		if (logger.isTraceEnabled()) {
 			logger.trace("Trying to find handler for exception of type [" + exceptionClass.getName() + "]");
 		}
@@ -119,7 +119,6 @@ public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
 		return handler;
 	}

-	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();
@@ -1,12 +1,18 @@
+
 /**
+ *
 * SPI package allowing Spring AOP framework to handle arbitrary advice types.
- *
- * <p>Users who want merely to <i>use</i> the Spring AOP framework, rather than extend
+ * <br>
+ * Users who want merely to <i>use</i> the Spring AOP framework, rather than extend
 * its capabilities, don't need to concern themselves with this package.
+ * <br>
+ * 	You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice,
+ * 	in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces.
+ * </br>
+ * <br>
+ * 	These adapters do not depend on any other Spring framework classes to allow such usage.
+ * </br>
 *
- * <p>You may wish to use these adapters to wrap Spring-specific advices, such as MethodBeforeAdvice,
- * in MethodInterceptor, to allow their use in another AOP framework supporting the AOP Alliance interfaces.
- *
- * <p>These adapters do not depend on any other Spring framework classes to allow such usage.
 */
 package org.springframework.aop.framework.adapter;
+
@@ -65,8 +65,8 @@ public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyC


 	@Override
-	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
-		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
+	protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
+		List advisors = findEligibleAdvisors(beanClass, beanName);
 		if (advisors.isEmpty()) {
 			return DO_NOT_PROXY;
 		}
@@ -83,7 +83,7 @@ public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyC
 	 * @see #sortAdvisors
 	 * @see #extendAdvisors
 	 */
-	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
+	protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
 		List<Advisor> candidateAdvisors = findCandidateAdvisors();
 		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
 		extendAdvisors(eligibleAdvisors);
@@ -111,7 +111,7 @@ public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyC
 	 * @see ProxyCreationContext#getCurrentProxiedBeanName()
 	 */
 	protected List<Advisor> findAdvisorsThatCanApply(
-			List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
+			List<Advisor> candidateAdvisors, Class beanClass, String beanName) {

 		ProxyCreationContext.setCurrentProxiedBeanName(beanName);
 		try {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -20,10 +20,8 @@ import java.beans.PropertyDescriptor;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 import org.aopalliance.aop.Advice;
@@ -33,18 +31,21 @@ import org.apache.commons.logging.LogFactory;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.TargetSource;
 import org.springframework.aop.framework.AopInfrastructureBean;
+import org.springframework.aop.framework.ProxyConfig;
 import org.springframework.aop.framework.ProxyFactory;
-import org.springframework.aop.framework.ProxyProcessorSupport;
 import org.springframework.aop.framework.adapter.AdvisorAdapterRegistry;
 import org.springframework.aop.framework.adapter.GlobalAdvisorAdapterRegistry;
 import org.springframework.aop.target.SingletonTargetSource;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.PropertyValues;
+import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.util.ClassUtils;

 /**
 * {@link org.springframework.beans.factory.config.BeanPostProcessor} implementation
@@ -87,8 +88,9 @@ import org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostP
 * @see DefaultAdvisorAutoProxyCreator
 */
@SuppressWarnings("serial")
-public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
-		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
+public abstract class AbstractAutoProxyCreator extends ProxyConfig
+		implements SmartInstantiationAwareBeanPostProcessor, BeanClassLoaderAware, BeanFactoryAware,
+		Ordered, AopInfrastructureBean {

 	/**
 	 * Convenience constant for subclasses: Return value for "do not proxy".
@@ -107,6 +109,9 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	/** Logger available to subclasses */
 	protected final Log logger = LogFactory.getLog(getClass());

+	/** Default value is same as non-ordered */
+	private int order = Ordered.LOWEST_PRECEDENCE;
+
 	/** Default is global AdvisorAdapterRegistry */
 	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();

@@ -123,19 +128,37 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport

 	private TargetSourceCreator[] customTargetSourceCreators;

+	private ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();
+
+	private boolean classLoaderConfigured = false;
+
 	private BeanFactory beanFactory;

 	private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<Object, Boolean>(64);

-	private final Set<String> targetSourcedBeans =
-			Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
+	// using a ConcurrentHashMap as a Set
+	private final Map<String, Boolean> targetSourcedBeans = new ConcurrentHashMap<String, Boolean>(16);

-	private final Set<Object> earlyProxyReferences =
-			Collections.newSetFromMap(new ConcurrentHashMap<Object, Boolean>(16));
+	// using a ConcurrentHashMap as a Set
+	private final Map<Object, Boolean> earlyProxyReferences = new ConcurrentHashMap<Object, Boolean>(16);

 	private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<Object, Class<?>>(16);


+	/**
+	 * Set the ordering which will apply to this class's implementation
+	 * of Ordered, used when applying multiple BeanPostProcessors.
+	 * <p>Default value is {@code Integer.MAX_VALUE}, meaning that it's non-ordered.
+	 * @param order ordering value
+	 */
+	public final void setOrder(int order) {
+		this.order = order;
+	}
+
+	public final int getOrder() {
+		return this.order;
+	}
+
 	/**
 	 * Set whether or not the proxy should be frozen, preventing advice
 	 * from being added to it once it is created.
@@ -175,7 +198,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	 * Ordering is significant: The TargetSource returned from the first matching
 	 * TargetSourceCreator (that is, the first that returns non-null) will be used.
 	 */
-	public void setCustomTargetSourceCreators(TargetSourceCreator... targetSourceCreators) {
+	public void setCustomTargetSourceCreators(TargetSourceCreator[] targetSourceCreators) {
 		this.customTargetSourceCreators = targetSourceCreators;
 	}

@@ -186,7 +209,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	 * This is perfectly valid, if "specific" interceptors such as matching
 	 * Advisors are all we want.
 	 */
-	public void setInterceptorNames(String... interceptorNames) {
+	public void setInterceptorNames(String[] interceptorNames) {
 		this.interceptorNames = interceptorNames;
 	}

@@ -198,7 +221,23 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 		this.applyCommonInterceptorsFirst = applyCommonInterceptorsFirst;
 	}

-	@Override
+	/**
+	 * Set the ClassLoader to generate the proxy class in.
+	 * <p>Default is the bean ClassLoader, i.e. the ClassLoader used by the
+	 * containing BeanFactory for loading all bean classes. This can be
+	 * overridden here for specific proxies.
+	 */
+	public void setProxyClassLoader(ClassLoader classLoader) {
+		this.proxyClassLoader = classLoader;
+		this.classLoaderConfigured = (classLoader != null);
+	}
+
+	public void setBeanClassLoader(ClassLoader classLoader) {
+		if (!this.classLoaderConfigured) {
+			this.proxyClassLoader = classLoader;
+		}
+	}
+
 	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 	}
@@ -212,31 +251,25 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	}


-	@Override
 	public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
 		Object cacheKey = getCacheKey(beanClass, beanName);
 		return this.proxyTypes.get(cacheKey);
 	}

-	@Override
 	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
 		return null;
 	}

-	@Override
 	public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
 		Object cacheKey = getCacheKey(bean.getClass(), beanName);
-		if (!this.earlyProxyReferences.contains(cacheKey)) {
-			this.earlyProxyReferences.add(cacheKey);
-		}
+		this.earlyProxyReferences.put(cacheKey, Boolean.TRUE);
 		return wrapIfNecessary(bean, beanName, cacheKey);
 	}

-	@Override
 	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
 		Object cacheKey = getCacheKey(beanClass, beanName);

-		if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
+		if (beanName == null || !this.targetSourcedBeans.containsKey(beanName)) {
 			if (this.advisedBeans.containsKey(cacheKey)) {
 				return null;
 			}
@@ -252,7 +285,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 		if (beanName != null) {
 			TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
 			if (targetSource != null) {
-				this.targetSourcedBeans.add(beanName);
+				this.targetSourcedBeans.put(beanName, Boolean.TRUE);
 				Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
 				Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
 				this.proxyTypes.put(cacheKey, proxy.getClass());
@@ -263,19 +296,16 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 		return null;
 	}

-	@Override
 	public boolean postProcessAfterInstantiation(Object bean, String beanName) {
 		return true;
 	}

-	@Override
 	public PropertyValues postProcessPropertyValues(
 			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {

 		return pvs;
 	}

-	@Override
 	public Object postProcessBeforeInitialization(Object bean, String beanName) {
 		return bean;
 	}
@@ -285,11 +315,10 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	 * identified as one to proxy by the subclass.
 	 * @see #getAdvicesAndAdvisorsForBean
 	 */
-	@Override
 	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
 		if (bean != null) {
 			Object cacheKey = getCacheKey(bean.getClass(), beanName);
-			if (!this.earlyProxyReferences.contains(cacheKey)) {
+			if (!this.earlyProxyReferences.containsKey(cacheKey)) {
 				return wrapIfNecessary(bean, beanName, cacheKey);
 			}
 		}
@@ -315,7 +344,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	 * @return a proxy wrapping the bean, or the raw bean instance as-is
 	 */
 	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
-		if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
+		if (beanName != null && this.targetSourcedBeans.containsKey(beanName)) {
 			return bean;
 		}
 		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
@@ -420,14 +449,15 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 			Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

 		ProxyFactory proxyFactory = new ProxyFactory();
+		// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
 		proxyFactory.copyFrom(this);

-		if (!proxyFactory.isProxyTargetClass()) {
-			if (shouldProxyTargetClass(beanClass, beanName)) {
-				proxyFactory.setProxyTargetClass(true);
-			}
-			else {
-				evaluateProxyInterfaces(beanClass, proxyFactory);
+		if (!shouldProxyTargetClass(beanClass, beanName)) {
+			// Must allow for introductions; can't just set interfaces to
+			// the target's interfaces only.
+			Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
+			for (Class<?> targetInterface : targetInterfaces) {
+				proxyFactory.addInterface(targetInterface);
 			}
 		}

@@ -444,12 +474,14 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 			proxyFactory.setPreFiltered(true);
 		}

-		return proxyFactory.getProxy(getProxyClassLoader());
+		return proxyFactory.getProxy(this.proxyClassLoader);
 	}

 	/**
-	 * Determine whether the given bean should be proxied with its target class rather than its interfaces.
-	 * <p>Checks the {@link AutoProxyUtils#PRESERVE_TARGET_CLASS_ATTRIBUTE "preserveTargetClass" attribute}
+	 * Determine whether the given bean should be proxied with its target
+	 * class rather than its interfaces. Checks the
+	 * {@link #setProxyTargetClass "proxyTargetClass" setting} as well as the
+	 * {@link AutoProxyUtils#PRESERVE_TARGET_CLASS_ATTRIBUTE "preserveTargetClass" attribute}
 	 * of the corresponding bean definition.
 	 * @param beanClass the class of the bean
 	 * @param beanName the name of the bean
@@ -457,8 +489,9 @@ public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
 	 * @see AutoProxyUtils#shouldProxyTargetClass
 	 */
 	protected boolean shouldProxyTargetClass(Class<?> beanClass, String beanName) {
-		return (this.beanFactory instanceof ConfigurableListableBeanFactory &&
-				AutoProxyUtils.shouldProxyTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName));
+		return (isProxyTargetClass() ||
+				(this.beanFactory instanceof ConfigurableListableBeanFactory &&
+						AutoProxyUtils.shouldProxyTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName)));
 	}

 	/**
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -60,7 +60,7 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 	 * @see org.springframework.beans.factory.FactoryBean
 	 * @see org.springframework.beans.factory.BeanFactory#FACTORY_BEAN_PREFIX
 	 */
-	public void setBeanNames(String... beanNames) {
+	public void setBeanNames(String[] beanNames) {
 		Assert.notEmpty(beanNames, "'beanNames' must not be empty");
 		this.beanNames = new ArrayList<String>(beanNames.length);
 		for (String mappedName : beanNames) {
@@ -73,7 +73,7 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 	 * Identify as bean to proxy if the bean name is in the configured list of names.
 	 */
 	@Override
-	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
+	protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
 		if (this.beanNames != null) {
 			for (String mappedName : this.beanNames) {
 				if (FactoryBean.class.isAssignableFrom(beanClass)) {
@@ -79,7 +79,6 @@ public class DefaultAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCrea
 		return this.advisorBeanNamePrefix;
 	}

-	@Override
 	public void setBeanName(String name) {
 		// If no infrastructure bean name prefix has been set, override it.
 		if (this.advisorBeanNamePrefix == null) {
@@ -1,4 +1,6 @@
+
 /**
+ *
 * Bean post-processors for use in ApplicationContexts to simplify AOP usage
 * by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
 *
@@ -8,5 +10,7 @@
 * <p><b>NB</b>: Automatic auto-proxying is not supported for BeanFactory implementations,
 * as post-processors beans are only automatically detected in application contexts.
 * Post-processors can be explicitly registered on a ConfigurableBeanFactory instead.
+ *
 */
 package org.springframework.aop.framework.autoproxy;
+
@@ -66,7 +66,6 @@ public abstract class AbstractBeanFactoryBasedTargetSourceCreator
 			new HashMap<String, DefaultListableBeanFactory>();


-	@Override
 	public final void setBeanFactory(BeanFactory beanFactory) {
 		if (!(beanFactory instanceof ConfigurableBeanFactory)) {
 			throw new IllegalStateException("Cannot do auto-TargetSource creation with a BeanFactory " +
@@ -87,7 +86,6 @@ public abstract class AbstractBeanFactoryBasedTargetSourceCreator
 	// Implementation of the TargetSourceCreator interface
 	//---------------------------------------------------------------------

-	@Override
 	public final TargetSource getTargetSource(Class<?> beanClass, String beanName) {
 		AbstractBeanFactoryBasedTargetSource targetSource =
 				createBeanFactoryBasedTargetSource(beanClass, beanName);
@@ -161,7 +159,6 @@ public abstract class AbstractBeanFactoryBasedTargetSourceCreator
 	 * Destroys the internal BeanFactory on shutdown of the TargetSourceCreator.
 	 * @see #getInternalBeanFactoryForBean
 	 */
-	@Override
 	public void destroy() {
 		synchronized (this.internalBeanFactories) {
 			for (DefaultListableBeanFactory bf : this.internalBeanFactories.values()) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2014 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.
@@ -25,7 +25,7 @@ import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 * TargetSourceCreator that enforces a LazyInitTargetSource for each bean
 * that is defined as "lazy-init". This will lead to a proxy created for
 * each of those beans, allowing to fetch a reference to such a bean
- * without actually initializing the target bean instance.
+ * without actually initialized the target bean instance.
 *
 * <p>To be registered as custom TargetSourceCreator for an auto-proxy creator,
 * in combination with custom interceptors for specific beans or for the
@@ -60,7 +60,7 @@ public class LazyInitTargetSourceCreator extends AbstractBeanFactoryBasedTargetS

 	@Override
 	protected AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(
-			Class<?> beanClass, String beanName) {
+			Class beanClass, String beanName) {

 		if (getBeanFactory() instanceof ConfigurableListableBeanFactory) {
 			BeanDefinition definition =
@@ -41,7 +41,7 @@ public class QuickTargetSourceCreator extends AbstractBeanFactoryBasedTargetSour

 	@Override
 	protected final AbstractBeanFactoryBasedTargetSource createBeanFactoryBasedTargetSource(
-			Class<?> beanClass, String beanName) {
+			Class beanClass, String beanName) {

 		if (beanName.startsWith(PREFIX_COMMONS_POOL)) {
 			CommonsPoolTargetSource cpts = new CommonsPoolTargetSource();
--- a/Show More
+++ b/Show More