Merge branch 'spring-operator-polish-urls-build-4.1.x' into 4.1.x

Closes gh-22518

.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*.{adoc,bat,groovy,html,java,js,jsp,kt,kts,md,properties,py,rb,sh,sql,svg,txt,xml,xsd}]
-charset = utf-8
-
-[*.{groovy,java,kt,kts,xml,xsd}]
-indent_style = tab
-indent_size = 4
-continuation_indent_size = 8
-end_of_line = lf

.gitignore

@@ -17,7 +17,6 @@ argfile*
 pom.xml
 activemq-data/
 
-classes/
 /build
 buildSrc/build
 /spring-*/build

CODE_OF_CONDUCT.adoc

@@ -1,44 +0,0 @@
-= Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of fostering an open
-and welcoming community, we pledge to respect all people who contribute through reporting
-issues, posting feature requests, updating documentation, submitting pull requests or
-patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for
-everyone, regardless of level of experience, gender, gender identity and expression,
-sexual orientation, disability, personal appearance, body size, race, ethnicity, age,
-religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic addresses,
-  without explicit permission
-* Other unethical or unprofessional conduct
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments,
-commits, code, wiki edits, issues, and other contributions that are not aligned to this
-Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors
-that they deem inappropriate, threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to fairly and
-consistently applying these principles to every aspect of managing this project. Project
-maintainers who do not follow or enforce the Code of Conduct may be permanently removed
-from the project team.
-
-This Code of Conduct applies both within project spaces and in public spaces when an
-individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by
-contacting a project maintainer at spring-code-of-conduct@pivotal.io . All complaints will
-be reviewed and investigated and will result in a response that is deemed necessary and
-appropriate to the circumstances. Maintainers are obligated to maintain confidentiality
-with regard to the reporter of an incident.
-
-This Code of Conduct is adapted from the
-http://contributor-covenant.org[Contributor Covenant], version 1.3.0, available at
-http://contributor-covenant.org/version/1/3/0/[contributor-covenant.org/version/1/3/0/]

CONTRIBUTING-DOCUMENTATION.adoc

@@ -1,60 +1,51 @@
-= How to Contribute to the Reference Manual
+= How to contribute to the reference
 
-The Spring Framework reference manual uses http://asciidoctor.org/[asciidoctor]. This
+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 `asciidoctor` task. For example,
-from the project root execute the following command:
+You can build the documentation using gradle using the `reference` task. For example, from
+the project root execute the following command:
 
-[indent=0]
-----
-	./gradlew asciidoctor
-----
+	./gradlew reference
 
-The generated reference manual will then be available at
-`build/asciidoc/html5/index.html`.
+the output will be available at `spring-framework/build/reference/htmlsingle/index.html`
 
-== Live Editing
+== Live editing
 
-One of the nice features about using Asciidoctor is the support for 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/docs/asciidoc/Guardfile`. First, 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]):
+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]):
 
-[indent=0]
-----
 	gem install guard-rspec guard-livereload
-----
 
 When running `guard start` within the `src/asciidoc/` folder, any changes to the
-`src/asciidoc/index.adoc` file are automatically written to
+`src/asciidoc/index.adoc` file will automatically be written at
 `src/asciidoc/build/index.html`.
 
 == Troubleshooting
 
-* If you are using LiveReload, 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, type `e` in the shell.
+* 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
+== Documentation notes
 
-Some notes on the documentation.
+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.
-
-Here are some useful resources for working with Asciidoctor:
+* 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]
+

CONTRIBUTING.md

@@ -6,10 +6,6 @@ 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!_
 
-## Code of Conduct
-This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.adoc).
-By participating, you  are expected to uphold this code. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
-
 ## Take Your First Steps
 
 ### Understand the basics
@@ -17,15 +13,8 @@ By participating, you  are expected to uphold this code. Please report unaccepta
 Not sure what a pull request is, or how to submit one? Take a look at GitHub's
 excellent [help documentation][] first.
 
-### Search Stack Overflow first; discuss if necessary
 
-If you're unsure why something isn't working or wondering if there is a better
-way of doing it please check on Stack Overflow first and if necessary start
-a discussion. This is the official list of
-[Spring project tags](https://spring.io/questions). In short the issue tracker
-should be used to report issues and make feature requests.
-
-### Search JIRA; 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
@@ -33,18 +22,32 @@ 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.
 
-### Sign the Contributor License Agreement (CLA)
+### Sign the Contributor License Agreement
 
-If you have not previously done so, please sign the [Contributor License Agreement][].
-If you forget to do so, you'll be reminded when you submit a pull request.
+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.
+Keep track of this; you may be asked for it later!
+
+Note that emailing/postal mailing a signed copy is _not_ necessary. Submission
+of the web form is all that is required.
+
+Once you've completed the web form, simply add the following in a comment on
+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
+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`
 
-Master currently represents work toward Spring Framework 5.0. Please submit
+Master currently represents work toward Spring Framework 4.0. Please submit
 all pull requests there, even bug fixes and minor improvements. Backports to
-`4.3.x` will be considered on a case-by-case basis.
+`3.2.x` will be considered on a case-by-case basis.
 
 
 ### Use short branch names
@@ -74,14 +77,15 @@ present in the framework.
 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.
-1. UTF-8 encoding for Java sources
+1. Latin-1 (ISO-8859-1) encoding for Java sources; use `native2ascii` to convert
+    if necessary
 
 
 ### Add Apache license header to all new classes
 
 ```java
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -102,18 +106,16 @@ package ...;
 ### Update Apache license header in modified files as necessary
 
 Always check the date range in the license header. For example, if you've
-modified a file in 2017 whose header still reads:
+modified a file in 2014 whose header still reads:
 
 ```java
-/*
  * Copyright 2002-2011 the original author or authors.
 ```
 
-Then be sure to update it to 2017 accordingly:
+Then be sure to update it to 2014 accordingly:
 
 ```java
-/*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
 ```
 
 ### Use @since tags for newly-added public API types and methods
@@ -125,7 +127,7 @@ For example:
  * ...
  *
  * @author First Last
- * @since 5.0
+ * @since 4.0
  * @see ...
  */
 ```
@@ -177,11 +179,11 @@ intend to submit as pull requests. For example, this is not acceptable:
     Author: Nickname <user@mail.com>
 
 Rather, please include your first and last name, properly capitalized, as
-submitted against the Spring Individual Contributor License Agreement (ICLA):
+submitted against the SpringSource contributor license agreement:
 
     Author: First Last <user@mail.com>
 
-This helps ensure traceability against the ICLA 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
@@ -224,16 +226,16 @@ Most importantly, please format your commit messages in the following way
     Issue: SPR-1234, SPR-1235
 
 
-1. Use imperative statements in the subject line, e.g. "Fix broken Javadoc link".
+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. Do not end the subject line with a period.
-1. Restrict the subject line to 50 characters or less if possible.
-1. Wrap lines in the body at 72 characters or less.
+1. Do not end the subject line with a period
+1. Restrict 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:
@@ -264,9 +266,9 @@ In the body:
     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
-    continue one from JIRA.
-1. Mention the JIRA issue ID.
-1. Also mention that you have submitted the ICLA as described above.
+    continue one from JIRA
+1. Mention the JIRA issue ID
+1. Also mention that you have submitted the CLA as described above
 
 Note that for pull requests containing a single commit, GitHub will default the
 subject line and body of the pull request to match the subject line and body of
@@ -294,9 +296,10 @@ 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.
 
-[help documentation]: https://help.github.com/categories/collaborating-on-projects-using-issues-and-pull-requests/
+[help documentation]: http://help.github.com/send-pull-requests
 [JIRA issue tracker]: https://jira.spring.io/browse/SPR
-[Contributor License Agreement]: https://cla.pivotal.io/sign/spring
+[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

README.md

@@ -1,33 +1,30 @@
 ## Spring Framework
 The Spring Framework provides a comprehensive programming and configuration
-model for modern Java-based enterprise applications -- on any kind of deployment
+model for modern Java-based enterprise applications - on any kind of deployment
 platform. A key element of Spring is infrastructural support at the application
 level: Spring focuses on the "plumbing" of enterprise applications so that teams
 can focus on application-level business logic, without unnecessary ties to
 specific deployment environments.
 
-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.
-
-## Code of Conduct
-This project adheres to the Contributor Covenant [code of conduct](CODE_OF_CONDUCT.adoc).
-By participating, you  are expected to uphold this code. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
+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.
 
 ## 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][].
+use Maven or other transitive dependency management tools? See [building a
+distribution with dependencies][].
 
 ## Documentation
 See the current [Javadoc][] and [reference docs][].
 
 ## Getting Support
-Check out the [spring][spring tags] tags on [Stack Overflow][]. [Commercial 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.
 
 ## Issue Tracking
-Report issues via the [Spring Framework JIRA][]. Understand our issue management
+Report issues via the [Spring Framework JIRA]. Understand our issue management
 process by reading about [the lifecycle of an issue][]. Think you've found a
 bug? Please consider submitting a reproduction project via the
 [spring-framework-issues][] GitHub repository. The [readme][] there provides
@@ -80,7 +77,9 @@ The Spring Framework is released under version 2.0 of the [Apache License][].
 [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 tags]: http://spring.io/questions
+[Spring forums]: http://forum.spring.io/
+[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
@@ -92,7 +91,7 @@ The Spring Framework is released under version 2.0 of the [Apache License][].
 [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
-[Pull requests]: https://help.github.com/categories/collaborating-on-projects-using-issues-and-pull-requests/
+[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

buildSrc/spring-build-src.gradle

@@ -1,10 +0,0 @@
-description = "Exposes gradle buildSrc for IDE support"
-
-apply plugin: "groovy"
-
-dependencies {
-	compile gradleApi()
-	compile localGroovy()
-}
-
-configurations.archives.artifacts.clear()

buildSrc/src/main/groovy/org/springframework/build/gradle/DetectSplitPackagesPlugin.groovy

@@ -0,0 +1,158 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.GradleException
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.TaskAction
+
+
+/**
+ * Gradle plugin that detects identically named, non-empty packages split across multiple
+ * subprojects, e.g. "org.springframework.context.annotation" existing in both spring-core
+ * and spring-aspects. Adds a 'detectSplitPackages' task to the current project's task
+ * collection. If the project already contains a 'check' task (i.e. is a typical Gradle
+ * project with the "java" plugin applied), the 'check' task will be updated to depend on
+ * the execution of 'detectSplitPackages'.
+ *
+ * By default, all subprojects will be scanned. Use the 'projectsToScan' task property to
+ * modify this value. Example usage:
+ *
+ *     apply plugin: 'detect-split-packages // typically applied to root project
+ *
+ *     detectSplitPackages {
+ *         packagesToScan -= project(":spring-xyz") // scan every project but spring-xyz
+ *     }
+ *
+ * @author Rob Winch
+ * @author Glyn Normington
+ * @author Chris Beams
+ */
+public class DetectSplitPackagesPlugin implements Plugin<Project> {
+	public void apply(Project project) {
+		def tasks = project.tasks
+		Task detectSplitPackages = tasks.create("detectSplitPackages", DetectSplitPackagesTask.class)
+		if (tasks.asMap.containsKey("check")) {
+			tasks.getByName("check").dependsOn detectSplitPackages
+		}
+	}
+}
+
+public class DetectSplitPackagesTask extends DefaultTask {
+
+	private static final String JAVA_FILE_SUFFIX = ".java"
+	private static final String PACKAGE_SEPARATOR = "."
+	private static final String HIDDEN_DIRECTORY_PREFIX = "."
+
+	@Input
+	Set<Project> projectsToScan = project.subprojects
+
+	public DetectSplitPackagesTask() {
+		this.group = "Verification"
+		this.description = "Detects packages split across two or more subprojects."
+	}
+
+	@TaskAction
+	public void detectSplitPackages() {
+		def splitPackages = doDetectSplitPackages()
+		if (!splitPackages.isEmpty()) {
+			def message = "The following split package(s) have been detected:\n"
+			splitPackages.each { pkg, mod ->
+				message += " - ${pkg} (split across ${mod[0].name} and ${mod[1].name})\n"
+			}
+			throw new GradleException(message)
+		}
+	}
+
+	private Map<String, List<Project>> doDetectSplitPackages() {
+		def splitPackages = [:]
+		def mergedProjects = findMergedProjects()
+		def packagesByProject = mapPackagesByProject()
+
+		def projects = packagesByProject.keySet().toArray()
+		def nProjects = projects.length
+
+		for (int i = 0; i < nProjects - 1; i++) {
+			for (int j = i + 1; j < nProjects - 1; j++) {
+				def prj_i = projects[i]
+				def prj_j = projects[j]
+
+				def pkgs_i = new HashSet(packagesByProject.get(prj_i))
+				def pkgs_j = packagesByProject.get(prj_j)
+				pkgs_i.retainAll(pkgs_j)
+
+				if (!pkgs_i.isEmpty()
+						&& mergedProjects.get(prj_i) != prj_j
+						&& mergedProjects.get(prj_j) != prj_i) {
+					pkgs_i.each { pkg ->
+						def readablePkg = pkg.substring(1).replaceAll(File.separator, PACKAGE_SEPARATOR)
+						splitPackages[readablePkg] = [prj_i, prj_j]
+					}
+				}
+			}
+		}
+		return splitPackages;
+	}
+
+	private Map<Project, Set<String>> mapPackagesByProject() {
+		def packagesByProject = [:]
+		this.projectsToScan.each { Project p ->
+			def packages = new HashSet<String>()
+			p.sourceSets.main.java.srcDirs.each { File dir ->
+				findPackages(packages, dir, "")
+			}
+			if (!packages.isEmpty()) {
+				packagesByProject.put(p, packages)
+			}
+		}
+		return packagesByProject;
+	}
+
+	private Map<Project, Project> findMergedProjects() {
+		def mergedProjects = [:]
+		this.projectsToScan.findAll { p ->
+			p.plugins.findPlugin(MergePlugin)
+		}.findAll { p ->
+			p.merge.into
+		}.each { p ->
+			mergedProjects.put(p, p.merge.into)
+		}
+		return mergedProjects
+	}
+
+	private static void findPackages(Set<String> packages, File dir, String packagePath) {
+		def scanDir = new File(dir, packagePath)
+		def File[] javaFiles = scanDir.listFiles({ file ->
+			!file.isDirectory() && file.name.endsWith(JAVA_FILE_SUFFIX)
+		} as FileFilter)
+
+		if (javaFiles != null && javaFiles.length != 0) {
+			packages.add(packagePath)
+		}
+
+		scanDir.listFiles({ File file ->
+			file.isDirectory() && !file.name.startsWith(HIDDEN_DIRECTORY_PREFIX)
+		} as FileFilter).each { File subDir ->
+			findPackages(packages, dir, packagePath + File.separator + subDir.name)
+		}
+	}
+}
+

buildSrc/src/main/groovy/org/springframework/build/gradle/MergePlugin.groovy

@@ -0,0 +1,157 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.*
+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.plugins.ide.eclipse.EclipsePlugin
+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
+ * 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">
+ * configure(subprojects) {
+ *     apply plugin: MergePlugin
+ * }
+ *
+ * project("myproject") {
+ * }
+ *
+ * project("myproject-extra") {
+ *     merge.into = project("myproject")
+ * }
+ * </pre>
+ * <p>
+ * This plugin adds two new configurations:
+ * <ul>
+ * <li>merging - Contains the projects being merged into this project<li>
+ * <li>runtimeMerge - Contains all dependencies that are merge projects. These are used
+ * to allow an IDE to reference merge projects.</li>
+ * <ul>
+ *
+ * @author Rob Winch
+ * @author Phillip Webb
+ */
+class MergePlugin implements Plugin<Project> {
+
+	private static boolean attachedProjectsEvaluated;
+
+	public void apply(Project project) {
+		project.plugins.apply(MavenPlugin)
+		project.plugins.apply(EclipsePlugin)
+		project.plugins.apply(IdeaPlugin)
+
+		MergeModel model = project.extensions.create("merge", MergeModel)
+		project.configurations.create("merging")
+		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 ]
+
+		// Hook to perform the actual merge logic
+		project.afterEvaluate{
+			if (it.merge.into != null) {
+				setup(it)
+			}
+		}
+
+		// Hook to build runtimeMerge dependencies
+		if (!attachedProjectsEvaluated) {
+			project.gradle.projectsEvaluated{
+				postProcessProjects(it)
+			}
+			attachedProjectsEvaluated  = true;
+		}
+	}
+
+	private void setup(Project project) {
+		project.merge.into.dependencies.add("merging", project)
+		project.dependencies.add("provided", project.merge.into.sourceSets.main.output)
+		project.dependencies.add("runtimeMerge", project.merge.into)
+		setupTaskDependencies(project)
+		setupMaven(project)
+	}
+
+	private void setupTaskDependencies(Project 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) {
+				task.enabled = false
+				task.dependsOn(project.merge.into.tasks.findByPath(it))
+			}
+		}
+
+		// update 'into' project artifacts to contain the source artifact contents
+		project.merge.into.sourcesJar.from(project.sourcesJar.source)
+		project.merge.into.jar.from(project.sourceSets.main.output)
+		project.merge.into.javadoc {
+			source += project.javadoc.source
+			classpath += project.javadoc.classpath
+		}
+	}
+
+	private void setupMaven(Project project) {
+		project.configurations.each { configuration ->
+			Conf2ScopeMapping mapping = project.conf2ScopeMappings.getMapping([configuration])
+			if (mapping.scope) {
+				Configuration intoConfiguration = project.merge.into.configurations.create(
+					project.name + "-" + configuration.name)
+				configuration.excludeRules.each {
+					configuration.exclude([
+						(ExcludeRule.GROUP_KEY) : it.group,
+						(ExcludeRule.MODULE_KEY) : it.module])
+				}
+				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)) {
+						intoConfiguration.dependencies.add(it)
+					}
+				}
+				project.merge.into.install.repositories.mavenInstaller.pom.scopeMappings.addMapping(
+					mapping.priority + 100, intoConfiguration, mapping.scope)
+			}
+		}
+	}
+
+	private postProcessProjects(Gradle gradle) {
+		gradle.allprojects(new Action<Project>() {
+			public void execute(Project project) {
+				project.configurations.getByName("runtime").allDependencies.withType(ProjectDependency).each{
+					Configuration dependsOnMergedFrom = it.dependencyProject.configurations.getByName("merging");
+					dependsOnMergedFrom.dependencies.each{ dep ->
+						project.dependencies.add("runtimeMerge", dep.dependencyProject)
+					}
+				}
+			}
+		});
+	}
+}
+
+class MergeModel {
+	Project into;
+}

buildSrc/src/main/resources/META-INF/gradle-plugins/detect-split-packages.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.DetectSplitPackagesPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/merge.properties

@@ -0,0 +1 @@
+implementation-class=org.springframework.build.gradle.MergePlugin

gradle.properties

@@ -1 +1 @@
-version=5.0.0.RC4
+version=4.1.10.BUILD-SNAPSHOT

gradle/docs.gradle

@@ -1,230 +0,0 @@
-/*
- * Copyright 2002-2017 the original author or authors.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *       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.
- */
-
-task api(type: Javadoc) {
-	group = "Documentation"
-	description = "Generates aggregated Javadoc API documentation."
-	title = "${rootProject.description} ${version} API"
-
-	dependsOn {
-		subprojects.collect {
-			it.tasks.getByName("jar")
-		}
-	}
-	options.memberLevel = org.gradle.external.javadoc.JavadocMemberLevel.PROTECTED
-	options.author = true
-	options.header = rootProject.description
-	options.overview = "src/docs/api/overview.html"
-	options.stylesheetFile = file("src/docs/api/stylesheet.css")
-	options.splitIndex = true
-	options.links(project.ext.javadocLinks)
-	options.addStringOption('Xdoclint:none', '-quiet')
-
-	source subprojects.collect { project ->
-		project.sourceSets.main.allJava
-	}
-
-	maxMemory = "1024m"
-	destinationDir = new File(buildDir, "api")
-
-	doFirst {
-		classpath = files(
-				// ensure the javadoc process can resolve types compiled from .aj sources
-				project(":spring-aspects").sourceSets.main.output
-		)
-		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
-	}
-}
-
-// Need https://github.com/Kotlin/dokka/issues/184 to be fixed to avoid "Can't find node by signature" log spam
-dokka {
-	dependsOn {
-		subprojects.collect {
-			it.tasks.getByName("jar")
-		}
-	}
-	doFirst {
-		classpath = subprojects.collect { project -> project.jar.outputs.files.getFiles() }.flatten()
-		classpath += files(subprojects.collect { it.sourceSets.main.compileClasspath })
-
-	}
-	moduleName = "spring-framework"
-	outputFormat = "html"
-	outputDirectory = "$buildDir/docs/kdoc"
-
-	sourceDirs = files(subprojects.collect { project ->
-		project.sourceSets.main.kotlin.srcDirs
-	})
-	externalDocumentationLink {
-		url = new URL("http://docs.spring.io/spring-framework/docs/${version}/javadoc-api/")
-	}
-	externalDocumentationLink {
-		url = new URL("http://projectreactor.io/docs/core/release/api/")
-	}
-	externalDocumentationLink {
-		url = new URL("http://www.reactive-streams.org/reactive-streams-1.0.1-javadoc/")
-	}
-}
-
-asciidoctor {
-	sources {
-		include '*.adoc'
-	}
-	logDocuments = true
-	backends = ["html5"]
-	// only ouput PDF documentation for non-SNAPSHOT builds
-	if(!project.getVersion().toString().contains("BUILD-SNAPSHOT")) {
-		backends += "pdf"
-	}
-	options doctype: 'book', eruby: 'erubis'
-	attributes  'icons': 'font',
-			'idprefix': '',
-			'idseparator': '-',
-			docinfo: '',
-			revnumber: project.version,
-			sectanchors: '',
-			sectnums: '',
-			'source-highlighter': 'coderay@', // TODO switch to 'rouge' once supported by the html5 backend
-			stylesdir: 'stylesheets/',
-			stylesheet: 'spring.css',
-			'spring-version': project.version
-
-}
-
-task docsZip(type: Zip, dependsOn: ['api', 'asciidoctor', 'dokka']) {
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "docs"
-	description = "Builds -${classifier} archive containing api and reference " +
-			"for deployment at http://docs.spring.io/spring-framework/docs."
-
-	from("src/dist") {
-		include "changelog.txt"
-	}
-
-	from (api) {
-		into "javadoc-api"
-	}
-
-	from (asciidoctor) {
-		into "spring-framework-reference"
-	}
-
-	from (dokka) {
-		into "kdoc-api"
-	}
-}
-
-task schemaZip(type: Zip) {
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "schema"
-	description = "Builds -${classifier} archive containing all " +
-			"XSDs for deployment at http://springframework.org/schema."
-	duplicatesStrategy 'exclude'
-	moduleProjects.each { subproject ->
-		def Properties schemas = new Properties();
-
-		subproject.sourceSets.main.resources.find {
-			it.path.endsWith("META-INF/spring.schemas")
-		}?.withInputStream { schemas.load(it) }
-
-		for (def key : schemas.keySet()) {
-			def shortName = key.replaceAll(/http.*schema.(.*).spring-.*/, '$1')
-			assert shortName != key
-			File xsdFile = subproject.sourceSets.main.resources.find {
-				it.path.endsWith(schemas.get(key))
-			}
-			assert xsdFile != null
-			into (shortName) {
-				from xsdFile.path
-			}
-		}
-	}
-}
-
-task distZip(type: Zip, dependsOn: [docsZip, schemaZip]) {
-
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "dist"
-	description = "Builds -${classifier} archive, containing all jars and docs, " +
-			"suitable for community download page."
-
-	ext.baseDir = "${baseName}-${project.version}";
-
-	from("src/docs/dist") {
-		include "readme.txt"
-		include "license.txt"
-		include "notice.txt"
-		into "${baseDir}"
-		expand(copyright: new Date().format("yyyy"), version: project.version)
-	}
-
-	from(zipTree(docsZip.archivePath)) {
-		into "${baseDir}/docs"
-	}
-
-	from(zipTree(schemaZip.archivePath)) {
-		into "${baseDir}/schema"
-	}
-
-	moduleProjects.each { subproject ->
-		into ("${baseDir}/libs") {
-			from subproject.jar
-			if (subproject.tasks.findByPath("sourcesJar")) {
-				from subproject.sourcesJar
-			}
-			if (subproject.tasks.findByPath("javadocJar")) {
-				from subproject.javadocJar
-			}
-		}
-	}
-}
-
-distZip.mustRunAfter subprojects.test
-
-// Create a distribution that contains all dependencies (required and optional).
-// Not published by default; only for use when building from source.
-task depsZip(type: Zip, dependsOn: distZip) { zipTask ->
-	group = "Distribution"
-	baseName = "spring-framework"
-	classifier = "dist-with-deps"
-	description = "Builds -${classifier} archive, containing everything " +
-			"in the -${distZip.classifier} archive plus all runtime dependencies."
-
-	from zipTree(distZip.archivePath)
-
-	gradle.taskGraph.whenReady { taskGraph ->
-		if (taskGraph.hasTask(":${zipTask.name}")) {
-			def projectNames = rootProject.subprojects*.name
-			def artifacts = new HashSet()
-			subprojects.each { subproject ->
-				(subproject.configurations.runtime.resolvedConfiguration.resolvedArtifacts +
-						subproject.configurations.optional.resolvedConfiguration.resolvedArtifacts).each { artifact ->
-					def dependency = artifact.moduleVersion.id
-					if (!projectNames.contains(dependency.name)) {
-						artifacts << artifact.file
-					}
-				}
-			}
-
-			zipTask.from(artifacts) {
-				into "${distZip.baseDir}/deps"
-			}
-		}
-	}
-}

gradle/ide.gradle

@@ -11,9 +11,9 @@ eclipse.jdt {
 }
 
 // Replace classpath entries with project dependencies (GRADLE-1116)
-// http://issues.gradle.org/browse/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 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)
@@ -21,7 +21,7 @@ eclipse.classpath.file.whenMerged { classpath ->
 			def projectName = matcher[0][1]
 			def path = "/${projectName}"
 			if(!classpath.entries.find { e -> e instanceof ProjectDependency && e.path == path }) {
-				def dependency = new ProjectDependency(path)
+				def dependency = new ProjectDependency(path, project(":${projectName}").path)
 				dependency.exported = true
 				classpath.entries.add(dependency)
 			}
@@ -85,8 +85,8 @@ task eclipseJdtPrepare(type: Copy) {
 }
 
 task cleanEclipseJdtUi(type: Delete) {
-	delete project.file(".settings/org.eclipse.jdt.core.prefs")
 	delete project.file(".settings/org.eclipse.jdt.ui.prefs")
+	delete project.file("org.eclipse.jdt.core.prefs")
 	delete project.file(".settings/org.eclipse.wst.common.component")
 	delete project.file(".settings/org.eclipse.wst.common.project.facet.core.xml")
 }

gradle/jdiff.gradle

@@ -43,7 +43,6 @@ task jdiff {
 		ant.mkdir(dir: outputDir)
 		ant.jdiff(
 				destdir: outputDir,
-				source: "1.8",
 				verbose: "off",
 				stats: "on",
 				docchanges: "off") {

gradle/publish-maven.gradle

@@ -25,12 +25,12 @@ def customizePom(pom, gradleProject) {
 			url = "https://github.com/spring-projects/spring-framework"
 			organization {
 				name = "Spring IO"
-				url = "http://projects.spring.io/spring-framework"
+				url = "https://projects.spring.io/spring-framework"
 			}
 			licenses {
 				license {
-					name "Apache License, Version 2.0"
-					url "http://www.apache.org/licenses/LICENSE-2.0"
+					name "The Apache Software License, Version 2.0"
+					url "https://www.apache.org/licenses/LICENSE-2.0.txt"
 					distribution "repo"
 				}
 			}

gradle/sniffer.gradle

@@ -1,67 +0,0 @@
-/*
- * Copyright 2002-2017 the original author or authors.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *       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.
- */
-
-configure(allprojects) { project ->
-
-	ext.snifferVersion = "1.15"
-
-	configurations {
-		sniffer
-		javaApiSignature
-	}
-
-	dependencies {
-		sniffer("org.codehaus.mojo:animal-sniffer-ant-tasks:${snifferVersion}")
-		javaApiSignature("org.codehaus.mojo.signature:java18:1.0@signature")
-	}
-}
-
-task copyJavaApiSignature(type: Copy) {
-	ext.to = file("$buildDir/javaApiSignature/")
-	description "Copy the resolved Animal Sniffer signature dependency artifact to a known location and name"
-	from configurations.javaApiSignature
-	into to
-	rename '.*signature', 'javaApi.signature'
-}
-
-task sniff {
-	group = "Verification"
-	description = "Checks the Java API signatures"
-
-	dependsOn compileJava
-	dependsOn copyJavaApiSignature
-
-	sourceSets.main.output.classesDirs.each { inputs.dir it }
-	inputs.dir copyJavaApiSignature.to
-
-	doLast {
-		ant.taskdef(
-				name: 'animalSniffer',
-				classname: 'org.codehaus.mojo.animal_sniffer.ant.CheckSignatureTask',
-				classpath: configurations.sniffer.asPath
-		)
-
-		// TODO: Animal Sniffer currently chokes on optional JDK 9 bytecode in AspectJ 1.9 beta 5
-		// ant.animalSniffer(
-		// 		signature: "$buildDir/javaApiSignature/javaApi.signature",
-		// 		classpath: sourceSets.main.compileClasspath.asPath) {
-		// 	path(path: sourceSets.main.output.classesDir)
-		// 	annotation(className: "org.springframework.lang.UsesSunHttpServer")
-		// }
-	}
-}
-
-

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
+#Wed Apr 30 13:06:57 CEST 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-1.12-all.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env sh
+#!/usr/bin/env bash
 
 ##############################################################################
 ##
@@ -6,6 +6,48 @@
 ##
 ##############################################################################
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+GRADLE_OPTS="-XX:MaxMetaspaceSize=1024m -Xmx1024m $GRADLE_OPTS"
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -20,50 +62,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
+cd "`dirname \"$PRG\"`/" >&-
 APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-GRADLE_OPTS="-XX:MaxMetaspaceSize=1024m -Xmx1024m $GRADLE_OPTS"
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
+cd "$SAVED" >&-
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +91,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,7 +115,6 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -155,19 +155,11 @@ if $cygwin ; then
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
 }
-APP_ARGS=$(save "$@")
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@@ -8,15 +8,15 @@
 @rem Set local scope for the variables with windows NT shell
 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 DEFAULT_JVM_OPTS=
+
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set GRADLE_OPTS=-XX:MaxMetaspaceSize=1024m -Xmx1024m -XX:MaxHeapSize=256m %GRADLE_OPTS%
-set DEFAULT_JVM_OPTS=
-
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -47,9 +47,10 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windows variants
+@rem Get command-line arguments, handling Windowz variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,6 +61,11 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

import-into-eclipse.bat

@@ -1,4 +1,5 @@
 @echo off
+set STS_TEST_VERSION='2.9.2.RELEASE'
 
 set CURRENT_DIR=%~dp0
 cd %CURRENT_DIR%
@@ -7,22 +8,16 @@ cls
 
 echo.
 echo -----------------------------------------------------------------------
-echo Spring Framework - Eclipse/STS project import guide
+echo Spring Framework Eclipse/STS project import guide
 echo.
-echo This script will guide you through the process of importing the Spring
-echo Framework projects into Eclipse or the Spring Tool Suite (STS). It is
-echo recommended that you have a recent version of Eclipse or STS. As a bare
-echo minimum you will need Eclipse with full Java 8 support, the AspectJ
-echo Development Tools (AJDT), and the Groovy Compiler.
+echo This script will guide you through the process of importing the
+echo Spring Framework sources into Eclipse/STS. It is recommended that you
+echo have a recent version of the SpringSource Tool Suite (this script has
+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 Eclipse or STS, please do that now
-echo by visiting one of the following sites:
-echo.
-echo - Eclipse downloads: http://download.eclipse.org/eclipse/downloads
-echo - STS downloads: http://spring.io/tools/sts/all
-echo - STS nightly builds: http://dist.springsource.com/snapshot/STS/nightly-distributions.html
-echo - ADJT: http://www.eclipse.org/ajdt/downloads/
-echo - Groovy Eclipse: https://github.com/groovy/groovy-eclipse/wiki
+echo If you need to download and install STS, please do that now by
+echo visiting https://spring.io/tools/sts/all 
 echo.
 echo Otherwise, press enter and we'll begin.
 
@@ -34,8 +29,8 @@ REM - generates OXM test classes to avoid errors on import into Eclipse
 REM - generates metadata for all subprojects
 REM - skips metadata gen for the root project (-x :eclipse) to work
 REM   around Eclipse's inability to import hierarchical project structures
-REM SET COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
-SET COMMAND=gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse
+REM SET COMMAND="./gradlew cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
+SET COMMAND=gradlew cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse
 
 echo.
 echo -----------------------------------------------------------------------
@@ -74,7 +69,7 @@ echo When the above is complete, return here and press the enter key.
 
 pause
 
-set COMMAND=gradlew --no-daemon :eclipse
+set COMMAND=gradlew :eclipse
 
 echo.
 echo -----------------------------------------------------------------------

import-into-eclipse.sh

@@ -13,17 +13,23 @@ Development Tools (AJDT), and the Groovy Compiler.
 
 This script has been tested against:
 
-- STS:     3.8.3.RELEASE (Eclipse Neon.2 4.6.2)
-- AJDT:    2.2.4.201612122115 (Eclipse Neon 4.6)
+- 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: http://download.eclipse.org/eclipse/downloads
-- STS downloads: http://spring.io/tools/sts/all
-- STS nightly builds: http://dist.springsource.com/snapshot/STS/nightly-distributions.html
-- ADJT: http://www.eclipse.org/ajdt/downloads/
-- Groovy Eclipse: https://github.com/groovy/groovy-eclipse/wiki
+- 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.
 EOM
@@ -36,7 +42,7 @@ read
 # - generates metadata for all subprojects
 # - skips metadata gen for the root project (-x :eclipse) to work
 #   around Eclipse's inability to import hierarchical project structures
-COMMAND="./gradlew --no-daemon cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
+COMMAND="./gradlew cleanEclipse :spring-oxm:compileTestJava eclipse -x :eclipse"
 
 cat <<EOM
 
@@ -78,7 +84,7 @@ EOM
 
 read
 
-COMMAND="./gradlew --no-daemon :eclipse"
+COMMAND="./gradlew :eclipse"
 
 cat <<EOM
 

import-into-idea.md

@@ -1,28 +1,25 @@
-The following has been tested against IntelliJ IDEA 2016.2.2
+The following has been tested against Intellij IDEA 13.1
 
 ## Steps
 
 _Within your locally cloned spring-framework working directory:_
 
-1. Precompile `spring-oxm` with `./gradlew :spring-oxm:compileTestJava`
-2. Import into IntelliJ (File -> New -> Project from Existing Sources -> Navigate to directory -> Select build.gradle)
-3. When prompted exclude the `spring-aspects` module (or after the import via File-> Project Structure -> Modules)
-4. Code away
+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)
+5. Code away
 
 ## Known issues
 
-1. `spring-core` and `spring-oxm` should be pre-compiled due to repackaged dependencies.
-See `*RepackJar` tasks in the build and https://youtrack.jetbrains.com/issue/IDEA-160605).
-2. `spring-aspects` does not compile due to references to aspect types unknown to
-IntelliJ IDEA. See http://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the
-'spring-aspects' can be excluded from the project to avoid compilation errors.
-3. While JUnit tests pass from the command line with Gradle, some may fail when run from
-IntelliJ IDEA. Resolving this is a work in progress. If attempting to run all JUnit tests from within
-IntelliJ IDEA, you will likely need to set the following VM options to avoid out of memory errors:
+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.
+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.
+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
-4. If you invoke "Rebuild Project" in the IDE, you'll have to generate some test
-resources of the `spring-oxm` module again (`./gradlew :spring-oxm:compileTestJava`)    
-
 
 ## Tips
 
@@ -31,6 +28,6 @@ You'll notice these files are already intentionally in .gitignore. The same poli
 
 ## FAQ
 
-Q. What about IntelliJ IDEA's own [Gradle support](http://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
+Q. What about IDEA's own [Gradle support](http://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
 
 A. Keep an eye on http://youtrack.jetbrains.com/issue/IDEA-53476

settings.gradle

@@ -1,42 +1,30 @@
-/*
-pluginManagement {
-	repositories {
-		maven {
-			url "https://dl.bintray.com/kotlin/kotlin-eap-1.1"
-		}
-		gradlePluginPortal()
-	}
-}
-*/
+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-context-indexer"
 include "spring-core"
 include "spring-expression"
 include "spring-instrument"
-include "spring-jcl"
+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-test"
 include "spring-tx"
 include "spring-web"
 include "spring-webmvc"
-include "spring-webflux"
+include "spring-webmvc-portlet"
+include "spring-webmvc-tiles2"
 include "spring-websocket"
 include "spring-framework-bom"
 
 // Exposes gradle buildSrc for IDE support
 include "buildSrc"
 rootProject.children.find{ it.name == "buildSrc" }.name = "spring-build-src"
-
-rootProject.name = 'spring'
-rootProject.children.each {project ->
-	project.buildFileName = "${project.name}.gradle"
-}

spring-aop/spring-aop.gradle

@@ -1,9 +0,0 @@
-description = "Spring AOP"
-
-dependencies {
-	compile(project(":spring-beans"))
-	compile(project(':spring-core'))
-	optional("org.aspectj:aspectjweaver:${aspectjVersion}")
-	optional("org.apache.commons:commons-pool2:2.4.2")
-	optional("com.jamonapi:jamon:2.81")
-}

spring-aop/src/main/java/org/aopalliance/aop/Advice.java

@@ -1,28 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.aop;
-
-/**
- * Tag interface for Advice. Implementations can be any type
- * of advice, such as Interceptors.
- *
- * @author Rod Johnson
- * @version $Id: Advice.java,v 1.1 2004/03/19 17:02:16 johnsonr Exp $
- */
-public interface Advice {
-
-}

spring-aop/src/main/java/org/aopalliance/aop/AspectException.java

@@ -1,48 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.aop;
-
-/**
- * Superclass for all AOP infrastructure exceptions.
- * Unchecked, as such exceptions are fatal and end user
- * code shouldn't be forced to catch them.
- * 
- * @author Rod Johnson
- * @author Bob Lee
- * @author Juergen Hoeller
- */
-@SuppressWarnings("serial")
-public class AspectException extends RuntimeException {
-
-	/**
-	 * Constructor for AspectException.
-	 * @param message the exception message
-	 */
-	public AspectException(String message) {
-		super(message);
-	}
-
-	/**
-	 * Constructor for AspectException.
-	 * @param message the exception message
-	 * @param cause the root cause, if any
-	 */
-	public AspectException(String message, Throwable cause) {
-		super(message, cause);
-	}
-
-}

spring-aop/src/main/java/org/aopalliance/aop/package-info.java

@@ -1,4 +0,0 @@
-/**
- * The core AOP Alliance advice marker.
- */
-package org.aopalliance.aop;

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInterceptor.java

@@ -1,59 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-/**
- * Intercepts the construction of a new object.
- *
- * <p>The user should implement the {@link
- * #construct(ConstructorInvocation)} method to modify the original
- * behavior. E.g. the following class implements a singleton
- * interceptor (allows only one unique instance for the intercepted
- * class):
- *
- * <pre class=code>
- * class DebuggingInterceptor implements ConstructorInterceptor {
- *   Object instance=null;
- *
- *   Object construct(ConstructorInvocation i) throws Throwable {
- *     if(instance==null) {
- *       return instance=i.proceed();
- *     } else {
- *       throw new Exception("singleton does not allow multiple instance");
- *     }
- *   }
- * }
- * </pre>
- *
- * @author Rod Johnson
- */
-public interface ConstructorInterceptor extends Interceptor  {
-
-	/**
-	 * Implement this method to perform extra treatments before and
-	 * after the construction of a new object. Polite implementations
-	 * would certainly like to invoke {@link Joinpoint#proceed()}.
-	 * @param invocation the construction joinpoint
-	 * @return the newly created object, which is also the result of
-	 * the call to {@link Joinpoint#proceed()}; might be replaced by
-	 * the interceptor
-	 * @throws Throwable if the interceptors or the target object
-	 * throws an exception
-	 */
-	Object construct(ConstructorInvocation invocation) throws Throwable;
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/ConstructorInvocation.java

@@ -1,41 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-import java.lang.reflect.Constructor;
-
-/**
- * Description of an invocation to a constuctor, given to an
- * interceptor upon constructor-call.
- *
- * <p>A constructor invocation is a joinpoint and can be intercepted
- * by a constructor interceptor.
- *
- * @author Rod Johnson
- * @see ConstructorInterceptor
- */
-public interface ConstructorInvocation extends Invocation {
-
-    /**
-     * Get the constructor being called.
-     * <p>This method is a friendly implementation of the
-     * {@link Joinpoint#getStaticPart()} method (same result).
-     * @return the constructor being called
-     */
-    Constructor<?> getConstructor();
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/Interceptor.java

@@ -1,69 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-import org.aopalliance.aop.Advice;
-
-/**
- * This interface represents a generic interceptor.
- *
- * <p>A generic interceptor can intercept runtime events that occur
- * within a base program. Those events are materialized by (reified
- * in) joinpoints. Runtime joinpoints can be invocations, field
- * access, exceptions... 
- *
- * <p>This interface is not used directly. Use the sub-interfaces
- * to intercept specific events. For instance, the following class
- * implements some specific interceptors in order to implement a
- * debugger:
- *
- * <pre class=code>
- * class DebuggingInterceptor implements MethodInterceptor, 
- *     ConstructorInterceptor, FieldInterceptor {
- *
- *   Object invoke(MethodInvocation i) throws Throwable {
- *     debug(i.getMethod(), i.getThis(), i.getArgs());
- *     return i.proceed();
- *   }
- *
- *   Object construct(ConstructorInvocation i) throws Throwable {
- *     debug(i.getConstructor(), i.getThis(), i.getArgs());
- *     return i.proceed();
- *   }
- * 
- *   Object get(FieldAccess fa) throws Throwable {
- *     debug(fa.getField(), fa.getThis(), null);
- *     return fa.proceed();
- *   }
- *
- *   Object set(FieldAccess fa) throws Throwable {
- *     debug(fa.getField(), fa.getThis(), fa.getValueToSet());
- *     return fa.proceed();
- *   }
- *
- *   void debug(AccessibleObject ao, Object this, Object value) {
- *     ...
- *   }
- * }
- * </pre>
- *
- * @author Rod Johnson
- * @see Joinpoint
- */
-public interface Interceptor extends Advice {
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/Invocation.java

@@ -1,37 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-/**
- * This interface represents an invocation in the program.
- *
- * <p>An invocation is a joinpoint and can be intercepted by an
- * interceptor.
- *
- * @author Rod Johnson
- */
-public interface Invocation extends Joinpoint {
-
-	/**
-	 * Get the arguments as an array object.
-	 * It is possible to change element values within this
-	 * array to change the arguments.
-	 * @return the argument of the invocation
-	 */
-	Object[] getArguments();
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/Joinpoint.java

@@ -1,65 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-import java.lang.reflect.AccessibleObject;
-
-/**
- * This interface represents a generic runtime joinpoint (in the AOP
- * terminology).
- *
- * <p>A runtime joinpoint is an <i>event</i> that occurs on a static
- * joinpoint (i.e. a location in a the program). For instance, an
- * invocation is the runtime joinpoint on a method (static joinpoint).
- * The static part of a given joinpoint can be generically retrieved
- * using the {@link #getStaticPart()} method.
- *
- * <p>In the context of an interception framework, a runtime joinpoint
- * is then the reification of an access to an accessible object (a
- * method, a constructor, a field), i.e. the static part of the
- * joinpoint. It is passed to the interceptors that are installed on
- * the static joinpoint.
- *
- * @author Rod Johnson
- * @see Interceptor
- */
-public interface Joinpoint {
-
-	/**
-	 * Proceed to the next interceptor in the chain.
-	 * <p>The implementation and the semantics of this method depends
-	 * on the actual joinpoint type (see the children interfaces).
-	 * @return see the children interfaces' proceed definition
-	 * @throws Throwable if the joinpoint throws an exception
-	 */
-	Object proceed() throws Throwable;
-
-	/**
-	 * Return the object that holds the current joinpoint's static part.
-	 * <p>For instance, the target object for an invocation.
-	 * @return the object (can be null if the accessible object is static)
-	 */
-	Object getThis();
-
-	/**
-	 * Return the static part of this joinpoint.
-	 * <p>The static part is an accessible object on which a chain of
-	 * interceptors are installed.
-	 */
-	AccessibleObject getStaticPart();
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/MethodInterceptor.java

@@ -1,57 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-/**
- * Intercepts calls on an interface on its way to the target. These
- * are nested "on top" of the target.
- *
- * <p>The user should implement the {@link #invoke(MethodInvocation)}
- * method to modify the original behavior. E.g. the following class
- * implements a tracing interceptor (traces all the calls on the
- * intercepted method(s)):
- *
- * <pre class=code>
- * class TracingInterceptor implements MethodInterceptor {
- *   Object invoke(MethodInvocation i) throws Throwable {
- *     System.out.println("method "+i.getMethod()+" is called on "+
- *                        i.getThis()+" with args "+i.getArguments());
- *     Object ret=i.proceed();
- *     System.out.println("method "+i.getMethod()+" returns "+ret);
- *     return ret;
- *   }
- * }
- * </pre>
- *
- * @author Rod Johnson
- */
-@FunctionalInterface
-public interface MethodInterceptor extends Interceptor {
-	
-	/**
-	 * Implement this method to perform extra treatments before and
-	 * after the invocation. Polite implementations would certainly
-	 * like to invoke {@link Joinpoint#proceed()}.
-	 * @param invocation the method invocation joinpoint
-	 * @return the result of the call to {@link Joinpoint#proceed()};
-	 * might be intercepted by the interceptor
-	 * @throws Throwable if the interceptors or the target object
-	 * throws an exception
-	 */
-	Object invoke(MethodInvocation invocation) throws Throwable;
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/MethodInvocation.java

@@ -1,41 +0,0 @@
-/*
- * Copyright 2002-2016 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.aopalliance.intercept;
-
-import java.lang.reflect.Method;
-
-/**
- * Description of an invocation to a method, given to an interceptor
- * upon method-call.
- *
- * <p>A method invocation is a joinpoint and can be intercepted by a
- * method interceptor.
- *
- * @author Rod Johnson
- * @see MethodInterceptor
- */
-public interface MethodInvocation extends Invocation {
-
-	/**
-	 * Get the method being called.
-	 * <p>This method is a frienly implementation of the
-	 * {@link Joinpoint#getStaticPart()} method (same result).
-	 * @return the method being called
-	 */
-	Method getMethod();
-
-}

spring-aop/src/main/java/org/aopalliance/intercept/package-info.java

@@ -1,4 +0,0 @@
-/**
- * The AOP Alliance reflective interception abstraction.
- */
-package org.aopalliance.intercept;

spring-aop/src/main/java/org/aopalliance/package-info.java

@@ -1,4 +0,0 @@
-/**
- * Spring's variant of the AOP Alliance interfaces.
- */
-package org.aopalliance;

spring-aop/src/main/java/org/springframework/aop/Advisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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,18 +31,9 @@ import org.aopalliance.aop.Advice;
  * implemented using interception.
  *
  * @author Rod Johnson
- * @author Juergen Hoeller
  */
 public interface Advisor {
 
-	/**
-	 * Common placeholder for an empty {@code Advice} to be returned from
-	 * {@link #getAdvice()} if no proper advice has been configured (yet).
-	 * @since 5.0
-	 */
-	Advice EMPTY_ADVICE = new Advice() {};
-
-
 	/**
 	 * Return the advice part of this aspect. An advice may be an
 	 * interceptor, a before advice, a throws advice, etc.

spring-aop/src/main/java/org/springframework/aop/AfterReturningAdvice.java

@@ -18,8 +18,6 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
-
 /**
  * After returning advice is invoked only on normal method return, not if an
  * exception is thrown. Such advice can see the return value, but cannot change it.
@@ -41,6 +39,6 @@ public interface AfterReturningAdvice extends AfterAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
 
 }

spring-aop/src/main/java/org/springframework/aop/ClassFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,6 @@ package org.springframework.aop;
  * @see Pointcut
  * @see MethodMatcher
  */
-@FunctionalInterface
 public interface ClassFilter {
 
 	/**

spring-aop/src/main/java/org/springframework/aop/IntroductionAwareMethodMatcher.java

@@ -18,8 +18,6 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
-
 /**
  * A specialized type of {@link MethodMatcher} that takes into account introductions
  * when matching methods. If there are no introductions on the target class,
@@ -41,6 +39,6 @@ public interface IntroductionAwareMethodMatcher extends MethodMatcher {
 	 * asking is the subject on one or more introductions; {@code false} otherwise
 	 * @return whether or not this method matches statically
 	 */
-	boolean matches(Method method, @Nullable Class<?> targetClass, boolean hasIntroductions);
+	boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions);
 
 }

spring-aop/src/main/java/org/springframework/aop/MethodBeforeAdvice.java

@@ -18,8 +18,6 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
-
 /**
  * Advice invoked before a method is invoked. Such advices cannot
  * prevent the method call proceeding, unless they throw a Throwable.
@@ -41,6 +39,6 @@ public interface MethodBeforeAdvice extends BeforeAdvice {
 	 * allowed by the method signature. Otherwise the exception
 	 * will be wrapped as a runtime exception.
 	 */
-	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
+	void before(Method method, Object[] args, Object target) throws Throwable;
 
 }

spring-aop/src/main/java/org/springframework/aop/MethodMatcher.java

@@ -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.
@@ -18,8 +18,6 @@ package org.springframework.aop;
 
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
-
 /**
  * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
  *
@@ -59,7 +57,7 @@ public interface MethodMatcher {
 	 * the candidate class must be taken to be the method's declaring class)
 	 * @return whether or not this method matches statically
 	 */
-	boolean matches(Method method, @Nullable Class<?> targetClass);
+	boolean matches(Method method, Class<?> targetClass);
 
 	/**
 	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
@@ -88,7 +86,7 @@ public interface MethodMatcher {
 	 * @return whether there's a runtime match
 	 * @see MethodMatcher#matches(Method, Class)
 	 */
-	boolean matches(Method method, @Nullable Class<?> targetClass, Object... args);
+	boolean matches(Method method, Class<?> targetClass, Object[] args);
 
 
 	/**

spring-aop/src/main/java/org/springframework/aop/ProxyMethodInvocation.java

@@ -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.
@@ -18,8 +18,6 @@ package org.springframework.aop;
 
 import org.aopalliance.intercept.MethodInvocation;
 
-import org.springframework.lang.Nullable;
-
 /**
  * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
  * interface, allowing access to the proxy that the method invocation was made through.
@@ -59,14 +57,14 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @return an invocable clone of this invocation.
 	 * {@code proceed()} can be called once per clone.
 	 */
-	MethodInvocation invocableClone(Object... arguments);
+	MethodInvocation invocableClone(Object[] arguments);
 
 	/**
 	 * Set the arguments to be used on subsequent invocations in the any advice
 	 * in this chain.
 	 * @param arguments the argument array
 	 */
-	void setArguments(Object... arguments);
+	void setArguments(Object[] arguments);
 
 	/**
 	 * Add the specified user attribute with the given value to this invocation.
@@ -75,7 +73,7 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @param key the name of the attribute
 	 * @param value the value of the attribute, or {@code null} to reset it
 	 */
-	void setUserAttribute(String key, @Nullable Object value);
+	void setUserAttribute(String key, Object value);
 
 	/**
 	 * Return the value of the specified user attribute.
@@ -83,7 +81,6 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * @return the value of the attribute, or {@code null} if not set
 	 * @see #setUserAttribute
 	 */
-	@Nullable
 	Object getUserAttribute(String key);
 
 }

spring-aop/src/main/java/org/springframework/aop/TargetClassAware.java

@@ -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.
@@ -16,13 +16,11 @@
 
 package org.springframework.aop;
 
-import org.springframework.lang.Nullable;
-
 /**
  * Minimal interface for exposing the target class behind a proxy.
  *
  * <p>Implemented by AOP proxy objects and proxy factories
- * (via {@link org.springframework.aop.framework.Advised})
+ * (via {@link org.springframework.aop.framework.Advised}}
  * as well as by {@link TargetSource TargetSources}.
  *
  * @author Juergen Hoeller
@@ -36,7 +34,6 @@ public interface TargetClassAware {
 	 * (typically a proxy configuration or an actual proxy).
 	 * @return the target Class, or {@code null} if not known
 	 */
-	@Nullable
 	Class<?> getTargetClass();
 
 }

spring-aop/src/main/java/org/springframework/aop/TargetSource.java

@@ -1,5 +1,5 @@
 /*<
- * Copyright 2002-2017 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.
@@ -16,8 +16,6 @@
 
 package org.springframework.aop;
 
-import org.springframework.lang.Nullable;
-
 /**
  * A {@code TargetSource} is used to obtain the current "target" of
  * an AOP invocation, which will be invoked via reflection if no around
@@ -31,24 +29,24 @@ import org.springframework.lang.Nullable;
  * {@code TargetSources} directly: this is an AOP framework interface.
  *
  * @author Rod Johnson
- * @author Juergen Hoeller
  */
 public interface TargetSource extends TargetClassAware {
 
 	/**
 	 * Return the type of targets returned by this {@link TargetSource}.
-	 * <p>Can return {@code null}, although certain usages of a {@code TargetSource}
-	 * might just work with a predetermined target class.
+	 * <p>Can return {@code null}, although certain usages of a
+	 * {@code TargetSource} might just work with a predetermined
+	 * target class.
 	 * @return the type of targets returned by this {@link TargetSource}
 	 */
 	@Override
-	@Nullable
 	Class<?> getTargetClass();
 
 	/**
 	 * Will all calls to {@link #getTarget()} return the same object?
-	 * <p>In that case, there will be no need to invoke {@link #releaseTarget(Object)},
-	 * and the AOP framework can cache the return value of {@link #getTarget()}.
+	 * <p>In that case, there will be no need to invoke
+	 * {@link #releaseTarget(Object)}, and the AOP framework can cache
+	 * the return value of {@link #getTarget()}.
 	 * @return {@code true} if the target is immutable
 	 * @see #getTarget
 	 */
@@ -57,16 +55,14 @@ public interface TargetSource extends TargetClassAware {
 	/**
 	 * Return a target instance. Invoked immediately before the
 	 * AOP framework calls the "target" of an AOP method invocation.
-	 * @return the target object which contains the joinpoint,
-	 * or {@code null} if there is no actual target instance
+	 * @return the target object, which contains the joinpoint
 	 * @throws Exception if the target object can't be resolved
 	 */
-	@Nullable
 	Object getTarget() throws Exception;
 
 	/**
 	 * Release the given target object obtained from the
-	 * {@link #getTarget()} method, if any.
+	 * {@link #getTarget()} method.
 	 * @param target object obtained from a call to {@link #getTarget()}
 	 * @throws Exception if the object can't be released
 	 */

spring-aop/src/main/java/org/springframework/aop/TrueMethodMatcher.java

@@ -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.
@@ -19,8 +19,6 @@ package org.springframework.aop;
 import java.io.Serializable;
 import java.lang.reflect.Method;
 
-import org.springframework.lang.Nullable;
-
 /**
  * Canonical MethodMatcher instance that matches all methods.
  *
@@ -31,36 +29,28 @@ class TrueMethodMatcher implements MethodMatcher, Serializable {
 
 	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
 
-
 	/**
 	 * Enforce Singleton pattern.
 	 */
 	private TrueMethodMatcher() {
 	}
 
-
 	@Override
 	public boolean isRuntime() {
 		return false;
 	}
 
 	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass) {
+	public boolean matches(Method method, Class<?> targetClass) {
 		return true;
 	}
 
 	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass, Object... args) {
+	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
 		// Should never be invoked as isRuntime returns false.
 		throw new UnsupportedOperationException();
 	}
 
-
-	@Override
-	public String toString() {
-		return "MethodMatcher.TRUE";
-	}
-
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
@@ -70,4 +60,9 @@ class TrueMethodMatcher implements MethodMatcher, Serializable {
 		return INSTANCE;
 	}
 
+	@Override
+	public String toString() {
+		return "MethodMatcher.TRUE";
+	}
+
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/AbstractAspectJAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -16,9 +16,6 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
@@ -42,7 +39,6 @@ import org.springframework.aop.support.MethodMatchers;
 import org.springframework.aop.support.StaticMethodMatcher;
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -59,8 +55,7 @@ import org.springframework.util.StringUtils;
  * @author Ramnivas Laddad
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {
+public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation {
 
 	/**
 	 * Key used in ReflectiveMethodInvocation userAtributes map for the current joinpoint.
@@ -91,24 +86,21 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}
 
 
-	private final Class<?> declaringClass;
+	protected final Method aspectJAdviceMethod;
 
-	private final String methodName;
-
-	private final Class<?>[] parameterTypes;
-
-	protected transient Method aspectJAdviceMethod;
+	/** The total number of arguments we have to populate on advice dispatch */
+	private final int adviceInvocationArgumentCount;
 
 	private final AspectJExpressionPointcut pointcut;
 
 	private final AspectInstanceFactory aspectInstanceFactory;
 
 	/**
-	 * The name of the aspect (ref bean) in which this advice was defined
-	 * (used when determining advice precedence so that we can determine
+	 * The name of the aspect (ref bean) in which this advice was defined (used
+	 * when determining advice precedence so that we can determine
 	 * whether two pieces of advice come from the same aspect).
 	 */
-	private String aspectName = "";
+	private String aspectName;
 
 	/**
 	 * The order of declaration of this advice within the aspect.
@@ -119,16 +111,13 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * This will be non-null if the creator of this advice object knows the argument names
 	 * and sets them explicitly
 	 */
-	@Nullable
-	private String[] argumentNames;
+	private String[] argumentNames = null;
 
 	/** Non-null if after throwing advice binds the thrown value */
-	@Nullable
-	private String throwingName;
+	private String throwingName = null;
 
 	/** Non-null if after returning advice binds the return value */
-	@Nullable
-	private String returningName;
+	private String returningName = null;
 
 	private Class<?> discoveredReturningType = Object.class;
 
@@ -146,12 +135,10 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 */
 	private int joinPointStaticPartArgumentIndex = -1;
 
-	@Nullable
-	private Map<String, Integer> argumentBindings;
+	private Map<String, Integer> argumentBindings = null;
 
 	private boolean argumentsIntrospected = false;
 
-	@Nullable
 	private Type discoveredReturningGenericType;
 	// Note: Unlike return type, no such generic information is needed for the throwing type,
 	// since Java doesn't allow exception types to be parameterized.
@@ -167,10 +154,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aspectInstanceFactory) {
 
 		Assert.notNull(aspectJAdviceMethod, "Advice method must not be null");
-		this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
-		this.methodName = aspectJAdviceMethod.getName();
-		this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
 		this.aspectJAdviceMethod = aspectJAdviceMethod;
+		this.adviceInvocationArgumentCount = this.aspectJAdviceMethod.getParameterTypes().length;
 		this.pointcut = pointcut;
 		this.aspectInstanceFactory = aspectInstanceFactory;
 	}
@@ -213,7 +198,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Return the ClassLoader for aspect instances.
 	 */
-	@Nullable
 	public final ClassLoader getAspectClassLoader() {
 		return this.aspectInstanceFactory.getAspectClassLoader();
 	}
@@ -266,17 +250,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 						this.argumentNames[i] + "' that is not a valid Java identifier");
 			}
 		}
-		if (this.argumentNames != null) {
-			if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
+		if (argumentNames != null) {
+			if (aspectJAdviceMethod.getParameterTypes().length == argumentNames.length + 1) {
 				// May need to add implicit join point arg name...
-				Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
+				Class<?> firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
 				if (firstArgType == JoinPoint.class ||
 						firstArgType == ProceedingJoinPoint.class ||
 						firstArgType == JoinPoint.StaticPart.class) {
-					String[] oldNames = this.argumentNames;
-					this.argumentNames = new String[oldNames.length + 1];
-					this.argumentNames[0] = "THIS_JOIN_POINT";
-					System.arraycopy(oldNames, 0, this.argumentNames, 1, oldNames.length);
+					String[] oldNames = argumentNames;
+					argumentNames = new String[oldNames.length + 1];
+					argumentNames[0] = "THIS_JOIN_POINT";
+					System.arraycopy(oldNames, 0, argumentNames, 1, oldNames.length);
 				}
 			}
 		}
@@ -302,8 +286,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Returning name '" + name  +
-						"' is neither a valid argument name nor the fully-qualified " +
-						"name of a Java type on the classpath. Root cause: " + ex);
+						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
+						"Root cause: " + ex);
 			}
 		}
 	}
@@ -312,7 +296,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		return this.discoveredReturningType;
 	}
 
-	@Nullable
 	protected Type getDiscoveredReturningGenericType() {
 		return this.discoveredReturningGenericType;
 	}
@@ -337,8 +320,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 			catch (Throwable ex) {
 				throw new IllegalArgumentException("Throwing name '" + name  +
-						"' is neither a valid argument name nor the fully-qualified " +
-						"name of a Java type on the classpath. Root cause: " + ex);
+						"' is neither a valid argument name nor the fully-qualified name of a Java type on the classpath. " +
+						"Root cause: " + ex);
 			}
 		}
 	}
@@ -376,11 +359,11 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 */
 	public synchronized final void calculateArgumentBindings() {
 		// The simple case... nothing to bind.
-		if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
+		if (this.argumentsIntrospected || this.adviceInvocationArgumentCount == 0) {
 			return;
 		}
 
-		int numUnboundArgs = this.parameterTypes.length;
+		int numUnboundArgs = this.adviceInvocationArgumentCount;
 		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
 			numUnboundArgs--;
@@ -398,7 +381,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}
 
 	private boolean maybeBindJoinPoint(Class<?> candidateParameterType) {
-		if (JoinPoint.class == candidateParameterType) {
+		if (candidateParameterType.equals(JoinPoint.class)) {
 			this.joinPointArgumentIndex = 0;
 			return true;
 		}
@@ -408,7 +391,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}
 
 	private boolean maybeBindProceedingJoinPoint(Class<?> candidateParameterType) {
-		if (ProceedingJoinPoint.class == candidateParameterType) {
+		if (candidateParameterType.equals(ProceedingJoinPoint.class)) {
 			if (!supportsProceedingJoinPoint()) {
 				throw new IllegalArgumentException("ProceedingJoinPoint is only supported for around advice");
 			}
@@ -425,7 +408,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}
 
 	private boolean maybeBindJoinPointStaticPart(Class<?> candidateParameterType) {
-		if (JoinPoint.StaticPart.class == candidateParameterType) {
+		if (candidateParameterType.equals(JoinPoint.StaticPart.class)) {
 			this.joinPointStaticPartArgumentIndex = 0;
 			return true;
 		}
@@ -469,18 +452,17 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	}
 
 	private void bindExplicitArguments(int numArgumentsLeftToBind) {
-		Assert.state(this.argumentNames != null, "No argument names available");
-		this.argumentBindings = new HashMap<>();
+		this.argumentBindings = new HashMap<String, Integer>();
 
-		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
+		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterTypes().length;
 		if (this.argumentNames.length != numExpectedArgumentNames) {
-			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
-					" arguments to bind by name in advice, but actually found " +
+			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames
+					+ " arguments to bind by name in advice, but actually found " +
 					this.argumentNames.length + " arguments.");
 		}
 
 		// So we match in number...
-		int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
+		int argumentIndexOffset = this.adviceInvocationArgumentCount - numArgumentsLeftToBind;
 		for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
 			this.argumentBindings.put(this.argumentNames[i], i);
 		}
@@ -489,8 +471,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		// specified, and find the discovered argument types.
 		if (this.returningName != null) {
 			if (!this.argumentBindings.containsKey(this.returningName)) {
-				throw new IllegalStateException("Returning argument name '" + this.returningName +
-						"' was not bound in advice arguments");
+				throw new IllegalStateException("Returning argument name '"
+						+ this.returningName + "' was not bound in advice arguments");
 			}
 			else {
 				Integer index = this.argumentBindings.get(this.returningName);
@@ -500,8 +482,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		if (this.throwingName != null) {
 			if (!this.argumentBindings.containsKey(this.throwingName)) {
-				throw new IllegalStateException("Throwing argument name '" + this.throwingName +
-						"' was not bound in advice arguments");
+				throw new IllegalStateException("Throwing argument name '"
+						+ this.throwingName + "' was not bound in advice arguments");
 			}
 			else {
 				Integer index = this.argumentBindings.get(this.throwingName);
@@ -510,7 +492,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 
 		// configure the pointcut expression accordingly.
-		configurePointcutParameters(this.argumentNames, argumentIndexOffset);
+		configurePointcutParameters(argumentIndexOffset);
 	}
 
 	/**
@@ -518,7 +500,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * pointcut parameters - but returning and throwing vars are handled differently
 	 * and must be removed from the list if present.
 	 */
-	private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
+	private void configurePointcutParameters(int argumentIndexOffset) {
 		int numParametersToRemove = argumentIndexOffset;
 		if (this.returningName != null) {
 			numParametersToRemove++;
@@ -526,20 +508,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.throwingName != null) {
 			numParametersToRemove++;
 		}
-		String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
+		String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
 		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
 		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 
 		int index = 0;
-		for (int i = 0; i < argumentNames.length; i++) {
+		for (int i = 0; i < this.argumentNames.length; i++) {
 			if (i < argumentIndexOffset) {
 				continue;
 			}
-			if (argumentNames[i].equals(this.returningName) ||
-				argumentNames[i].equals(this.throwingName)) {
+			if (this.argumentNames[i].equals(this.returningName) ||
+				this.argumentNames[i].equals(this.throwingName)) {
 				continue;
 			}
-			pointcutParameterNames[index] = argumentNames[i];
+			pointcutParameterNames[index] = this.argumentNames[i];
 			pointcutParameterTypes[index] = methodParameterTypes[i];
 			index++;
 		}
@@ -557,13 +539,11 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * @param ex the exception thrown by the method execution (may be null)
 	 * @return the empty array if there are no arguments
 	 */
-	protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable ex) {
-
+	protected Object[] argBinding(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable ex) {
 		calculateArgumentBindings();
 
 		// AMC start
-		Object[] adviceInvocationArgs = new Object[this.parameterTypes.length];
+		Object[] adviceInvocationArgs = new Object[this.adviceInvocationArgumentCount];
 		int numBound = 0;
 
 		if (this.joinPointArgumentIndex != -1) {
@@ -600,10 +580,11 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			}
 		}
 
-		if (numBound != this.parameterTypes.length) {
-			throw new IllegalStateException("Required to bind " + this.parameterTypes.length +
-					" arguments, but only bound " + numBound + " (JoinPointMatch " +
-					(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
+		if (numBound != this.adviceInvocationArgumentCount) {
+			throw new IllegalStateException("Required to bind " + this.adviceInvocationArgumentCount
+					+ " arguments, but only bound " + numBound + " (JoinPointMatch " +
+					(jpMatch == null ? "was NOT" : "WAS") +
+					" bound in invocation)");
 		}
 
 		return adviceInvocationArgs;
@@ -618,23 +599,20 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * @return the invocation result
 	 * @throws Throwable in case of invocation failure
 	 */
-	protected Object invokeAdviceMethod(
-			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
-			throws Throwable {
-
+	protected Object invokeAdviceMethod(JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable {
 		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
 	}
 
 	// As above, but in this case we are given the join point.
-	protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
-			@Nullable Object returnValue, @Nullable Throwable t) throws Throwable {
+	protected Object invokeAdviceMethod(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable t)
+			throws Throwable {
 
 		return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
 	}
 
 	protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
 		Object[] actualArgs = args;
-		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
+		if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
 			actualArgs = null;
 		}
 		try {
@@ -662,7 +640,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/**
 	 * Get the current join point match at the join point we are being dispatched on.
 	 */
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch() {
 		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
 		if (!(mi instanceof ProxyMethodInvocation)) {
@@ -677,10 +654,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	// 'last man wins' which is not what we want at all.
 	// Using the expression is guaranteed to be safe, since 2 identical expressions
 	// are guaranteed to bind in exactly the same way.
-	@Nullable
 	protected JoinPointMatch getJoinPointMatch(ProxyMethodInvocation pmi) {
-		String expression = this.pointcut.getExpression();
-		return (expression != null ? (JoinPointMatch) pmi.getUserAttribute(expression) : null);
+		return (JoinPointMatch) pmi.getUserAttribute(this.pointcut.getExpression());
 	}
 
 
@@ -690,16 +665,6 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 				"aspect name '" + this.aspectName + "'";
 	}
 
-	private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
-		inputStream.defaultReadObject();
-		try {
-			this.aspectJAdviceMethod = this.declaringClass.getMethod(this.methodName, this.parameterTypes);
-		}
-		catch (NoSuchMethodException ex) {
-			throw new IllegalStateException("Failed to find advice method on deserialization", ex);
-		}
-	}
-
 
 	/**
 	 * MethodMatcher that excludes the specified advice method.
@@ -714,7 +679,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 
 		@Override
-		public boolean matches(Method method, @Nullable Class<?> targetClass) {
+		public boolean matches(Method method, Class<?> targetClass) {
 			return !this.adviceMethod.equals(method);
 		}
 

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -17,7 +17,6 @@
 package org.springframework.aop.aspectj;
 
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 
 /**
  * Interface implemented to provide an instance of an AspectJ aspect.
@@ -41,10 +40,8 @@ public interface AspectInstanceFactory extends Ordered {
 
 	/**
 	 * Expose the aspect class loader that this factory uses.
-	 * @return the aspect class loader (or {@code null} for the bootstrap loader)
-	 * @see org.springframework.util.ClassUtils#getDefaultClassLoader()
+	 * @return the aspect class loader (never {@code null})
 	 */
-	@Nullable
 	ClassLoader getAspectClassLoader();
 
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAdviceParameterNameDiscoverer.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -30,7 +30,6 @@ import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;
 
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 /**
@@ -114,7 +113,6 @@ import org.springframework.util.StringUtils;
  * returning {@code null} in the case that the parameter names cannot be discovered.
  *
  * @author Adrian Colyer
- * @author Juergen Hoeller
  * @since 2.0
  */
 public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscoverer {
@@ -132,8 +130,8 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	private static final int STEP_REFERENCE_PCUT_BINDING = 7;
 	private static final int STEP_FINISHED = 8;
 
-	private static final Set<String> singleValuedAnnotationPcds = new HashSet<>();
-	private static final Set<String> nonReferencePointcutTokens = new HashSet<>();
+	private static final Set<String> singleValuedAnnotationPcds = new HashSet<String>();
+	private static final Set<String> nonReferencePointcutTokens = new HashSet<String>();
 
 
 	static {
@@ -156,23 +154,26 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}
 
 
-	/** The pointcut expression associated with the advice, as a simple String */
-	@Nullable
-	private String pointcutExpression;
-
 	private boolean raiseExceptions;
 
-	/** If the advice is afterReturning, and binds the return value, this is the parameter name used */
-	@Nullable
+	/**
+	 * If the advice is afterReturning, and binds the return value, this is the parameter name used.
+	 */
 	private String returningName;
 
-	/** If the advice is afterThrowing, and binds the thrown value, this is the parameter name used */
-	@Nullable
+	/**
+	 * If the advice is afterThrowing, and binds the thrown value, this is the parameter name used.
+	 */
 	private String throwingName;
 
-	private Class<?>[] argumentTypes = new Class<?>[0];
+	/**
+	 * The pointcut expression associated with the advice, as a simple String.
+	 */
+	private String pointcutExpression;
 
-	private String[] parameterNameBindings = new String[0];
+	private Class<?>[] argumentTypes;
+
+	private String[] parameterNameBindings;
 
 	private int numberOfRemainingUnboundArguments;
 
@@ -181,11 +182,10 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Create a new discoverer that attempts to discover parameter names
 	 * from the given pointcut expression.
 	 */
-	public AspectJAdviceParameterNameDiscoverer(@Nullable String pointcutExpression) {
+	public AspectJAdviceParameterNameDiscoverer(String pointcutExpression) {
 		this.pointcutExpression = pointcutExpression;
 	}
 
-
 	/**
 	 * Indicate whether {@link IllegalArgumentException} and {@link AmbiguousBindingException}
 	 * must be thrown as appropriate in the case of failing to deduce advice parameter names.
@@ -200,7 +200,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * returning variable name must be specified.
 	 * @param returningName the name of the returning variable
 	 */
-	public void setReturningName(@Nullable String returningName) {
+	public void setReturningName(String returningName) {
 		this.returningName = returningName;
 	}
 
@@ -209,11 +209,10 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * throwing variable name must be specified.
 	 * @param throwingName the name of the throwing variable
 	 */
-	public void setThrowingName(@Nullable String throwingName) {
+	public void setThrowingName(String throwingName) {
 		this.throwingName = throwingName;
 	}
 
-
 	/**
 	 * Deduce the parameter names for an advice method.
 	 * <p>See the {@link AspectJAdviceParameterNameDiscoverer class level javadoc}
@@ -222,7 +221,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * @return the parameter names
 	 */
 	@Override
-	@Nullable
 	public String[] getParameterNames(Method method) {
 		this.argumentTypes = method.getParameterTypes();
 		this.numberOfRemainingUnboundArguments = this.argumentTypes.length;
@@ -311,7 +309,6 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
 	 */
 	@Override
-	@Nullable
 	public String[] getParameterNames(Constructor<?> ctor) {
 		if (this.raiseExceptions) {
 			throw new UnsupportedOperationException("An advice method can never be a constructor");
@@ -417,7 +414,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * <p>Some more support from AspectJ in doing this exercise would be nice... :)
 	 */
 	private void maybeBindAnnotationsFromPointcutExpression() {
-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
@@ -476,9 +473,8 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	/*
 	 * If the token starts meets Java identifier conventions, it's in.
 	 */
-	@Nullable
-	private String maybeExtractVariableName(@Nullable String candidateToken) {
-		if (!StringUtils.hasLength(candidateToken)) {
+	private String maybeExtractVariableName(String candidateToken) {
+		if (candidateToken == null || candidateToken.equals("")) {
 			return null;
 		}
 		if (Character.isJavaIdentifierStart(candidateToken.charAt(0)) &&
@@ -500,7 +496,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Given an args pointcut body (could be {@code args} or {@code at_args}),
 	 * add any candidate variable names to the given list.
 	 */
-	private void maybeExtractVariableNamesFromArgs(@Nullable String argsSpec, List<String> varNames) {
+	private void maybeExtractVariableNamesFromArgs(String argsSpec, List<String> varNames) {
 		if (argsSpec == null) {
 			return;
 		}
@@ -524,7 +520,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at this(),target(),args() binding stage, with no way to determine between them");
 		}
 
-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			if (tokens[i].equals("this") ||
@@ -541,7 +537,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 			else if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
 				PointcutBody body = getPointcutBody(tokens, i);
 				i += body.numTokensConsumed;
-				List<String> candidateVarNames = new ArrayList<>();
+				List<String> candidateVarNames = new ArrayList<String>();
 				maybeExtractVariableNamesFromArgs(body.text, candidateVarNames);
 				// we may have found some var names that were bound in previous primitive args binding step,
 				// filter them out...
@@ -575,7 +571,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 					+ " unbound args at reference pointcut binding stage, with no way to determine between them");
 		}
 
-		List<String> varNames = new ArrayList<>();
+		List<String> varNames = new ArrayList<String>();
 		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 		for (int i = 0; i < tokens.length; i++) {
 			String toMatch = tokens[i];
@@ -687,7 +683,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 		}
 		if (numUnboundPrimitives == 1) {
 			// Look for arg variable and bind it if we find exactly one...
-			List<String> varNames = new ArrayList<>();
+			List<String> varNames = new ArrayList<String>();
 			String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
 			for (int i = 0; i < tokens.length; i++) {
 				if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
@@ -781,10 +777,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 
 		private int numTokensConsumed;
 
-		@Nullable
 		private String text;
 
-		public PointcutBody(int tokens, @Nullable String text) {
+		public PointcutBody(int tokens, String text) {
 			this.numTokensConsumed = tokens;
 			this.text = text;
 		}

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterAdvice.java

@@ -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.
@@ -16,7 +16,6 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 
 import org.aopalliance.intercept.MethodInterceptor;
@@ -30,9 +29,7 @@ import org.springframework.aop.AfterAdvice;
  * @author Rod Johnson
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class AspectJAfterAdvice extends AbstractAspectJAdvice
-		implements MethodInterceptor, AfterAdvice, Serializable {
+public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
 
 	public AspectJAfterAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -40,7 +37,6 @@ public class AspectJAfterAdvice extends AbstractAspectJAdvice
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
 
-
 	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterReturningAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -16,13 +16,11 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 
 import org.springframework.aop.AfterAdvice;
 import org.springframework.aop.AfterReturningAdvice;
-import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.TypeUtils;
 
@@ -34,9 +32,7 @@ import org.springframework.util.TypeUtils;
  * @author Ramnivas Laddad
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
-		implements AfterReturningAdvice, AfterAdvice, Serializable {
+public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice implements AfterReturningAdvice, AfterAdvice {
 
 	public AspectJAfterReturningAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -44,7 +40,6 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
 
-
 	@Override
 	public boolean isBeforeAdvice() {
 		return false;
@@ -61,13 +56,12 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	}
 
 	@Override
-	public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {
+	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
 		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
 			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
 		}
 	}
 
-
 	/**
 	 * Following AspectJ semantics, if a returning clause was specified, then the
 	 * advice is only invoked if the returned value is an instance of the given
@@ -76,7 +70,7 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	 * @param returnValue the return value of the target method
 	 * @return whether to invoke the advice method for the given return value
 	 */
-	private boolean shouldInvokeOnReturnValueOf(Method method, @Nullable Object returnValue) {
+	private boolean shouldInvokeOnReturnValueOf(Method method, Object returnValue) {
 		Class<?> type = getDiscoveredReturningType();
 		Type genericType = getDiscoveredReturningGenericType();
 		// If we aren't dealing with a raw type, check if generic parameters are assignable.
@@ -95,14 +89,14 @@ public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
 	 * @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, @Nullable Object returnValue) {
+	private boolean matchesReturnValue(Class<?> type, Method method, Object returnValue) {
 		if (returnValue != null) {
 			return ClassUtils.isAssignableValue(type, returnValue);
 		}
-		else if (Object.class == type && void.class == method.getReturnType()) {
+		else if (type.equals(Object.class) && method.getReturnType().equals(void.class)) {
 			return true;
 		}
-		else {
+		else{
 			return ClassUtils.isAssignable(type, method.getReturnType());
 		}
 	}

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAfterThrowingAdvice.java

@@ -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.
@@ -16,7 +16,6 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 
 import org.aopalliance.intercept.MethodInterceptor;
@@ -30,9 +29,7 @@ import org.springframework.aop.AfterAdvice;
  * @author Rod Johnson
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
-		implements MethodInterceptor, AfterAdvice, Serializable {
+public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
 
 	public AspectJAfterThrowingAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -40,7 +37,6 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
 
-
 	@Override
 	public boolean isBeforeAdvice() {
 		return false;
@@ -61,11 +57,11 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 		try {
 			return mi.proceed();
 		}
-		catch (Throwable ex) {
-			if (shouldInvokeOnThrowing(ex)) {
-				invokeAdviceMethod(getJoinPointMatch(), null, ex);
+		catch (Throwable t) {
+			if (shouldInvokeOnThrowing(t)) {
+				invokeAdviceMethod(getJoinPointMatch(), null, t);
 			}
-			throw ex;
+			throw t;
 		}
 	}
 
@@ -73,8 +69,8 @@ public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
 	 * In AspectJ semantics, after throwing advice that specifies a throwing clause
 	 * is only invoked if the thrown exception is a subtype of the given throwing type.
 	 */
-	private boolean shouldInvokeOnThrowing(Throwable ex) {
-		return getDiscoveredThrowingType().isAssignableFrom(ex.getClass());
+	private boolean shouldInvokeOnThrowing(Throwable t) {
+		return getDiscoveredThrowingType().isAssignableFrom(t.getClass());
 	}
 
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAopUtils.java

@@ -21,7 +21,6 @@ import org.aopalliance.aop.Advice;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.AfterAdvice;
 import org.springframework.aop.BeforeAdvice;
-import org.springframework.lang.Nullable;
 
 /**
  * Utility methods for dealing with AspectJ advisors.
@@ -59,7 +58,6 @@ public abstract class AspectJAopUtils {
 	 * If neither the advisor nor the advice have precedence information, this method
 	 * will return {@code null}.
 	 */
-	@Nullable
 	public static AspectJPrecedenceInformation getAspectJPrecedenceInformationFor(Advisor anAdvisor) {
 		if (anAdvisor instanceof AspectJPrecedenceInformation) {
 			return (AspectJPrecedenceInformation) anAdvisor;

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJAroundAdvice.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -16,7 +16,6 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 
 import org.aopalliance.intercept.MethodInterceptor;
@@ -34,8 +33,7 @@ import org.springframework.aop.ProxyMethodInvocation;
  * @author Juergen Hoeller
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor, Serializable {
+public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor {
 
 	public AspectJAroundAdvice(
 			Method aspectJAroundAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -43,7 +41,6 @@ public class AspectJAroundAdvice extends AbstractAspectJAdvice implements Method
 		super(aspectJAroundAdviceMethod, pointcut, aif);
 	}
 
-
 	@Override
 	public boolean isBeforeAdvice() {
 		return false;
@@ -59,6 +56,7 @@ public class AspectJAroundAdvice extends AbstractAspectJAdvice implements Method
 		return true;
 	}
 
+
 	@Override
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		if (!(mi instanceof ProxyMethodInvocation)) {

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcut.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -28,6 +28,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import org.aopalliance.intercept.MethodInvocation;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.patterns.NamePattern;
 import org.aspectj.weaver.reflect.ReflectionWorld.ReflectionWorldException;
 import org.aspectj.weaver.reflect.ShadowMatchImpl;
@@ -54,10 +55,7 @@ import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.FactoryBean;
-import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
@@ -84,7 +82,7 @@ import org.springframework.util.StringUtils;
 public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
 
-	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
+	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
 
 	static {
 		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
@@ -102,23 +100,19 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
 
-	@Nullable
 	private Class<?> pointcutDeclarationScope;
 
 	private String[] pointcutParameterNames = new String[0];
 
 	private Class<?>[] pointcutParameterTypes = new Class<?>[0];
 
-	@Nullable
 	private BeanFactory beanFactory;
 
-	@Nullable
 	private transient ClassLoader pointcutClassLoader;
 
-	@Nullable
 	private transient PointcutExpression pointcutExpression;
 
-	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<>(32);
+	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
 
 
 	/**
@@ -173,13 +167,13 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	@Override
 	public ClassFilter getClassFilter() {
-		obtainPointcutExpression();
+		checkReadyToMatch();
 		return this;
 	}
 
 	@Override
 	public MethodMatcher getMethodMatcher() {
-		obtainPointcutExpression();
+		checkReadyToMatch();
 		return this;
 	}
 
@@ -188,59 +182,40 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * Check whether this pointcut is ready to match,
 	 * lazily building the underlying AspectJ pointcut expression.
 	 */
-	private PointcutExpression obtainPointcutExpression() {
+	private void checkReadyToMatch() {
 		if (getExpression() == null) {
 			throw new IllegalStateException("Must set property 'expression' before attempting to match");
 		}
 		if (this.pointcutExpression == null) {
-			this.pointcutClassLoader = determinePointcutClassLoader();
+			this.pointcutClassLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
+					((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
+					ClassUtils.getDefaultClassLoader());
 			this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
 		}
-		return this.pointcutExpression;
-	}
-
-	/**
-	 * Determine the ClassLoader to use for pointcut evaluation.
-	 */
-	@Nullable
-	private ClassLoader determinePointcutClassLoader() {
-		if (this.beanFactory instanceof ConfigurableBeanFactory) {
-			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
-		}
-		if (this.pointcutDeclarationScope != null) {
-			return this.pointcutDeclarationScope.getClassLoader();
-		}
-		return ClassUtils.getDefaultClassLoader();
 	}
 
 	/**
 	 * Build the underlying AspectJ pointcut expression.
 	 */
-	private PointcutExpression buildPointcutExpression(@Nullable ClassLoader classLoader) {
+	private PointcutExpression buildPointcutExpression(ClassLoader classLoader) {
 		PointcutParser parser = initializePointcutParser(classLoader);
 		PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];
 		for (int i = 0; i < pointcutParameters.length; i++) {
 			pointcutParameters[i] = parser.createPointcutParameter(
 					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
 		}
-		return parser.parsePointcutExpression(replaceBooleanOperators(resolveExpression()),
+		return parser.parsePointcutExpression(replaceBooleanOperators(getExpression()),
 				this.pointcutDeclarationScope, pointcutParameters);
 	}
 
-	private String resolveExpression() {
-		String expression = getExpression();
-		Assert.state(expression != null, "No expression set");
-		return expression;
-	}
-
 	/**
 	 * Initialize the underlying AspectJ pointcut parser.
 	 */
-	private PointcutParser initializePointcutParser(@Nullable ClassLoader classLoader) {
+	private PointcutParser initializePointcutParser(ClassLoader cl) {
 		PointcutParser parser = PointcutParser
 				.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
-						SUPPORTED_PRIMITIVES, classLoader);
-		parser.registerPointcutDesignatorHandler(new BeanPointcutDesignatorHandler());
+						SUPPORTED_PRIMITIVES, cl);
+		parser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
 		return parser;
 	}
 
@@ -263,15 +238,16 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * Return the underlying AspectJ pointcut expression.
 	 */
 	public PointcutExpression getPointcutExpression() {
-		return obtainPointcutExpression();
+		checkReadyToMatch();
+		return this.pointcutExpression;
 	}
 
 	@Override
 	public boolean matches(Class<?> targetClass) {
-		PointcutExpression pointcutExpression = obtainPointcutExpression();
+		checkReadyToMatch();
 		try {
 			try {
-				return pointcutExpression.couldMatchJoinPointsInType(targetClass);
+				return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
 			}
 			catch (ReflectionWorldException ex) {
 				logger.debug("PointcutExpression matching rejected target class - trying fallback expression", ex);
@@ -282,15 +258,15 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 				}
 			}
 		}
-		catch (Throwable ex) {
+		catch (BCException ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
 		}
 		return false;
 	}
 
 	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass, boolean beanHasIntroductions) {
-		obtainPointcutExpression();
+	public boolean matches(Method method, Class<?> targetClass, boolean beanHasIntroductions) {
+		checkReadyToMatch();
 		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
 		ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);
 
@@ -313,24 +289,24 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			// we say this is not a match as in Spring there will never be a different
 			// runtime subtype.
 			RuntimeTestWalker walker = getRuntimeTestWalker(shadowMatch);
-			return (!walker.testsSubtypeSensitiveVars() ||
-					(targetClass != null && walker.testTargetInstanceOfResidue(targetClass)));
+			return (!walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass));
 		}
 	}
 
 	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass) {
+	public boolean matches(Method method, Class<?> targetClass) {
 		return matches(method, targetClass, false);
 	}
 
 	@Override
 	public boolean isRuntime() {
-		return obtainPointcutExpression().mayNeedDynamicTest();
+		checkReadyToMatch();
+		return this.pointcutExpression.mayNeedDynamicTest();
 	}
 
 	@Override
-	public boolean matches(Method method, @Nullable Class<?> targetClass, Object... args) {
-		obtainPointcutExpression();
+	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
+		checkReadyToMatch();
 		ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
 		ShadowMatch originalShadowMatch = getShadowMatch(method, method);
 
@@ -350,6 +326,7 @@ 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);
 			}
@@ -366,7 +343,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			 * type but not 'this' (as would be the case of JDK dynamic proxies).
 			 * <p>See SPR-2979 for the original bug.
 			 */
-			if (pmi != null && thisObject != null) {  // there is a current invocation
+			if (pmi != null) {  // there is a current invocation
 				RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(originalShadowMatch);
 				if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
 					return false;
@@ -387,7 +364,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		}
 	}
 
-	@Nullable
 	protected String getCurrentProxiedBeanName() {
 		return ProxyCreationContext.getCurrentProxiedBeanName();
 	}
@@ -396,7 +372,6 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	/**
 	 * Get a new pointcut expression based on a target class's loader rather than the default.
 	 */
-	@Nullable
 	private PointcutExpression getFallbackPointcutExpression(Class<?> targetClass) {
 		try {
 			ClassLoader classLoader = targetClass.getClassLoader();
@@ -424,7 +399,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		// 'last man wins' which is not what we want at all.
 		// Using the expression is guaranteed to be safe, since 2 identical expressions
 		// are guaranteed to bind in exactly the same way.
-		invocation.setUserAttribute(resolveExpression(), jpm);
+		invocation.setUserAttribute(getExpression(), jpm);
 	}
 
 	private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
@@ -438,46 +413,39 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 				shadowMatch = this.shadowMatchCache.get(targetMethod);
 				if (shadowMatch == null) {
 					try {
+						shadowMatch = this.pointcutExpression.matchesMethodExecution(methodToMatch);
+					}
+					catch (ReflectionWorldException ex) {
+						// Failed to introspect target method, probably because it has been loaded
+						// in a special ClassLoader. Let's try the declaring ClassLoader instead...
 						try {
-							shadowMatch = obtainPointcutExpression().matchesMethodExecution(methodToMatch);
+							fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+							if (fallbackExpression != null) {
+								shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
+							}
 						}
-						catch (ReflectionWorldException ex) {
-							// Failed to introspect target method, probably because it has been loaded
-							// in a special ClassLoader. Let's try the declaring ClassLoader instead...
+						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);
 								}
 							}
-							catch (ReflectionWorldException ex2) {
+							catch (ReflectionWorldException ex4) {
 								fallbackExpression = null;
 							}
 						}
-						if (shadowMatch == null && targetMethod != originalMethod) {
-							methodToMatch = originalMethod;
-							try {
-								shadowMatch = obtainPointcutExpression().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);
-									}
-								}
-								catch (ReflectionWorldException ex4) {
-									fallbackExpression = null;
-								}
-							}
-						}
-					}
-					catch (Throwable ex) {
-						// Possibly AspectJ 1.8.10 encountering an invalid signature
-						logger.debug("PointcutExpression matching rejected target method", ex);
-						fallbackExpression = null;
 					}
 					if (shadowMatch == null) {
 						shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
@@ -522,16 +490,18 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	public String toString() {
 		StringBuilder sb = new StringBuilder();
 		sb.append("AspectJExpressionPointcut: ");
-		sb.append("(");
-		for (int i = 0; i < this.pointcutParameterTypes.length; i++) {
-			sb.append(this.pointcutParameterTypes[i].getName());
-			sb.append(" ");
-			sb.append(this.pointcutParameterNames[i]);
-			if ((i+1) < this.pointcutParameterTypes.length) {
-				sb.append(", ");
+		if (this.pointcutParameterNames != null && this.pointcutParameterTypes != null) {
+			sb.append("(");
+			for (int i = 0; i < this.pointcutParameterTypes.length; i++) {
+				sb.append(this.pointcutParameterTypes[i].getName());
+				sb.append(" ");
+				sb.append(this.pointcutParameterNames[i]);
+				if ((i+1) < this.pointcutParameterTypes.length) {
+					sb.append(", ");
+				}
 			}
+			sb.append(")");
 		}
-		sb.append(")");
 		sb.append(" ");
 		if (getExpression() != null) {
 			sb.append(getExpression());
@@ -551,7 +521,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * automatically by examining a thread local variable and therefore a matching
 	 * context need not be set on the pointcut.
 	 */
-	private class BeanPointcutDesignatorHandler implements PointcutDesignatorHandler {
+	private class BeanNamePointcutDesignatorHandler implements PointcutDesignatorHandler {
 
 		private static final String BEAN_DESIGNATOR_NAME = "bean";
 
@@ -562,7 +532,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 		@Override
 		public ContextBasedMatcher parse(String expression) {
-			return new BeanContextMatcher(expression);
+			return new BeanNameContextMatcher(expression);
 		}
 	}
 
@@ -574,11 +544,11 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * For static match tests, this matcher abstains to allow the overall
 	 * pointcut to match even when negation is used with the bean() pointcut.
 	 */
-	private class BeanContextMatcher implements ContextBasedMatcher {
+	private class BeanNameContextMatcher implements ContextBasedMatcher {
 
 		private final NamePattern expressionPattern;
 
-		public BeanContextMatcher(String expression) {
+		public BeanNameContextMatcher(String expression) {
 			this.expressionPattern = new NamePattern(expression);
 		}
 
@@ -611,7 +581,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			return false;
 		}
 
-		private FuzzyBoolean contextMatch(@Nullable 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
@@ -623,17 +593,27 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			if (targetType != null) {
 				boolean isFactory = FactoryBean.class.isAssignableFrom(targetType);
 				return FuzzyBoolean.fromBoolean(
-						matchesBean(isFactory ? BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName : advisedBeanName));
+						matchesBeanName(isFactory ? BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName : advisedBeanName));
 			}
 			else {
-				return FuzzyBoolean.fromBoolean(matchesBean(advisedBeanName) ||
-						matchesBean(BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName));
+				return FuzzyBoolean.fromBoolean(matchesBeanName(advisedBeanName) ||
+						matchesBeanName(BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName));
 			}
 		}
 
-		private boolean matchesBean(String advisedBeanName) {
-			return BeanFactoryAnnotationUtils.isQualifierMatch(
-					this.expressionPattern::matches, advisedBeanName, beanFactory);
+		private boolean matchesBeanName(String advisedBeanName) {
+			if (this.expressionPattern.matches(advisedBeanName)) {
+				return true;
+			}
+			if (beanFactory != null) {
+				String[] aliases = beanFactory.getAliases(advisedBeanName);
+				for (String alias : aliases) {
+					if (this.expressionPattern.matches(alias)) {
+						return true;
+					}
+				}
+			}
+			return false;
 		}
 	}
 
@@ -648,7 +628,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 		// Initialize transient fields.
 		// pointcutExpression will be initialized lazily by checkReadyToMatch()
-		this.shadowMatchCache = new ConcurrentHashMap<>(32);
+		this.shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
 	}
 
 

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJExpressionPointcutAdvisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -18,9 +18,6 @@ package org.springframework.aop.aspectj;
 
 import org.springframework.aop.Pointcut;
 import org.springframework.aop.support.AbstractGenericPointcutAdvisor;
-import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.BeanFactoryAware;
-import org.springframework.lang.Nullable;
 
 /**
  * Spring AOP Advisor that can be used for any AspectJ pointcut expression.
@@ -29,45 +26,38 @@ import org.springframework.lang.Nullable;
  * @since 2.0
  */
 @SuppressWarnings("serial")
-public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor implements BeanFactoryAware {
+public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor {
 
 	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
 
 
-	public void setExpression(@Nullable String expression) {
-		this.pointcut.setExpression(expression);
-	}
-
-	@Nullable
-	public String getExpression() {
-		return this.pointcut.getExpression();
-	}
-
-	public void setLocation(@Nullable String location) {
-		this.pointcut.setLocation(location);
-	}
-
-	@Nullable
-	public String getLocation() {
-		return this.pointcut.getLocation();
-	}
-
-	public void setParameterNames(String... names) {
-		this.pointcut.setParameterNames(names);
-	}
-
-	public void setParameterTypes(Class<?>... types) {
-		this.pointcut.setParameterTypes(types);
-	}
-
-	@Override
-	public void setBeanFactory(BeanFactory beanFactory) {
-		this.pointcut.setBeanFactory(beanFactory);
-	}
-
 	@Override
 	public Pointcut getPointcut() {
 		return this.pointcut;
 	}
 
+	public void setExpression(String expression) {
+		this.pointcut.setExpression(expression);
+	}
+
+	public String getExpression() {
+		return this.pointcut.getExpression();
+	}
+
+	public void setLocation(String location) {
+		this.pointcut.setLocation(location);
+	}
+
+	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);
+	}
+
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJMethodBeforeAdvice.java

@@ -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.
@@ -16,11 +16,9 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
 import java.lang.reflect.Method;
 
 import org.springframework.aop.MethodBeforeAdvice;
-import org.springframework.lang.Nullable;
 
 /**
  * Spring AOP advice that wraps an AspectJ before method.
@@ -29,8 +27,7 @@ import org.springframework.lang.Nullable;
  * @author Adrian Colyer
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {
+public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice {
 
 	public AspectJMethodBeforeAdvice(
 			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
@@ -38,9 +35,8 @@ public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
 
-
 	@Override
-	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
+	public void before(Method method, Object[] args, Object target) throws Throwable {
 		invokeAdviceMethod(getJoinPointMatch(), null, null);
 	}
 

spring-aop/src/main/java/org/springframework/aop/aspectj/AspectJPointcutAdvisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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,8 +21,8 @@ import org.aopalliance.aop.Advice;
 import org.springframework.aop.Pointcut;
 import org.springframework.aop.PointcutAdvisor;
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 /**
  * AspectJPointcutAdvisor that adapts an {@link AbstractAspectJAdvice}
@@ -38,7 +38,6 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 
 	private final Pointcut pointcut;
 
-	@Nullable
 	private Integer order;
 
 
@@ -52,11 +51,11 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 		this.pointcut = advice.buildSafePointcut();
 	}
 
-
 	public void setOrder(int order) {
 		this.order = order;
 	}
 
+
 	@Override
 	public boolean isPerInstance() {
 		return true;
@@ -92,12 +91,12 @@ public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
 			return false;
 		}
 		AspectJPointcutAdvisor otherAdvisor = (AspectJPointcutAdvisor) other;
-		return this.advice.equals(otherAdvisor.advice);
+		return (ObjectUtils.nullSafeEquals(this.advice, otherAdvisor.advice));
 	}
 
 	@Override
 	public int hashCode() {
-		return AspectJPointcutAdvisor.class.hashCode() * 29 + this.advice.hashCode();
+		return AspectJPointcutAdvisor.class.hashCode();
 	}
 
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/DeclareParentsAdvisor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -65,7 +65,7 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 
 	/**
 	 * Private constructor to share common code between impl-based delegate and reference-based delegate
-	 * (cannot use method such as init() to share common code, due the use of final fields)
+	 * (cannot use method such as init() to share common code, due the the use of final fields)
 	 * @param interfaceType static field defining the introduction
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param implementationClass implementation class
@@ -76,7 +76,12 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 		ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);
 
 		// Excludes methods implemented.
-		ClassFilter exclusion = clazz -> !(introducedInterface.isAssignableFrom(clazz));
+		ClassFilter exclusion = new ClassFilter() {
+			@Override
+			public boolean matches(Class<?> clazz) {
+				return !(introducedInterface.isAssignableFrom(clazz));
+			}
+		};
 
 		this.typePatternClassFilter = ClassFilters.intersection(typePatternFilter, exclusion);
 		this.advice = advice;

spring-aop/src/main/java/org/springframework/aop/aspectj/MethodInvocationProceedingJoinPoint.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -29,7 +29,6 @@ import org.aspectj.runtime.internal.AroundClosure;
 import org.springframework.aop.ProxyMethodInvocation;
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.ParameterNameDiscoverer;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -57,15 +56,12 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 
 	private final ProxyMethodInvocation methodInvocation;
 
-	@Nullable
 	private Object[] defensiveCopyOfArgs;
 
 	/** Lazily initialized signature object */
-	@Nullable
 	private Signature signature;
 
 	/** Lazily initialized source location object */
-	@Nullable
 	private SourceLocation sourceLocation;
 
 
@@ -113,7 +109,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	 * Returns the Spring AOP target. May be {@code null} if there is no target.
 	 */
 	@Override
-	@Nullable
 	public Object getTarget() {
 		return this.methodInvocation.getThis();
 	}
@@ -181,7 +176,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	 */
 	private class MethodSignatureImpl implements MethodSignature {
 
-		@Nullable
 		private volatile String[] parameterNames;
 
 		@Override
@@ -220,7 +214,6 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 		}
 
 		@Override
-		@Nullable
 		public String[] getParameterNames() {
 			if (this.parameterNames == null) {
 				this.parameterNames = parameterNameDiscoverer.getParameterNames(getMethod());

spring-aop/src/main/java/org/springframework/aop/aspectj/RuntimeTestWalker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.aspectj.weaver.reflect.ReflectionVar;
 import org.aspectj.weaver.reflect.ShadowMatchImpl;
 import org.aspectj.weaver.tools.ShadowMatch;
 
-import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
 
@@ -79,7 +78,6 @@ class RuntimeTestWalker {
 	}
 
 
-	@Nullable
 	private final Test runtimeTest;
 
 

spring-aop/src/main/java/org/springframework/aop/aspectj/SimpleAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -16,13 +16,9 @@
 
 package org.springframework.aop.aspectj;
 
-import java.lang.reflect.InvocationTargetException;
-
 import org.springframework.aop.framework.AopConfigException;
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
-import org.springframework.util.ReflectionUtils;
 
 /**
  * Implementation of {@link AspectInstanceFactory} that creates a new instance
@@ -56,28 +52,17 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	@Override
 	public final Object getAspectInstance() {
 		try {
-			return ReflectionUtils.accessibleConstructor(this.aspectClass).newInstance();
-		}
-		catch (NoSuchMethodException ex) {
-			throw new AopConfigException(
-					"No default constructor on aspect class: " + this.aspectClass.getName(), ex);
+			return this.aspectClass.newInstance();
 		}
 		catch (InstantiationException ex) {
-			throw new AopConfigException(
-					"Unable to instantiate aspect class: " + this.aspectClass.getName(), ex);
+			throw new AopConfigException("Unable to instantiate aspect class [" + this.aspectClass.getName() + "]", ex);
 		}
 		catch (IllegalAccessException ex) {
-			throw new AopConfigException(
-					"Could not access aspect constructor: " + this.aspectClass.getName(), ex);
-		}
-		catch (InvocationTargetException ex) {
-			throw new AopConfigException(
-					"Failed to invoke aspect constructor: " + this.aspectClass.getName(), ex.getTargetException());
+			throw new AopConfigException("Cannot access element class [" + this.aspectClass.getName() + "]", ex);
 		}
 	}
 
 	@Override
-	@Nullable
 	public ClassLoader getAspectClassLoader() {
 		return this.aspectClass.getClassLoader();
 	}

spring-aop/src/main/java/org/springframework/aop/aspectj/SingletonAspectInstanceFactory.java

@@ -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.
@@ -16,10 +16,7 @@
 
 package org.springframework.aop.aspectj;
 
-import java.io.Serializable;
-
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -32,8 +29,7 @@ import org.springframework.util.Assert;
  * @since 2.0
  * @see SimpleAspectInstanceFactory
  */
-@SuppressWarnings("serial")
-public class SingletonAspectInstanceFactory implements AspectInstanceFactory, Serializable {
+public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
 
 	private final Object aspectInstance;
 
@@ -54,7 +50,6 @@ public class SingletonAspectInstanceFactory implements AspectInstanceFactory, Se
 	}
 
 	@Override
-	@Nullable
 	public ClassLoader getAspectClassLoader() {
 		return this.aspectInstance.getClass().getClassLoader();
 	}

spring-aop/src/main/java/org/springframework/aop/aspectj/TypePatternClassFilter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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,7 +20,6 @@ import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.TypePatternMatcher;
 
 import org.springframework.aop.ClassFilter;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -28,14 +27,12 @@ import org.springframework.util.StringUtils;
  * Spring AOP {@link ClassFilter} implementation using AspectJ type matching.
  *
  * @author Rod Johnson
- * @author Juergen Hoeller
  * @since 2.0
  */
 public class TypePatternClassFilter implements ClassFilter {
 
-	private String typePattern = "";
+	private String typePattern;
 
-	@Nullable
 	private TypePatternMatcher aspectJTypePatternMatcher;
 
 
@@ -53,6 +50,8 @@ public class TypePatternClassFilter implements ClassFilter {
 	 * Create a fully configured {@link TypePatternClassFilter} using the
 	 * given type pattern.
 	 * @param typePattern the type pattern that AspectJ weaver should parse
+	 * @throws IllegalArgumentException if the supplied {@code typePattern} is {@code null}
+	 * or is recognized as invalid
 	 */
 	public TypePatternClassFilter(String typePattern) {
 		setTypePattern(typePattern);
@@ -73,23 +72,21 @@ public class TypePatternClassFilter implements ClassFilter {
 	 * that implements it.
 	 * <p>These conventions are established by AspectJ, not Spring AOP.
 	 * @param typePattern the type pattern that AspectJ weaver should parse
+	 * @throws IllegalArgumentException if the supplied {@code typePattern} is {@code null}
+	 * or is recognized as invalid
 	 */
 	public void setTypePattern(String typePattern) {
-		Assert.notNull(typePattern, "Type pattern must not be null");
+		Assert.notNull(typePattern);
 		this.typePattern = typePattern;
 		this.aspectJTypePatternMatcher =
 				PointcutParser.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution().
 				parseTypePattern(replaceBooleanOperators(typePattern));
 	}
 
-	/**
-	 * Return the AspectJ type pattern to match.
-	 */
 	public String getTypePattern() {
-		return this.typePattern;
+		return typePattern;
 	}
 
-
 	/**
 	 * Should the pointcut apply to the given interface or target class?
 	 * @param clazz candidate target class
@@ -98,7 +95,9 @@ public class TypePatternClassFilter implements ClassFilter {
 	 */
 	@Override
 	public boolean matches(Class<?> clazz) {
-		Assert.state(this.aspectJTypePatternMatcher != null, "No type pattern has been set");
+		if (this.aspectJTypePatternMatcher == null) {
+			throw new IllegalStateException("No 'typePattern' has been set via ctor/setter.");
+		}
 		return this.aspectJTypePatternMatcher.matches(clazz);
 	}
 
@@ -109,8 +108,9 @@ public class TypePatternClassFilter implements ClassFilter {
 	 * <p>This method converts back to {@code &&} for the AspectJ pointcut parser.
 	 */
 	private String replaceBooleanOperators(String pcExpr) {
-		String result = StringUtils.replace(pcExpr," and "," && ");
-		result = StringUtils.replace(result, " or ", " || ");
-		return StringUtils.replace(result, " not ", " ! ");
+		pcExpr = StringUtils.replace(pcExpr," and "," && ");
+		pcExpr = StringUtils.replace(pcExpr, " or ", " || ");
+		pcExpr = StringUtils.replace(pcExpr, " not ", " ! ");
+		return pcExpr;
 	}
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AbstractAspectJAdvisorFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -38,10 +38,10 @@ import org.aspectj.lang.reflect.AjType;
 import org.aspectj.lang.reflect.AjTypeSystem;
 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.annotation.AnnotationUtils;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 /**
@@ -61,6 +61,34 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	private static final String AJC_MAGIC = "ajc$";
 
 
+	/**
+	 * Find and return the first AspectJ annotation on the given method
+	 * (there <i>should</i> only be one anyway...)
+	 */
+	@SuppressWarnings("unchecked")
+	protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
+		Class<?>[] 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);
+			if (foundAnnotation != null) {
+				return foundAnnotation;
+			}
+		}
+		return null;
+	}
+
+	private static <A extends Annotation> AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
+		A result = AnnotationUtils.findAnnotation(method, toLookFor);
+		if (result != null) {
+			return new AspectJAnnotation<A>(result);
+		}
+		else {
+			return null;
+		}
+	}
+
+
 	/** Logger available to subclasses */
 	protected final Log logger = LogFactory.getLog(getClass());
 
@@ -122,37 +150,48 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	}
 
 	/**
-	 * Find and return the first AspectJ annotation on the given method
-	 * (there <i>should</i> only be one anyway...)
+	 * The pointcut and advice annotations both have an "argNames" member which contains a
+	 * comma-separated list of the argument names. We use this (if non-empty) to build the
+	 * formal parameters for the pointcut.
 	 */
-	@SuppressWarnings("unchecked")
-	@Nullable
-	protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
-		Class<?>[] 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);
-			if (foundAnnotation != null) {
-				return foundAnnotation;
-			}
+	protected AspectJExpressionPointcut createPointcutExpression(
+			Method annotatedMethod, Class<?> declarationScope, String[] pointcutParameterNames) {
+
+		Class<?> [] pointcutParameterTypes = new Class<?>[0];
+		if (pointcutParameterNames != null) {
+			pointcutParameterTypes = extractPointcutParameterTypes(pointcutParameterNames,annotatedMethod);
 		}
-		return null;
+
+		AspectJExpressionPointcut ajexp =
+				new AspectJExpressionPointcut(declarationScope,pointcutParameterNames,pointcutParameterTypes);
+		ajexp.setLocation(annotatedMethod.toString());
+		return ajexp;
 	}
 
-	@Nullable
-	private static <A extends Annotation> AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
-		A result = AnnotationUtils.findAnnotation(method, toLookFor);
-		if (result != null) {
-			return new AspectJAnnotation<>(result);
+	/**
+	 * Create the pointcut parameters needed by aspectj based on the given argument names
+	 * and the argument types that are available from the adviceMethod. Needs to take into
+	 * account (ignore) any JoinPoint based arguments as these are not pointcut context but
+	 * rather part of the advice execution context (thisJoinPoint, thisJoinPointStaticPart)
+	 */
+	private Class<?>[] extractPointcutParameterTypes(String[] argNames, Method adviceMethod) {
+		Class<?>[] ret = new Class<?>[argNames.length];
+		Class<?>[] paramTypes = adviceMethod.getParameterTypes();
+		if (argNames.length > paramTypes.length) {
+			throw new IllegalStateException("Expecting at least " + argNames.length +
+					" arguments in the advice declaration, but only found " + paramTypes.length);
 		}
-		else {
-			return null;
+		// Make the simplifying assumption for now that all of the JoinPoint based arguments
+		// come first in the advice declaration.
+		int typeOffset = paramTypes.length - argNames.length;
+		for (int i = 0; i < ret.length; i++) {
+			ret[i] = paramTypes[i + typeOffset];
 		}
+		return ret;
 	}
 
 
 	protected enum AspectJAnnotationType {
-
 		AtPointcut,
 		AtBefore,
 		AtAfter,
@@ -170,7 +209,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<>();
+		private static Map<Class<?>, AspectJAnnotationType> annotationTypes =
+				new HashMap<Class<?>, AspectJAnnotationType>();
 
 		static {
 			annotationTypes.put(Pointcut.class,AspectJAnnotationType.AtPointcut);
@@ -213,6 +253,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}
 
 		private String resolveExpression(A annotation) throws Exception {
+			String expression = null;
 			for (String methodName : EXPRESSION_PROPERTIES) {
 				Method method;
 				try {
@@ -224,11 +265,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 				if (method != null) {
 					String candidate = (String) method.invoke(annotation);
 					if (StringUtils.hasText(candidate)) {
-						return candidate;
+						expression = candidate;
 					}
 				}
 			}
-			throw new IllegalStateException("Failed to resolve expression: " + annotation);
+			return expression;
 		}
 
 		public AspectJAnnotationType getAnnotationType() {
@@ -261,9 +302,8 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 	private static class AspectJAnnotationParameterNameDiscoverer implements ParameterNameDiscoverer {
 
 		@Override
-		@Nullable
 		public String[] getParameterNames(Method method) {
-			if (method.getParameterCount() == 0) {
+			if (method.getParameterTypes().length == 0) {
 				return new String[0];
 			}
 			AspectJAnnotation<?> annotation = findAspectJAnnotationOnMethod(method);
@@ -284,7 +324,6 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		}
 
 		@Override
-		@Nullable
 		public String[] getParameterNames(Constructor<?> ctor) {
 			throw new UnsupportedOperationException("Spring AOP cannot handle constructor advice");
 		}

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AnnotationAwareAspectJAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -24,7 +24,6 @@ import org.springframework.aop.Advisor;
 import org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator;
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -49,13 +48,10 @@ import org.springframework.util.Assert;
 @SuppressWarnings("serial")
 public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
 
-	@Nullable
 	private List<Pattern> includePatterns;
 
-	@Nullable
-	private AspectJAdvisorFactory aspectJAdvisorFactory;
+	private AspectJAdvisorFactory aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory();
 
-	@Nullable
 	private BeanFactoryAspectJAdvisorsBuilder aspectJAdvisorsBuilder;
 
 
@@ -64,7 +60,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 	 * <p>Default is to consider all @AspectJ beans as eligible.
 	 */
 	public void setIncludePatterns(List<String> patterns) {
-		this.includePatterns = new ArrayList<>(patterns.size());
+		this.includePatterns = new ArrayList<Pattern>(patterns.size());
 		for (String patternText : patterns) {
 			this.includePatterns.add(Pattern.compile(patternText));
 		}
@@ -78,9 +74,6 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 	@Override
 	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 		super.initBeanFactory(beanFactory);
-		if (this.aspectJAdvisorFactory == null) {
-			this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
-		}
 		this.aspectJAdvisorsBuilder =
 				new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
 	}
@@ -91,9 +84,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 		// Add all the Spring advisors found according to superclass rules.
 		List<Advisor> advisors = super.findCandidateAdvisors();
 		// Build Advisors for all AspectJ aspects in the bean factory.
-		if (this.aspectJAdvisorsBuilder != null) {
-			advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
-		}
+		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
 		return advisors;
 	}
 
@@ -107,8 +98,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 		// proxied by that interface and fail at runtime as the advice method is not
 		// defined on the interface. We could potentially relax the restriction about
 		// not advising aspects in the future.
-		return (super.isInfrastructureClass(beanClass) ||
-				(this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
+		return (super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory.isAspect(beanClass));
 	}
 
 	/**
@@ -140,7 +130,6 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 
 		public BeanFactoryAspectJAdvisorsBuilderAdapter(
 				ListableBeanFactory beanFactory, AspectJAdvisorFactory advisorFactory) {
-
 			super(beanFactory, advisorFactory);
 		}
 

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectJAdvisorFactory.java

@@ -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.
@@ -24,7 +24,6 @@ import org.aopalliance.aop.Advice;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.aspectj.AspectJExpressionPointcut;
 import org.springframework.aop.framework.AopConfigException;
-import org.springframework.lang.Nullable;
 
 /**
  * Interface for factories that can create Spring AOP Advisors from classes
@@ -64,32 +63,31 @@ public interface AspectJAdvisorFactory {
 	/**
 	 * Build Spring AOP Advisors for all annotated At-AspectJ methods
 	 * on the specified aspect instance.
-	 * @param aspectInstanceFactory the aspect instance factory
-	 * (not the aspect instance itself in order to avoid eager instantiation)
+	 * @param aif the aspect instance factory (not the aspect instance itself
+	 * in order to avoid eager instantiation)
 	 * @return a list of advisors for this class
 	 */
-	List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory);
+	List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aif);
 
 	/**
 	 * Build a Spring AOP Advisor for the given AspectJ advice method.
 	 * @param candidateAdviceMethod the candidate advice method
-	 * @param aspectInstanceFactory the aspect instance factory
-	 * @param declarationOrder the declaration order within the aspect
+	 * @param aif the aspect instance factory
+	 * @param declarationOrderInAspect the declaration order within the aspect
 	 * @param aspectName the name of the aspect
 	 * @return {@code null} if the method is not an AspectJ advice method
 	 * or if it is a pointcut that will be used by other advice but will not
 	 * create a Spring advice in its own right
 	 */
-	@Nullable
-	Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
-			int declarationOrder, String aspectName);
+	Advisor getAdvisor(Method candidateAdviceMethod,
+			MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName);
 
 	/**
 	 * Build a Spring AOP Advice for the given AspectJ advice method.
 	 * @param candidateAdviceMethod the candidate advice method
-	 * @param expressionPointcut the AspectJ expression pointcut
-	 * @param aspectInstanceFactory the aspect instance factory
-	 * @param declarationOrder the declaration order within the aspect
+	 * @param pointcut the corresponding AspectJ expression pointcut
+	 * @param aif the aspect instance factory
+	 * @param declarationOrderInAspect the declaration order within the aspect
 	 * @param aspectName the name of the aspect
 	 * @return {@code null} if the method is not an AspectJ advice method
 	 * or if it is a pointcut that will be used by other advice but will not
@@ -100,8 +98,7 @@ public interface AspectJAdvisorFactory {
 	 * @see org.springframework.aop.aspectj.AspectJAfterReturningAdvice
 	 * @see org.springframework.aop.aspectj.AspectJAfterThrowingAdvice
 	 */
-	@Nullable
-	Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
-			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName);
+	Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut pointcut,
+			MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName);
 
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectJProxyFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -16,18 +16,18 @@
 
 package org.springframework.aop.aspectj.annotation;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 import org.aspectj.lang.reflect.PerClauseKind;
 
 import org.springframework.aop.Advisor;
 import org.springframework.aop.aspectj.AspectJProxyUtils;
-import org.springframework.aop.aspectj.SimpleAspectInstanceFactory;
+import org.springframework.aop.framework.AopConfigException;
 import org.springframework.aop.framework.ProxyCreatorSupport;
 import org.springframework.aop.support.AopUtils;
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.core.OrderComparator;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -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 ConcurrentHashMap<>();
+	private static final Map<Class<?>, Object> aspectCache = new HashMap<Class<?>, Object>();
 
 	private final AspectJAdvisorFactory aspectFactory = new ReflectiveAspectJAdvisorFactory();
 
@@ -119,11 +119,9 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 */
 	private void addAdvisorsFromAspectInstanceFactory(MetadataAwareAspectInstanceFactory instanceFactory) {
 		List<Advisor> advisors = this.aspectFactory.getAdvisors(instanceFactory);
-		Class<?> targetClass = getTargetClass();
-		Assert.state(targetClass != null, "Unresolvable target class");
-		advisors = AopUtils.findAdvisorsThatCanApply(advisors, targetClass);
+		advisors = AopUtils.findAdvisorsThatCanApply(advisors, getTargetClass());
 		AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(advisors);
-		AnnotationAwareOrderComparator.sort(advisors);
+		OrderComparator.sort(advisors);
 		addAdvisors(advisors);
 	}
 
@@ -146,7 +144,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	private MetadataAwareAspectInstanceFactory createAspectInstanceFactory(
 			AspectMetadata am, Class<?> aspectClass, String aspectName) {
 
-		MetadataAwareAspectInstanceFactory instanceFactory;
+		MetadataAwareAspectInstanceFactory instanceFactory = null;
 		if (am.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
 			// Create a shared aspect instance.
 			Object instance = getSingletonAspectInstance(aspectClass);
@@ -164,20 +162,23 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	 * is created if one cannot be found in the instance cache.
 	 */
 	private Object getSingletonAspectInstance(Class<?> aspectClass) {
-		// Quick check without a lock...
-		Object instance = aspectCache.get(aspectClass);
-		if (instance == null) {
-			synchronized (aspectCache) {
-				// To be safe, check within full lock now...
-				instance = aspectCache.get(aspectClass);
-				if (instance != null) {
-					return instance;
-				}
-				instance = new SimpleAspectInstanceFactory(aspectClass).getAspectInstance();
+		synchronized (aspectCache) {
+			Object instance = aspectCache.get(aspectClass);
+			if (instance != null) {
+				return instance;
+			}
+			try {
+				instance = aspectClass.newInstance();
 				aspectCache.put(aspectClass, instance);
+				return instance;
+			}
+			catch (InstantiationException ex) {
+				throw new AopConfigException("Unable to instantiate aspect class [" + aspectClass.getName() + "]", ex);
+			}
+			catch (IllegalAccessException ex) {
+				throw new AopConfigException("Cannot access aspect class [" + aspectClass.getName() + "]", ex);
 			}
 		}
-		return instance;
 	}
 
 

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/AspectMetadata.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -16,10 +16,6 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
-
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.reflect.AjType;
 import org.aspectj.lang.reflect.AjTypeSystem;
@@ -35,35 +31,21 @@ import org.springframework.aop.support.ComposablePointcut;
  * Metadata for an AspectJ aspect class, with an additional Spring AOP pointcut
  * for the per clause.
  *
- * <p>Uses AspectJ 5 AJType reflection API, enabling us to work with different
- * AspectJ instantiation models such as "singleton", "pertarget" and "perthis".
+ * <p>Uses AspectJ 5 AJType reflection API, so is only supported on Java 5.
+ * Enables us to work with different AspectJ instantiation models such as
+ * "singleton", "pertarget" and "perthis".
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @since 2.0
  * @see org.springframework.aop.aspectj.AspectJExpressionPointcut
  */
-@SuppressWarnings("serial")
-public class AspectMetadata implements Serializable {
-
-	/**
-	 * The name of this aspect as defined to Spring (the bean name) -
-	 * allows us to determine if two pieces of advice come from the
-	 * same aspect and hence their relative precedence.
-	 */
-	private final String aspectName;
-
-	/**
-	 * The aspect class, stored separately for re-resolution of the
-	 * corresponding AjType on deserialization.
-	 */
-	private final Class<?> aspectClass;
+public class AspectMetadata {
 
 	/**
 	 * AspectJ reflection information (AspectJ 5 / Java 5 specific).
-	 * Re-resolved on deserialization since it isn't serializable itself.
 	 */
-	private transient AjType<?> ajType;
+	private final AjType<?> ajType;
 
 	/**
 	 * Spring AOP pointcut corresponding to the per clause of the
@@ -72,6 +54,13 @@ public class AspectMetadata implements Serializable {
 	 */
 	private final Pointcut perClausePointcut;
 
+	/**
+	 * The name of this aspect as defined to Spring (the bean name) -
+	 * allows us to determine if two pieces of advice come from the
+	 * same aspect and hence their relative precedence.
+	 */
+	private String aspectName;
+
 
 	/**
 	 * Create a new AspectMetadata instance for the given aspect class.
@@ -83,7 +72,7 @@ public class AspectMetadata implements Serializable {
 
 		Class<?> currClass = aspectClass;
 		AjType<?> ajType = null;
-		while (currClass != Object.class) {
+		while (!currClass.equals(Object.class)) {
 			AjType<?> ajTypeToCheck = AjTypeSystem.getAjType(currClass);
 			if (ajTypeToCheck.isAspect()) {
 				ajType = ajTypeToCheck;
@@ -94,29 +83,26 @@ public class AspectMetadata implements Serializable {
 		if (ajType == null) {
 			throw new IllegalArgumentException("Class '" + aspectClass.getName() + "' is not an @AspectJ aspect");
 		}
-		if (ajType.getDeclarePrecedence().length > 0) {
+		this.ajType = ajType;
+		if (this.ajType.getDeclarePrecedence().length > 0) {
 			throw new IllegalArgumentException("DeclarePrecendence not presently supported in Spring AOP");
 		}
-		this.aspectClass = ajType.getJavaClass();
-		this.ajType = ajType;
 
 		switch (this.ajType.getPerClause().getKind()) {
-			case SINGLETON:
+			case SINGLETON :
 				this.perClausePointcut = Pointcut.TRUE;
 				return;
-			case PERTARGET:
-			case PERTHIS:
+			case PERTARGET : case PERTHIS :
 				AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut();
-				ajexp.setLocation(aspectClass.getName());
+				ajexp.setLocation("@Aspect annotation on " + aspectClass.getName());
 				ajexp.setExpression(findPerClause(aspectClass));
-				ajexp.setPointcutDeclarationScope(aspectClass);
 				this.perClausePointcut = ajexp;
 				return;
-			case PERTYPEWITHIN:
+			case PERTYPEWITHIN :
 				// Works with a type pattern
 				this.perClausePointcut = new ComposablePointcut(new TypePatternClassFilter(findPerClause(aspectClass)));
 				return;
-			default:
+			default :
 				throw new AopConfigException(
 						"PerClause " + ajType.getPerClause().getKind() + " not supported by Spring AOP for " + aspectClass);
 		}
@@ -126,6 +112,8 @@ public class AspectMetadata implements Serializable {
 	 * Extract contents from String of form {@code pertarget(contents)}.
 	 */
 	private String findPerClause(Class<?> aspectClass) {
+		// TODO when AspectJ provides this, we can remove this hack. Hence we don't
+		// bother to make it elegant. Or efficient. Or robust :-)
 		String str = aspectClass.getAnnotation(Aspect.class).value();
 		str = str.substring(str.indexOf("(") + 1);
 		str = str.substring(0, str.length() - 1);
@@ -144,7 +132,7 @@ public class AspectMetadata implements Serializable {
 	 * Return the aspect class.
 	 */
 	public Class<?> getAspectClass() {
-		return this.aspectClass;
+		return this.ajType.getJavaClass();
 	}
 
 	/**
@@ -185,10 +173,4 @@ public class AspectMetadata implements Serializable {
 		return (isPerThisOrPerTarget() || isPerTypeWithin());
 	}
 
-
-	private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
-		inputStream.defaultReadObject();
-		this.ajType = AjTypeSystem.getAjType(this.aspectClass);
-	}
-
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/BeanFactoryAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -16,14 +16,10 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.Serializable;
-
 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.lang.Nullable;
-import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
@@ -41,8 +37,7 @@ import org.springframework.util.ClassUtils;
  * @see org.springframework.beans.factory.BeanFactory
  * @see LazySingletonAspectInstanceFactoryDecorator
  */
-@SuppressWarnings("serial")
-public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInstanceFactory, Serializable {
+public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInstanceFactory {
 
 	private final BeanFactory beanFactory;
 
@@ -59,7 +54,7 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @param name name of the bean
 	 */
 	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name) {
-		this(beanFactory, name, null);
+		this(beanFactory, name, beanFactory.getType(name));
 	}
 
 	/**
@@ -69,19 +64,11 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @param beanFactory BeanFactory to obtain instance(s) from
 	 * @param name the name of the bean
 	 * @param type the type that should be introspected by AspectJ
-	 * ({@code null} indicates resolution through {@link BeanFactory#getType} via the bean name)
 	 */
-	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, @Nullable Class<?> type) {
-		Assert.notNull(beanFactory, "BeanFactory must not be null");
-		Assert.notNull(name, "Bean name must not be null");
+	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class<?> type) {
 		this.beanFactory = beanFactory;
 		this.name = name;
-		Class<?> resolvedType = type;
-		if (type == null) {
-			resolvedType = beanFactory.getType(name);
-			Assert.notNull(resolvedType, "Unresolvable bean type - explicitly specify the aspect class");
-		}
-		this.aspectMetadata = new AspectMetadata(resolvedType, name);
+		this.aspectMetadata = new AspectMetadata(type, name);
 	}
 
 
@@ -91,11 +78,13 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	}
 
 	@Override
-	@Nullable
 	public ClassLoader getAspectClassLoader() {
-		return (this.beanFactory instanceof ConfigurableBeanFactory ?
-				((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
-				ClassUtils.getDefaultClassLoader());
+		if (this.beanFactory instanceof ConfigurableBeanFactory) {
+			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
+		}
+		else {
+			return ClassUtils.getDefaultClassLoader();
+		}
 	}
 
 	@Override
@@ -103,24 +92,6 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 		return this.aspectMetadata;
 	}
 
-	@Override
-	@Nullable
-	public Object getAspectCreationMutex() {
-		if (this.beanFactory.isSingleton(this.name)) {
-			// Rely on singleton semantics provided by the factory -> no local lock.
-			return null;
-		}
-		else if (this.beanFactory instanceof ConfigurableBeanFactory) {
-			// No singleton guarantees from the factory -> let's lock locally but
-			// reuse the factory's singleton lock, just in case a lazy dependency
-			// of our advice bean happens to trigger the singleton lock implicitly...
-			return ((ConfigurableBeanFactory) this.beanFactory).getSingletonMutex();
-		}
-		else {
-			return this;
-		}
-	}
-
 	/**
 	 * Determine the order for this factory's target aspect, either
 	 * an instance-specific order expressed through implementing the

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/BeanFactoryAspectJAdvisorsBuilder.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2008 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,17 +17,16 @@
 package org.springframework.aop.aspectj.annotation;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 import org.aspectj.lang.reflect.PerClauseKind;
 
 import org.springframework.aop.Advisor;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.ListableBeanFactory;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -44,12 +43,12 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 
 	private final AspectJAdvisorFactory advisorFactory;
 
-	@Nullable
-	private volatile List<String> aspectBeanNames;
+	private List<String> aspectBeanNames;
 
-	private final Map<String, List<Advisor>> advisorsCache = new ConcurrentHashMap<>();
+	private final Map<String, List<Advisor>> advisorsCache = new HashMap<String, List<Advisor>>();
 
-	private final Map<String, MetadataAwareAspectInstanceFactory> aspectFactoryCache = new ConcurrentHashMap<>();
+	private final Map<String, MetadataAwareAspectInstanceFactory> aspectFactoryCache =
+			new HashMap<String, MetadataAwareAspectInstanceFactory>();
 
 
 	/**
@@ -57,7 +56,7 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 	 * @param beanFactory the ListableBeanFactory to scan
 	 */
 	public BeanFactoryAspectJAdvisorsBuilder(ListableBeanFactory beanFactory) {
-		this(beanFactory, new ReflectiveAspectJAdvisorFactory(beanFactory));
+		this(beanFactory, new ReflectiveAspectJAdvisorFactory());
 	}
 
 	/**
@@ -81,64 +80,63 @@ public class BeanFactoryAspectJAdvisorsBuilder {
 	 * @see #isEligibleBean
 	 */
 	public List<Advisor> buildAspectJAdvisors() {
-		List<String> aspectNames = this.aspectBeanNames;
+		List<String> aspectNames = null;
 
-		if (aspectNames == null) {
-			synchronized (this) {
-				aspectNames = this.aspectBeanNames;
-				if (aspectNames == null) {
-					List<Advisor> advisors = new LinkedList<>();
-					aspectNames = new LinkedList<>();
-					String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
-							this.beanFactory, Object.class, true, false);
-					for (String beanName : beanNames) {
-						if (!isEligibleBean(beanName)) {
-							continue;
-						}
-						// 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);
-						if (beanType == null) {
-							continue;
-						}
-						if (this.advisorFactory.isAspect(beanType)) {
-							aspectNames.add(beanName);
-							AspectMetadata amd = new AspectMetadata(beanType, beanName);
-							if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
-								MetadataAwareAspectInstanceFactory factory =
-										new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
-								List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
-								if (this.beanFactory.isSingleton(beanName)) {
-									this.advisorsCache.put(beanName, classAdvisors);
-								}
-								else {
-									this.aspectFactoryCache.put(beanName, factory);
-								}
-								advisors.addAll(classAdvisors);
+		synchronized (this) {
+			aspectNames = this.aspectBeanNames;
+			if (aspectNames == null) {
+				List<Advisor> advisors = new LinkedList<Advisor>();
+				aspectNames = new LinkedList<String>();
+				String[] beanNames =
+						BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
+				for (String beanName : beanNames) {
+					if (!isEligibleBean(beanName)) {
+						continue;
+					}
+					// 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);
+					if (beanType == null) {
+						continue;
+					}
+					if (this.advisorFactory.isAspect(beanType)) {
+						aspectNames.add(beanName);
+						AspectMetadata amd = new AspectMetadata(beanType, beanName);
+						if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
+							MetadataAwareAspectInstanceFactory factory =
+									new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
+							List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
+							if (this.beanFactory.isSingleton(beanName)) {
+								this.advisorsCache.put(beanName, classAdvisors);
 							}
 							else {
-								// Per target or per this.
-								if (this.beanFactory.isSingleton(beanName)) {
-									throw new IllegalArgumentException("Bean with name '" + beanName +
-											"' is a singleton, but aspect instantiation model is not singleton");
-								}
-								MetadataAwareAspectInstanceFactory factory =
-										new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
 								this.aspectFactoryCache.put(beanName, factory);
-								advisors.addAll(this.advisorFactory.getAdvisors(factory));
 							}
+							advisors.addAll(classAdvisors);
+						}
+						else {
+							// Per target or per this.
+							if (this.beanFactory.isSingleton(beanName)) {
+								throw new IllegalArgumentException("Bean with name '" + beanName +
+										"' is a singleton, but aspect instantiation model is not singleton");
+							}
+							MetadataAwareAspectInstanceFactory factory =
+									new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
+							this.aspectFactoryCache.put(beanName, factory);
+							advisors.addAll(this.advisorFactory.getAdvisors(factory));
 						}
 					}
-					this.aspectBeanNames = aspectNames;
-					return advisors;
 				}
+				this.aspectBeanNames = aspectNames;
+				return advisors;
 			}
 		}
 
 		if (aspectNames.isEmpty()) {
 			return Collections.emptyList();
 		}
-		List<Advisor> advisors = new LinkedList<>();
+		List<Advisor> advisors = new LinkedList<Advisor>();
 		for (String aspectName : aspectNames) {
 			List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
 			if (cachedAdvisors != null) {

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -16,9 +16,6 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
 import java.lang.reflect.Method;
 
 import org.aopalliance.aop.Advice;
@@ -31,7 +28,6 @@ import org.springframework.aop.aspectj.InstantiationModelAwarePointcutAdvisor;
 import org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactory.AspectJAnnotation;
 import org.springframework.aop.support.DynamicMethodMatcherPointcut;
 import org.springframework.aop.support.Pointcuts;
-import org.springframework.lang.Nullable;
 
 /**
  * Internal implementation of AspectJPointcutAdvisor.
@@ -41,76 +37,58 @@ import org.springframework.lang.Nullable;
  * @author Juergen Hoeller
  * @since 2.0
  */
-@SuppressWarnings("serial")
 class InstantiationModelAwarePointcutAdvisorImpl
-		implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation, Serializable {
-
-	private static Advice EMPTY_ADVICE = new Advice() {};
-
+		implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation {
 
 	private final AspectJExpressionPointcut declaredPointcut;
 
-	private final Class<?> declaringClass;
-
-	private final String methodName;
-
-	private final Class<?>[] parameterTypes;
-
-	private transient Method aspectJAdviceMethod;
-
-	private final AspectJAdvisorFactory aspectJAdvisorFactory;
+	private Pointcut pointcut;
 
 	private final MetadataAwareAspectInstanceFactory aspectInstanceFactory;
 
-	private final int declarationOrder;
-
-	private final String aspectName;
-
-	private final Pointcut pointcut;
+	private final Method method;
 
 	private final boolean lazy;
 
-	@Nullable
+	private final AspectJAdvisorFactory atAspectJAdvisorFactory;
+
 	private Advice instantiatedAdvice;
 
-	@Nullable
+	private int declarationOrder;
+
+	private String aspectName;
+
 	private Boolean isBeforeAdvice;
 
-	@Nullable
 	private Boolean isAfterAdvice;
 
 
-	public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
-			Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
-			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
+	public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp,
+			MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName) {
 
-		this.declaredPointcut = declaredPointcut;
-		this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
-		this.methodName = aspectJAdviceMethod.getName();
-		this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
-		this.aspectJAdviceMethod = aspectJAdviceMethod;
-		this.aspectJAdvisorFactory = aspectJAdvisorFactory;
-		this.aspectInstanceFactory = aspectInstanceFactory;
-		this.declarationOrder = declarationOrder;
+		this.declaredPointcut = ajexp;
+		this.method = method;
+		this.atAspectJAdvisorFactory = af;
+		this.aspectInstanceFactory = aif;
+		this.declarationOrder = declarationOrderInAspect;
 		this.aspectName = aspectName;
 
-		if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
+		if (aif.getAspectMetadata().isLazilyInstantiated()) {
 			// Static part of the pointcut is a lazy type.
-			Pointcut preInstantiationPointcut = Pointcuts.union(
-					aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
+			Pointcut preInstantiationPointcut =
+					Pointcuts.union(aif.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
 
 			// Make it dynamic: must mutate from pre-instantiation to post-instantiation state.
 			// If it's not a dynamic pointcut, it may be optimized out
 			// by the Spring AOP infrastructure after the first evaluation.
-			this.pointcut = new PerTargetInstantiationModelPointcut(
-					this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
+			this.pointcut = new PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aif);
 			this.lazy = true;
 		}
 		else {
 			// A singleton aspect.
-			this.pointcut = this.declaredPointcut;
-			this.lazy = false;
 			this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
+			this.pointcut = declaredPointcut;
+			this.lazy = false;
 		}
 	}
 
@@ -163,10 +141,9 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	}
 
 
-	private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
-		Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
-				this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
-		return (advice != null ? advice : EMPTY_ADVICE);
+	private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
+		return this.atAspectJAdvisorFactory.getAdvice(
+				this.method, pcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
 	}
 
 	public MetadataAwareAspectInstanceFactory getAspectInstanceFactory() {
@@ -214,7 +191,7 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	 */
 	private void determineAdviceType() {
 		AspectJAnnotation<?> aspectJAnnotation =
-				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(this.aspectJAdviceMethod);
+				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(this.method);
 		if (aspectJAnnotation == null) {
 			this.isBeforeAdvice = false;
 			this.isAfterAdvice = false;
@@ -243,21 +220,11 @@ class InstantiationModelAwarePointcutAdvisorImpl
 	@Override
 	public String toString() {
 		return "InstantiationModelAwarePointcutAdvisor: expression [" + getDeclaredPointcut().getExpression() +
-			"]; advice method [" + this.aspectJAdviceMethod + "]; perClauseKind=" +
+			"]; advice method [" + this.method + "]; perClauseKind=" +
 			this.aspectInstanceFactory.getAspectMetadata().getAjType().getPerClause().getKind();
 
 	}
 
-	private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
-		inputStream.defaultReadObject();
-		try {
-			this.aspectJAdviceMethod = this.declaringClass.getMethod(this.methodName, this.parameterTypes);
-		}
-		catch (NoSuchMethodException ex) {
-			throw new IllegalStateException("Failed to find advice method on deserialization", ex);
-		}
-	}
-
 
 	/**
 	 * Pointcut implementation that changes its behaviour when the advice is instantiated.
@@ -270,12 +237,10 @@ class InstantiationModelAwarePointcutAdvisorImpl
 
 		private final Pointcut preInstantiationPointcut;
 
-		@Nullable
 		private LazySingletonAspectInstanceFactoryDecorator aspectInstanceFactory;
 
 		private PerTargetInstantiationModelPointcut(AspectJExpressionPointcut declaredPointcut,
 				Pointcut preInstantiationPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
-
 			this.declaredPointcut = declaredPointcut;
 			this.preInstantiationPointcut = preInstantiationPointcut;
 			if (aspectInstanceFactory instanceof LazySingletonAspectInstanceFactoryDecorator) {
@@ -284,14 +249,14 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		}
 
 		@Override
-		public boolean matches(Method method, @Nullable 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, @Nullable 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));
 		}

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/LazySingletonAspectInstanceFactoryDecorator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -16,9 +16,6 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.Serializable;
-
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -28,12 +25,10 @@ import org.springframework.util.Assert;
  * @author Juergen Hoeller
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwareAspectInstanceFactory, Serializable {
+public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwareAspectInstanceFactory {
 
 	private final MetadataAwareAspectInstanceFactory maaif;
 
-	@Nullable
 	private volatile Object materialized;
 
 
@@ -48,25 +43,15 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 
 
 	@Override
-	public Object getAspectInstance() {
-		Object aspectInstance = this.materialized;
-		if (aspectInstance == null) {
-			Object mutex = this.maaif.getAspectCreationMutex();
-			if (mutex == null) {
-				aspectInstance = this.maaif.getAspectInstance();
-				this.materialized = aspectInstance;
-			}
-			else {
-				synchronized (mutex) {
-					aspectInstance = this.materialized;
-					if (aspectInstance == null) {
-						aspectInstance = this.maaif.getAspectInstance();
-						this.materialized = aspectInstance;
-					}
+	public synchronized Object getAspectInstance() {
+		if (this.materialized == null) {
+			synchronized (this) {
+				if (this.materialized == null) {
+					this.materialized = this.maaif.getAspectInstance();
 				}
 			}
 		}
-		return aspectInstance;
+		return this.materialized;
 	}
 
 	public boolean isMaterialized() {
@@ -74,7 +59,6 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 	}
 
 	@Override
-	@Nullable
 	public ClassLoader getAspectClassLoader() {
 		return this.maaif.getAspectClassLoader();
 	}
@@ -84,12 +68,6 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 		return this.maaif.getAspectMetadata();
 	}
 
-	@Override
-	@Nullable
-	public Object getAspectCreationMutex() {
-		return this.maaif.getAspectCreationMutex();
-	}
-
 	@Override
 	public int getOrder() {
 		return this.maaif.getOrder();

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/MetadataAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@
 package org.springframework.aop.aspectj.annotation;
 
 import org.springframework.aop.aspectj.AspectInstanceFactory;
-import org.springframework.lang.Nullable;
 
 /**
  * Subinterface of {@link org.springframework.aop.aspectj.AspectInstanceFactory}
@@ -40,12 +39,4 @@ public interface MetadataAwareAspectInstanceFactory extends AspectInstanceFactor
 	 */
 	AspectMetadata getAspectMetadata();
 
-	/**
-	 * Return the best possible creation mutex for this factory.
-	 * @return the mutex object (may be {@code null} for no mutex to use)
-	 * @since 4.3
-	 */
-	@Nullable
-	Object getAspectCreationMutex();
-
 }

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/PrototypeAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2015 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,13 +16,11 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.Serializable;
-
 import org.springframework.beans.factory.BeanFactory;
 
 /**
- * {@link org.springframework.aop.aspectj.AspectInstanceFactory} backed by a
- * {@link BeanFactory}-provided prototype, enforcing prototype semantics.
+ * AspectInstanceFactory backed by a BeanFactory-provided prototype,
+ * enforcing prototype semantics.
  *
  * <p>Note that this may instantiate multiple times, which probably won't give the
  * semantics you expect. Use a {@link LazySingletonAspectInstanceFactoryDecorator}
@@ -34,8 +32,7 @@ import org.springframework.beans.factory.BeanFactory;
  * @see org.springframework.beans.factory.BeanFactory
  * @see LazySingletonAspectInstanceFactoryDecorator
  */
-@SuppressWarnings("serial")
-public class PrototypeAspectInstanceFactory extends BeanFactoryAspectInstanceFactory implements Serializable {
+public class PrototypeAspectInstanceFactory extends BeanFactoryAspectInstanceFactory {
 
 	/**
 	 * Create a PrototypeAspectInstanceFactory. AspectJ will be called to

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -16,7 +16,6 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.Serializable;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -46,13 +45,12 @@ import org.springframework.aop.aspectj.AspectJMethodBeforeAdvice;
 import org.springframework.aop.aspectj.DeclareParentsAdvisor;
 import org.springframework.aop.framework.AopConfigException;
 import org.springframework.aop.support.DefaultPointcutAdvisor;
-import org.springframework.beans.factory.BeanFactory;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConvertingComparator;
-import org.springframework.lang.Nullable;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
+import org.springframework.util.comparator.CompoundComparator;
 import org.springframework.util.comparator.InstanceComparator;
 
 /**
@@ -67,62 +65,45 @@ import org.springframework.util.comparator.InstanceComparator;
  * @author Phillip Webb
  * @since 2.0
  */
-@SuppressWarnings("serial")
-public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory implements Serializable {
+public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFactory {
 
 	private static final Comparator<Method> METHOD_COMPARATOR;
 
 	static {
-		Comparator<Method> adviceKindComparator = new ConvertingComparator<>(
-				new InstanceComparator<>(
+		CompoundComparator<Method> comparator = new CompoundComparator<Method>();
+		comparator.addComparator(new ConvertingComparator<Method, Annotation>(
+				new InstanceComparator<Annotation>(
 						Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class),
-				(Converter<Method, Annotation>) method -> {
-					AspectJAnnotation<?> annotation =
-						AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
-					return (annotation != null ? annotation.getAnnotation() : null);
-				});
-		Comparator<Method> methodNameComparator = new ConvertingComparator<>(Method::getName);
-		METHOD_COMPARATOR = adviceKindComparator.thenComparing(methodNameComparator);
-	}
-
-
-	@Nullable
-	private final BeanFactory beanFactory;
-
-
-	/**
-	 * Create a new {@code ReflectiveAspectJAdvisorFactory}.
-	 */
-	public ReflectiveAspectJAdvisorFactory() {
-		this(null);
-	}
-
-	/**
-	 * Create a new {@code ReflectiveAspectJAdvisorFactory}, propagating the given
-	 * {@link BeanFactory} to the created {@link AspectJExpressionPointcut} instances,
-	 * for bean pointcut handling as well as consistent {@link ClassLoader} resolution.
-	 * @param beanFactory the BeanFactory to propagate (may be {@code null}}
-	 * @since 4.3.6
-	 * @see AspectJExpressionPointcut#setBeanFactory
-	 * @see org.springframework.beans.factory.config.ConfigurableBeanFactory#getBeanClassLoader()
-	 */
-	public ReflectiveAspectJAdvisorFactory(@Nullable BeanFactory beanFactory) {
-		this.beanFactory = beanFactory;
+				new Converter<Method, Annotation>() {
+					@Override
+					public Annotation convert(Method method) {
+						AspectJAnnotation<?> annotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(method);
+						return annotation == null ? null : annotation.getAnnotation();
+					}
+				}));
+		comparator.addComparator(new ConvertingComparator<Method, String>(
+				new Converter<Method, String>() {
+					@Override
+					public String convert(Method method) {
+						return method.getName();
+					}
+				}));
+		METHOD_COMPARATOR = comparator;
 	}
 
 
 	@Override
-	public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
-		Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
-		String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
+	public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory maaif) {
+		final Class<?> aspectClass = maaif.getAspectMetadata().getAspectClass();
+		final String aspectName = maaif.getAspectMetadata().getAspectName();
 		validate(aspectClass);
 
 		// We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
 		// so that it will only instantiate once.
-		MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
-				new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
+		final MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
+				new LazySingletonAspectInstanceFactoryDecorator(maaif);
 
-		List<Advisor> advisors = new LinkedList<>();
+		final List<Advisor> advisors = new LinkedList<Advisor>();
 		for (Method method : getAdvisorMethods(aspectClass)) {
 			Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
 			if (advisor != null) {
@@ -148,11 +129,14 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	}
 
 	private List<Method> getAdvisorMethods(Class<?> aspectClass) {
-		final List<Method> methods = new LinkedList<>();
-		ReflectionUtils.doWithMethods(aspectClass, method -> {
-			// Exclude pointcuts
-			if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) {
-				methods.add(method);
+		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) {
+					methods.add(method);
+				}
 			}
 		});
 		Collections.sort(methods, METHOD_COMPARATOR);
@@ -166,7 +150,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	 * @param introductionField the field to introspect
 	 * @return {@code null} if not an Advisor
 	 */
-	@Nullable
 	private Advisor getDeclareParentsAdvisor(Field introductionField) {
 		DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
 		if (declareParents == null) {
@@ -174,8 +157,10 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 			return null;
 		}
 
-		if (DeclareParents.class == declareParents.defaultImpl()) {
-			throw new IllegalStateException("'defaultImpl' attribute must be set on DeclareParents");
+		if (DeclareParents.class.equals(declareParents.defaultImpl())) {
+			// This is what comes back if it wasn't set. This seems bizarre...
+			// TODO this restriction possibly should be relaxed
+			throw new IllegalStateException("defaultImpl must be set on DeclareParents");
 		}
 
 		return new DeclareParentsAdvisor(
@@ -184,46 +169,38 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 
 
 	@Override
-	@Nullable
-	public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
+	public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif,
 			int declarationOrderInAspect, String aspectName) {
 
-		validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
+		validate(aif.getAspectMetadata().getAspectClass());
 
-		AspectJExpressionPointcut expressionPointcut = getPointcut(
-				candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
-		if (expressionPointcut == null) {
+		AspectJExpressionPointcut ajexp =
+				getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());
+		if (ajexp == null) {
 			return null;
 		}
-
-		return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
-				this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
+		return new InstantiationModelAwarePointcutAdvisorImpl(
+				this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);
 	}
 
-	@Nullable
 	private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
 		AspectJAnnotation<?> aspectJAnnotation =
 				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
 		if (aspectJAnnotation == null) {
 			return null;
 		}
-
 		AspectJExpressionPointcut ajexp =
 				new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class<?>[0]);
 		ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
-		if (this.beanFactory != null) {
-			ajexp.setBeanFactory(this.beanFactory);
-		}
 		return ajexp;
 	}
 
 
 	@Override
-	@Nullable
-	public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
-			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
+	public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut ajexp,
+			MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName) {
 
-		Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
+		Class<?> candidateAspectClass = aif.getAspectMetadata().getAspectClass();
 		validate(candidateAspectClass);
 
 		AspectJAnnotation<?> aspectJAnnotation =
@@ -248,32 +225,27 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 
 		switch (aspectJAnnotation.getAnnotationType()) {
 			case AtBefore:
-				springAdvice = new AspectJMethodBeforeAdvice(
-						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+				springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, ajexp, aif);
 				break;
 			case AtAfter:
-				springAdvice = new AspectJAfterAdvice(
-						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+				springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, ajexp, aif);
 				break;
 			case AtAfterReturning:
-				springAdvice = new AspectJAfterReturningAdvice(
-						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+				springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, ajexp, aif);
 				AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
 				if (StringUtils.hasText(afterReturningAnnotation.returning())) {
 					springAdvice.setReturningName(afterReturningAnnotation.returning());
 				}
 				break;
 			case AtAfterThrowing:
-				springAdvice = new AspectJAfterThrowingAdvice(
-						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+				springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, ajexp, aif);
 				AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
 				if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
 					springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
 				}
 				break;
 			case AtAround:
-				springAdvice = new AspectJAroundAdvice(
-						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
+				springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, ajexp, aif);
 				break;
 			case AtPointcut:
 				if (logger.isDebugEnabled()) {
@@ -282,12 +254,12 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 				return null;
 			default:
 				throw new UnsupportedOperationException(
-						"Unsupported advice type on method: " + candidateAdviceMethod);
+						"Unsupported advice type on method " + candidateAdviceMethod);
 		}
 
 		// Now to configure the advice...
 		springAdvice.setAspectName(aspectName);
-		springAdvice.setDeclarationOrder(declarationOrder);
+		springAdvice.setDeclarationOrder(declarationOrderInAspect);
 		String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
 		if (argNames != null) {
 			springAdvice.setArgumentNamesFromStringArray(argNames);
@@ -296,7 +268,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 		return springAdvice;
 	}
 
-
 	/**
 	 * Synthetic advisor that instantiates the aspect.
 	 * Triggered by per-clause pointcut on non-singleton aspect.
@@ -308,7 +279,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 		public SyntheticInstantiationAdvisor(final MetadataAwareAspectInstanceFactory aif) {
 			super(aif.getAspectMetadata().getPerClausePointcut(), new MethodBeforeAdvice() {
 				@Override
-				public void before(Method method, Object[] args, @Nullable Object target) {
+				public void before(Method method, Object[] args, Object target) {
 					// Simply instantiate the aspect
 					aif.getAspectInstance();
 				}

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/SimpleMetadataAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * 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.
@@ -50,11 +50,6 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 		return this.metadata;
 	}
 
-	@Override
-	public Object getAspectCreationMutex() {
-		return this;
-	}
-
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
 		return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE);

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/SingletonMetadataAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * 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.
@@ -16,8 +16,6 @@
 
 package org.springframework.aop.aspectj.annotation;
 
-import java.io.Serializable;
-
 import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.OrderUtils;
@@ -32,9 +30,8 @@ import org.springframework.core.annotation.OrderUtils;
  * @since 2.0
  * @see SimpleMetadataAwareAspectInstanceFactory
  */
-@SuppressWarnings("serial")
 public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspectInstanceFactory
-		implements MetadataAwareAspectInstanceFactory, Serializable {
+		implements MetadataAwareAspectInstanceFactory {
 
 	private final AspectMetadata metadata;
 
@@ -55,11 +52,6 @@ public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspect
 		return this.metadata;
 	}
 
-	@Override
-	public Object getAspectCreationMutex() {
-		return this;
-	}
-
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
 		return OrderUtils.getOrder(aspectClass, Ordered.LOWEST_PRECEDENCE);

spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/package-info.java

@@ -3,7 +3,4 @@
  *
  * <p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
  */
-@NonNullApi
 package org.springframework.aop.aspectj.annotation;
-
-import org.springframework.lang.NonNullApi;

spring-aop/src/main/java/org/springframework/aop/aspectj/autoproxy/AspectJAwareAdvisorAutoProxyCreator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -68,7 +68,7 @@ public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProx
 	@SuppressWarnings("unchecked")
 	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
 		List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors =
-				new ArrayList<>(advisors.size());
+				new ArrayList<PartiallyComparableAdvisorHolder>(advisors.size());
 		for (Advisor element : advisors) {
 			partiallyComparableAdvisors.add(
 					new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
@@ -76,7 +76,7 @@ public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProx
 		List<PartiallyComparableAdvisorHolder> sorted =
 				PartialOrder.sort(partiallyComparableAdvisors);
 		if (sorted != null) {
-			List<Advisor> result = new ArrayList<>(advisors.size());
+			List<Advisor> result = new ArrayList<Advisor>(advisors.size());
 			for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
 				result.add(pcAdvisor.getAdvisor());
 			}

spring-aop/src/main/java/org/springframework/aop/aspectj/autoproxy/AspectJPrecedenceComparator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -21,7 +21,7 @@ import java.util.Comparator;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.aspectj.AspectJAopUtils;
 import org.springframework.aop.aspectj.AspectJPrecedenceInformation;
-import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.core.OrderComparator;
 import org.springframework.util.Assert;
 
 /**
@@ -62,7 +62,7 @@ class AspectJPrecedenceComparator implements Comparator<Advisor> {
 	 * Create a default AspectJPrecedenceComparator.
 	 */
 	public AspectJPrecedenceComparator() {
-		this.advisorComparator = AnnotationAwareOrderComparator.INSTANCE;
+		this.advisorComparator = OrderComparator.INSTANCE;
 	}
 
 	/**
@@ -132,9 +132,7 @@ class AspectJPrecedenceComparator implements Comparator<Advisor> {
 
 	// pre-condition is that hasAspectName returned true
 	private String getAspectName(Advisor anAdvisor) {
-		AspectJPrecedenceInformation pi = AspectJAopUtils.getAspectJPrecedenceInformationFor(anAdvisor);
-		Assert.state(pi != null, "Unresolvable precedence information");
-		return pi.getAspectName();
+		return AspectJAopUtils.getAspectJPrecedenceInformationFor(anAdvisor).getAspectName();
 	}
 
 	private int getAspectDeclarationOrder(Advisor anAdvisor) {

spring-aop/src/main/java/org/springframework/aop/aspectj/autoproxy/package-info.java

@@ -2,7 +2,4 @@
  * Base classes enabling auto-proxying based on AspectJ.
  * Support for AspectJ annotation aspects resides in the "aspectj.annotation" package.
  */
-@NonNullApi
 package org.springframework.aop.aspectj.autoproxy;
-
-import org.springframework.lang.NonNullApi;

spring-aop/src/main/java/org/springframework/aop/aspectj/package-info.java

@@ -8,7 +8,4 @@
  * 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.
  */
-@NonNullApi
 package org.springframework.aop.aspectj;
-
-import org.springframework.lang.NonNullApi;

spring-aop/src/main/java/org/springframework/aop/config/AbstractInterceptorDrivenBeanDefinitionDecorator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -30,7 +30,6 @@ import org.springframework.beans.factory.support.ManagedList;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.beans.factory.xml.BeanDefinitionDecorator;
 import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
@@ -72,7 +71,7 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 		BeanDefinition interceptorDefinition = createInterceptorDefinition(node);
 
 		// generate name and register the interceptor
-		String interceptorName = existingBeanName + '.' + getInterceptorNameSuffix(interceptorDefinition);
+		String interceptorName = existingBeanName + "." + getInterceptorNameSuffix(interceptorDefinition);
 		BeanDefinitionReaderUtils.registerBeanDefinition(
 				new BeanDefinitionHolder(interceptorDefinition, interceptorName), registry);
 
@@ -106,8 +105,8 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 
 	@SuppressWarnings("unchecked")
 	private void addInterceptorNameToList(String interceptorName, BeanDefinition beanDefinition) {
-		List<String> list = (List<String>) beanDefinition.getPropertyValues().get("interceptorNames");
-		Assert.state(list != null, "Missing 'interceptorNames' property");
+		List<String> list = (List<String>)
+				beanDefinition.getPropertyValues().getPropertyValue("interceptorNames").getValue();
 		list.add(interceptorName);
 	}
 
@@ -116,9 +115,7 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 	}
 
 	protected String getInterceptorNameSuffix(BeanDefinition interceptorDefinition) {
-		String beanClassName = interceptorDefinition.getBeanClassName();
-		return (StringUtils.hasLength(beanClassName) ?
-				StringUtils.uncapitalize(ClassUtils.getShortName(beanClassName)) : "");
+		return StringUtils.uncapitalize(ClassUtils.getShortName(interceptorDefinition.getBeanClassName()));
 	}
 
 	/**

spring-aop/src/main/java/org/springframework/aop/config/AdvisorComponentDefinition.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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,13 +20,12 @@ import org.springframework.beans.MutablePropertyValues;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanReference;
 import org.springframework.beans.factory.parsing.AbstractComponentDefinition;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
  * {@link org.springframework.beans.factory.parsing.ComponentDefinition}
  * that bridges the gap between the advisor bean definition configured
- * by the {@code <aop:advisor>} tag and the component definition
+ * by the {@code &lt;aop:advisor&gt;} tag and the component definition
  * infrastructure.
  *
  * @author Rob Harrop
@@ -39,11 +38,11 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 
 	private final BeanDefinition advisorDefinition;
 
-	private final String description;
+	private String description;
 
-	private final BeanReference[] beanReferences;
+	private BeanReference[] beanReferences;
 
-	private final BeanDefinition[] beanDefinitions;
+	private BeanDefinition[] beanDefinitions;
 
 
 	public AdvisorComponentDefinition(String advisorBeanName, BeanDefinition advisorDefinition) {
@@ -51,16 +50,19 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 	}
 
 	public AdvisorComponentDefinition(
-			String advisorBeanName, BeanDefinition advisorDefinition, @Nullable BeanDefinition pointcutDefinition) {
+			String advisorBeanName, BeanDefinition advisorDefinition, BeanDefinition pointcutDefinition) {
 
 		Assert.notNull(advisorBeanName, "'advisorBeanName' must not be null");
 		Assert.notNull(advisorDefinition, "'advisorDefinition' must not be null");
 		this.advisorBeanName = advisorBeanName;
 		this.advisorDefinition = advisorDefinition;
+		unwrapDefinitions(advisorDefinition, pointcutDefinition);
+	}
 
+
+	private void unwrapDefinitions(BeanDefinition advisorDefinition, BeanDefinition pointcutDefinition) {
 		MutablePropertyValues pvs = advisorDefinition.getPropertyValues();
-		BeanReference adviceReference = (BeanReference) pvs.get("adviceBeanName");
-		Assert.state(adviceReference != null, "Missing 'adviceBeanName' property");
+		BeanReference adviceReference = (BeanReference) pvs.getPropertyValue("adviceBeanName").getValue();
 
 		if (pointcutDefinition != null) {
 			this.beanReferences = new BeanReference[] {adviceReference};
@@ -68,8 +70,7 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 			this.description = buildDescription(adviceReference, pointcutDefinition);
 		}
 		else {
-			BeanReference pointcutReference = (BeanReference) pvs.get("pointcut");
-			Assert.state(pointcutReference != null, "Missing 'pointcut' property");
+			BeanReference pointcutReference = (BeanReference) pvs.getPropertyValue("pointcut").getValue();
 			this.beanReferences = new BeanReference[] {adviceReference, pointcutReference};
 			this.beanDefinitions = new BeanDefinition[] {advisorDefinition};
 			this.description = buildDescription(adviceReference, pointcutReference);
@@ -77,15 +78,16 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 	}
 
 	private String buildDescription(BeanReference adviceReference, BeanDefinition pointcutDefinition) {
-		return "Advisor <advice(ref)='" +
-				adviceReference.getBeanName() + "', pointcut(expression)=[" +
-				pointcutDefinition.getPropertyValues().get("expression") + "]>";
+		return new StringBuilder("Advisor <advice(ref)='").
+				append(adviceReference.getBeanName()).append("', pointcut(expression)=[").
+				append(pointcutDefinition.getPropertyValues().getPropertyValue("expression").getValue()).
+				append("]>").toString();
 	}
 
 	private String buildDescription(BeanReference adviceReference, BeanReference pointcutReference) {
-		return "Advisor <advice(ref)='" +
-				adviceReference.getBeanName() + "', pointcut(ref)='" +
-				pointcutReference.getBeanName() + "'>";
+		return new StringBuilder("Advisor <advice(ref)='").
+				append(adviceReference.getBeanName()).append("', pointcut(ref)='").
+				append(pointcutReference.getBeanName()).append("'>").toString();
 	}
 
 
@@ -110,7 +112,6 @@ public class AdvisorComponentDefinition extends AbstractComponentDefinition {
 	}
 
 	@Override
-	@Nullable
 	public Object getSource() {
 		return this.advisorDefinition.getSource();
 	}

spring-aop/src/main/java/org/springframework/aop/config/AopConfigUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -26,7 +26,6 @@ import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -55,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<>();
+	private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<Class<?>>();
 
 	/**
 	 * Setup the escalation list.
@@ -67,39 +66,27 @@ public abstract class AopConfigUtils {
 	}
 
 
-	@Nullable
 	public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
 		return registerAutoProxyCreatorIfNecessary(registry, null);
 	}
 
-	@Nullable
-	public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
-			@Nullable Object source) {
-
+	public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
 		return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
 	}
 
-	@Nullable
 	public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
 		return registerAspectJAutoProxyCreatorIfNecessary(registry, null);
 	}
 
-	@Nullable
-	public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
-			@Nullable Object source) {
-
+	public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
 		return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
 	}
 
-	@Nullable
 	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
 		return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
 	}
 
-	@Nullable
-	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
-			@Nullable Object source) {
-
+	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
 		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
 	}
 
@@ -110,19 +97,16 @@ public abstract class AopConfigUtils {
 		}
 	}
 
-	public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
+	static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
 		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
 			BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
 			definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
 		}
 	}
 
-	@Nullable
-	private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
-			@Nullable 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);
 			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
@@ -134,7 +118,6 @@ public abstract class AopConfigUtils {
 			}
 			return null;
 		}
-
 		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
 		beanDefinition.setSource(source);
 		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
@@ -147,7 +130,7 @@ public abstract class AopConfigUtils {
 		return APC_PRIORITY_LIST.indexOf(clazz);
 	}
 
-	private static int findPriorityForClass(@Nullable String className) {
+	private static int findPriorityForClass(String className) {
 		for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
 			Class<?> clazz = APC_PRIORITY_LIST.get(i);
 			if (clazz.getName().equals(className)) {

spring-aop/src/main/java/org/springframework/aop/config/AopNamespaceHandler.java

@@ -24,7 +24,7 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
  * {@code NamespaceHandler} for the {@code aop} namespace.
  *
  * <p>Provides a {@link org.springframework.beans.factory.xml.BeanDefinitionParser} for the
- * {@code <aop:config>} tag. A {@code config} tag can include nested
+ * {@code &lt;aop:config&gt;} tag. A {@code config} tag can include nested
  * {@code pointcut}, {@code advisor} and {@code aspect} tags.
  *
  * <p>The {@code pointcut} tag allows for creation of named

spring-aop/src/main/java/org/springframework/aop/config/AopNamespaceUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -22,7 +22,6 @@ import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.lang.Nullable;
 
 /**
  * Utility class for handling registration of auto-proxy creators used internally
@@ -80,7 +79,7 @@ public abstract class AopNamespaceUtils {
 		registerComponentIfNecessary(beanDefinition, parserContext);
 	}
 
-	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
+	private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
 		if (sourceElement != null) {
 			boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
 			if (proxyTargetClass) {
@@ -93,7 +92,7 @@ public abstract class AopNamespaceUtils {
 		}
 	}
 
-	private static void registerComponentIfNecessary(@Nullable BeanDefinition beanDefinition, ParserContext parserContext) {
+	private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
 		if (beanDefinition != null) {
 			BeanComponentDefinition componentDefinition =
 					new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);

spring-aop/src/main/java/org/springframework/aop/config/AspectComponentDefinition.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2007 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,6 @@ package org.springframework.aop.config;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanReference;
 import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
-import org.springframework.lang.Nullable;
 
 /**
  * {@link org.springframework.beans.factory.parsing.ComponentDefinition}
@@ -38,8 +37,8 @@ public class AspectComponentDefinition extends CompositeComponentDefinition {
 	private final BeanReference[] beanReferences;
 
 
-	public AspectComponentDefinition(String aspectName, @Nullable BeanDefinition[] beanDefinitions,
-			@Nullable BeanReference[] beanReferences, @Nullable Object source) {
+	public AspectComponentDefinition(
+			String aspectName, BeanDefinition[] beanDefinitions, BeanReference[] beanReferences, Object source) {
 
 		super(aspectName, source);
 		this.beanDefinitions = (beanDefinitions != null ? beanDefinitions : new BeanDefinition[0]);

spring-aop/src/main/java/org/springframework/aop/config/AspectJAutoProxyBeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -25,7 +25,6 @@ import org.springframework.beans.factory.config.TypedStringValue;
 import org.springframework.beans.factory.support.ManagedList;
 import org.springframework.beans.factory.xml.BeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.lang.Nullable;
 
 /**
  * {@link BeanDefinitionParser} for the {@code aspectj-autoproxy} tag,
@@ -39,7 +38,6 @@ import org.springframework.lang.Nullable;
 class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
 
 	@Override
-	@Nullable
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
 		extendBeanDefinition(element, parserContext);
@@ -55,7 +53,7 @@ class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
-		ManagedList<TypedStringValue> includePatterns = new ManagedList<>();
+		ManagedList<TypedStringValue> includePatterns = new ManagedList<TypedStringValue>();
 		NodeList childNodes = element.getChildNodes();
 		for (int i = 0; i < childNodes.getLength(); i++) {
 			Node node = childNodes.item(i);

spring-aop/src/main/java/org/springframework/aop/config/ConfigBeanDefinitionParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 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.
@@ -45,12 +45,11 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.beans.factory.xml.BeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 import org.springframework.util.xml.DomUtils;
 
 /**
- * {@link BeanDefinitionParser} for the {@code <aop:config>} tag.
+ * {@link BeanDefinitionParser} for the {@code &lt;aop:config&gt;} tag.
  *
  * @author Rob Harrop
  * @author Juergen Hoeller
@@ -97,7 +96,6 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 
 	@Override
-	@Nullable
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		CompositeComponentDefinition compositeDef =
 				new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
@@ -125,7 +123,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 	/**
 	 * Configures the auto proxy creator needed to support the {@link BeanDefinition BeanDefinitions}
-	 * created by the '{@code <aop:config/>}' tag. Will force class proxying if the
+	 * created by the '{@code &lt;aop:config/&gt;}' tag. Will force class proxying if the
 	 * '{@code proxy-target-class}' attribute is set to '{@code true}'.
 	 * @see AopNamespaceUtils
 	 */
@@ -134,7 +132,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses the supplied {@code <advisor>} element and registers the resulting
+	 * Parses the supplied {@code &lt;advisor&gt;} element and registers the resulting
 	 * {@link org.springframework.aop.Advisor} and any resulting {@link org.springframework.aop.Pointcut}
 	 * with the supplied {@link BeanDefinitionRegistry}.
 	 */
@@ -201,8 +199,8 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 		try {
 			this.parseState.push(new AspectEntry(aspectId, aspectName));
-			List<BeanDefinition> beanDefinitions = new ArrayList<>();
-			List<BeanReference> beanReferences = new ArrayList<>();
+			List<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
+			List<BeanReference> beanReferences = new ArrayList<BeanReference>();
 
 			List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
 			for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
@@ -430,7 +428,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses the supplied {@code <pointcut>} and registers the resulting
+	 * Parses the supplied {@code &lt;pointcut&gt;} and registers the resulting
 	 * Pointcut with the BeanDefinitionRegistry.
 	 */
 	private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
@@ -468,7 +466,6 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	 * {@link org.springframework.beans.factory.config.BeanDefinition} for the pointcut if  necessary
 	 * and returns its bean name, otherwise returns the bean name of the referred pointcut.
 	 */
-	@Nullable
 	private Object parsePointcutProperty(Element element, ParserContext parserContext) {
 		if (element.hasAttribute(POINTCUT) && element.hasAttribute(POINTCUT_REF)) {
 			parserContext.getReaderContext().error(

spring-aop/src/main/java/org/springframework/aop/config/MethodLocatingFactoryBean.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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.
@@ -22,7 +22,6 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.FactoryBean;
-import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 /**
@@ -33,13 +32,10 @@ import org.springframework.util.StringUtils;
  */
 public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFactoryAware {
 
-	@Nullable
 	private String targetBeanName;
 
-	@Nullable
 	private String methodName;
 
-	@Nullable
 	private Method method;
 
 
@@ -84,7 +80,6 @@ public class MethodLocatingFactoryBean implements FactoryBean<Method>, BeanFacto
 
 
 	@Override
-	@Nullable
 	public Method getObject() throws Exception {
 		return this.method;
 	}

spring-aop/src/main/java/org/springframework/aop/config/PointcutComponentDefinition.java

@@ -18,7 +18,6 @@ package org.springframework.aop.config;
 
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.parsing.AbstractComponentDefinition;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -63,7 +62,6 @@ public class PointcutComponentDefinition extends AbstractComponentDefinition {
 	}
 
 	@Override
-	@Nullable
 	public Object getSource() {
 		return this.pointcutDefinition.getSource();
 	}

spring-aop/src/main/java/org/springframework/aop/config/ScopedProxyBeanDefinitionDecorator.java

@@ -27,7 +27,7 @@ import org.springframework.beans.factory.xml.ParserContext;
 
 /**
  * {@link BeanDefinitionDecorator} responsible for parsing the
- * {@code <aop:scoped-proxy/>} tag.
+ * {@code &lt;aop:scoped-proxy/&gt;} tag.
  *
  * @author Rob Harrop
  * @author Juergen Hoeller

spring-aop/src/main/java/org/springframework/aop/config/SimpleBeanFactoryAwareAspectInstanceFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 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,9 +21,8 @@ import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.core.Ordered;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
+import org.springframework.util.StringUtils;
 
 /**
  * Implementation of {@link AspectInstanceFactory} that locates the aspect from the
@@ -35,10 +34,8 @@ import org.springframework.util.ClassUtils;
  */
 public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstanceFactory, BeanFactoryAware {
 
-	@Nullable
 	private String aspectBeanName;
 
-	@Nullable
 	private BeanFactory beanFactory;
 
 
@@ -53,7 +50,9 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 	@Override
 	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
-		Assert.notNull(this.aspectBeanName, "'aspectBeanName' is required");
+		if (!StringUtils.hasText(this.aspectBeanName)) {
+			throw new IllegalArgumentException("'aspectBeanName' is required");
+		}
 	}
 
 
@@ -63,13 +62,10 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 	 */
 	@Override
 	public Object getAspectInstance() {
-		Assert.state(this.beanFactory != null, "No BeanFactory set");
-		Assert.state(this.aspectBeanName != null, "No 'aspectBeanName' set");
 		return this.beanFactory.getBean(this.aspectBeanName);
 	}
 
 	@Override
-	@Nullable
 	public ClassLoader getAspectClassLoader() {
 		if (this.beanFactory instanceof ConfigurableBeanFactory) {
 			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
@@ -81,8 +77,7 @@ public class SimpleBeanFactoryAwareAspectInstanceFactory implements AspectInstan
 
 	@Override
 	public int getOrder() {
-		if (this.beanFactory != null && this.aspectBeanName != null &&
-				this.beanFactory.isSingleton(this.aspectBeanName) &&
+		if (this.beanFactory.isSingleton(this.aspectBeanName) &&
 				this.beanFactory.isTypeMatch(this.aspectBeanName, Ordered.class)) {
 			return ((Ordered) this.beanFactory.getBean(this.aspectBeanName)).getOrder();
 		}

spring-aop/src/main/java/org/springframework/aop/config/package-info.java

@@ -2,7 +2,4 @@
  * Support package for declarative AOP configuration,
  * with XML schema being the primary configuration format.
  */
-@NonNullApi
 package org.springframework.aop.config;
-
-import org.springframework.lang.NonNullApi;

spring-aop/src/main/java/org/springframework/aop/framework/AbstractAdvisingBeanPostProcessor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * 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.
@@ -22,7 +22,6 @@ import java.util.concurrent.ConcurrentHashMap;
 import org.springframework.aop.Advisor;
 import org.springframework.aop.support.AopUtils;
 import org.springframework.beans.factory.config.BeanPostProcessor;
-import org.springframework.lang.Nullable;
 
 /**
  * Base class for {@link BeanPostProcessor} implementations that apply a
@@ -34,12 +33,11 @@ import org.springframework.lang.Nullable;
 @SuppressWarnings("serial")
 public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSupport implements BeanPostProcessor {
 
-	@Nullable
 	protected Advisor advisor;
 
 	protected boolean beforeExistingAdvisors = false;
 
-	private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<>(256);
+	private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<Class<?>, Boolean>(64);
 
 
 	/**
@@ -63,7 +61,7 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 
 	@Override
 	public Object postProcessAfterInitialization(Object bean, String beanName) {
-		if (bean instanceof AopInfrastructureBean || this.advisor == null) {
+		if (bean instanceof AopInfrastructureBean) {
 			// Ignore AOP infrastructure such as scoped proxies.
 			return bean;
 		}
@@ -83,12 +81,13 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 		}
 
 		if (isEligible(bean, beanName)) {
-			ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
+			ProxyFactory proxyFactory = new ProxyFactory();
+			proxyFactory.copyFrom(this);
+			proxyFactory.setTarget(bean);
 			if (!proxyFactory.isProxyTargetClass()) {
 				evaluateProxyInterfaces(bean.getClass(), proxyFactory);
 			}
 			proxyFactory.addAdvisor(this.advisor);
-			customizeProxyFactory(proxyFactory);
 			return proxyFactory.getProxy(getProxyClassLoader());
 		}
 
@@ -127,46 +126,9 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyProcessorSu
 		if (eligible != null) {
 			return eligible;
 		}
-		if (this.advisor == null) {
-			return false;
-		}
 		eligible = AopUtils.canApply(this.advisor, targetClass);
 		this.eligibleBeans.put(targetClass, eligible);
 		return eligible;
 	}
 
-	/**
-	 * Prepare a {@link ProxyFactory} for the given bean.
-	 * <p>Subclasses may customize the handling of the target instance and in
-	 * particular the exposure of the target class. The default introspection
-	 * of interfaces for non-target-class proxies and the configured advisor
-	 * will be applied afterwards; {@link #customizeProxyFactory} allows for
-	 * late customizations of those parts right before proxy creation.
-	 * @param bean the bean instance to create a proxy for
-	 * @param beanName the corresponding bean name
-	 * @return the ProxyFactory, initialized with this processor's
-	 * {@link ProxyConfig} settings and the specified bean
-	 * @since 4.2.3
-	 * @see #customizeProxyFactory
-	 */
-	protected ProxyFactory prepareProxyFactory(Object bean, String beanName) {
-		ProxyFactory proxyFactory = new ProxyFactory();
-		proxyFactory.copyFrom(this);
-		proxyFactory.setTarget(bean);
-		return proxyFactory;
-	}
-
-	/**
-	 * Subclasses may choose to implement this: for example,
-	 * to change the interfaces exposed.
-	 * <p>The default implementation is empty.
-	 * @param proxyFactory ProxyFactory that is already configured with
-	 * target, advisor and interfaces and will be used to create the proxy
-	 * immediately after this method returns
-	 * @since 4.2.3
-	 * @see #prepareProxyFactory
-	 */
-	protected void customizeProxyFactory(ProxyFactory proxyFactory) {
-	}
-
 }