Consistent local vs external resolution of https schema references

Co-Authored-By: Sam Brannen <sbrannen@pivotal.io>

See gh-22504

.gitignore

@@ -10,17 +10,27 @@ integration-repo
 ivy-cache
 jxl.log
 jmx.log
-spring-jdbc/derby.log
+derby.log
 spring-test/test-output/
 .gradle
-build
-.classpath
-.project
 argfile*
 pom.xml
 
-# IDEA metadata and output dirs
+/build
+buildSrc/build
+/spring-*/build
+target/
+
+# Eclipse artifacts, including WTP generated manifests
+.classpath
+.project
+spring-*/src/main/java/META-INF/MANIFEST.MF
+
+# IDEA artifacts and output dirs
 *.iml
 *.ipr
 *.iws
+.idea
 out
+test-output
+atlassian-ide-plugin.xml

.mailmap

@@ -0,0 +1,14 @@
+Juergen Hoeller <jhoeller@vmware.com> jhoeller <jhoeller@vmware.com>
+<rstoyanchev@gopivotal.com> <rstoyanchev@vmware.com>
+<pwebb@gopivotal.com> <pwebb@vmware.com>
+<cbeams@gopivotal.com> <cbeams@vmware.com>
+<cbeams@gopivotal.com> <cbeams@gmail.com>
+<apoutsma@gopivotal.com> <apoutsma@vmware.com>
+<apoutsma@gopivotal.com> <poutsma@mac.com>
+<ogierke@gopivotal.com> <ogierke@vmware.com>
+<dsyer@gopivotal.com> <david_syer@hotmail.com>
+<dsyer@gopivotal.com> <dsyer@vmware.com>
+<aclement@gopivotal.com> <andrew.clement@gmail.com>
+<aclement@gopivotal.com> <aclement@vmware.com>
+<dmitry.katsubo@gmail.com> <dmitry.katsubo@gmai.com>
+Nick Williams <nicholas@nicholaswilliams.net> Nicholas Williams <nicholas@nicholaswilliams.net> 

CONTRIBUTING.md

@@ -19,45 +19,33 @@ in our [JIRA issue tracker][] to see if you can find something similar. If not,
 please create a new issue before submitting a pull request unless the change is
 truly trivial, e.g. typo fixes, removing compiler warnings, etc.
 
-## Discuss non-trivial contribution ideas with committers
-
-If you're considering anything more than correcting a typo or fixing a minor
-bug, please discuss it on the [spring-framework-contrib][] mailing list before
-submitting a pull request. We're happy to provide guidance but please spend an
-hour or two researching the subject on your own including searching the mailing
-list for prior discussions.
-
 ## Sign the Contributor License Agreement
 
 If you have not previously done so, please fill out and submit the
 [SpringSource CLA form][]. You'll receive a token when this process is complete.
-Keep track of this, you may be asked for it later!
+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.
 
-When you've completed the web form, simply add the following in a comment on
+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 statement above to all
-future pull requests as well, simply so the Spring Framework team knows
+future pull requests as well, simply so that the Spring Framework team knows
 immediately that this process is complete.
 
 
-## Create your branch from `master`
+## Create your branch from `3.2.x`
 
-At any given time, Spring Framework's `master` branch represents the version
-currently under development. For example, if 3.1.1 was the latest Spring
-Framework release, `master` represents 3.2.0 development, and the `3.1.x`
-branch represents 3.1.2 development.
-
-Create your topic branch to be submitted as a pull request from `master`. The
-Spring team will consider your pull request for backporting to maintenance
-versions (e.g. 3.1.2) on a case-by-case basis; you don't need to worry about
-submitting anything for backporting.
+If your pull request addresses a bug or improvement, please create your branch
+from Spring Framework's `3.2.x` branch. `master` is reserved for work on new features
+for the next major version of the framework. Rest assured that if your pull
+request is accepted and merged into `3.2.x`, these changes will also eventually
+be merged into `master`.
 
 
 ## Use short branch names
@@ -76,7 +64,7 @@ Please carefully follow the whitespace and formatting conventions already
 present in the framework.
 
 1. Tabs, not spaces
-1. Unix (LF), not dos (CRLF) line endings
+1. Unix (LF), not DOS (CRLF) line endings
 1. Eliminate all trailing whitespace
 1. Wrap Javadoc at 90 characters
 1. Aim to wrap code at 90 characters, but favor readability over wrapping
@@ -91,13 +79,13 @@ present in the framework.
 
 ```java
 /*
- * Copyright 2002-2012 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -112,16 +100,16 @@ package ...;
 ## Update Apache license header to modified files as necessary
 
 Always check the date range in the license header. For example, if you've
-modified a file in 2012 whose header still reads
+modified a file in 2013 whose header still reads
 
 ```java
  * Copyright 2002-2011 the original author or authors.
 ```
 
-then be sure to update it to 2012 appropriately
+then be sure to update it to 2013 appropriately
 
 ```java
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2013 the original author or authors.
 ```
 
 ## Use @since tags for newly-added public API types and methods
@@ -172,7 +160,7 @@ public class Spr8954Tests {
 Use `git rebase --interactive`, `git add --patch` and other tools to "squash"
 multiple commits into atomic changes. In addition to the man pages for git,
 there are many resources online to help you understand how these tools work.
-Here is one: http://book.git-scm.com/4_interactive_rebasing.html.
+Here is one: https://book.git-scm.com/4_interactive_rebasing.html.
 
 
 ## Use real name in git commits
@@ -232,11 +220,11 @@ Most importantly, please format your commit messages in the following way
 
 1. Use imperative statements in the subject line, e.g. "Fix broken Javadoc link"
 1. Begin the subject line sentence with a capitalized verb, e.g. "Add, Prune,
-   Fix, Introduce, Avoid, etc"
+   Fix, Introduce, Avoid, etc."
 1. Do not end the subject line with a period
 1. Keep the subject line to 50 characters or less if possible
 1. Wrap lines in the body at 72 characters or less
-1. Mention associated jira issue(s) at the end of the commit comment, prefixed
+1. Mention associated JIRA issue(s) at the end of the commit comment, prefixed
    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
@@ -298,10 +286,10 @@ Note that you can always force push (`git push -f`) reworked / rebased commits
 against the branch used to submit your pull request. i.e. you do not need to
 issue a new pull request when asked to make changes.
 
-[help documentation]: http://help.github.com/send-pull-requests
+[help documentation]: https://help.github.com/send-pull-requests
 [JIRA issue tracker]: https://jira.springsource.org/browse/SPR
 [spring-framework-contrib]: https://groups.google.com/forum/#!forum/spring-framework-contrib
 [SpringSource CLA form]: https://support.springsource.com/spring_committer_signup
 [fork-and-edit]: https://github.com/blog/844-forking-with-the-edit-button
-[commit guidelines section of Pro Git]: http://progit.org/book/ch5-2.html#commit_guidelines
+[commit guidelines section of Pro Git]: https://progit.org/book/ch5-2.html#commit_guidelines
 [building from source]: https://github.com/SpringSource/spring-framework#building-from-source

README.md

@@ -66,31 +66,31 @@ The Spring Framework is released under version 2.0 of the [Apache License][].
 
 [Spring Integration]: https://github.com/SpringSource/spring-integration
 [Spring Batch]: https://github.com/SpringSource/spring-batch
-[family of projects]: http://springsource.org/projects
+[family of projects]: https://springsource.org/projects
 [SpringSource organization]: https://github.com/SpringSource
 [.NET]: https://github.com/SpringSource/spring-net
 [Python]: https://github.com/SpringSource/spring-python
 [downloading Spring artifacts]: https://github.com/SpringSource/spring-framework/wiki/Downloading-Spring-artifacts
 [building a distribution with dependencies]: https://github.com/SpringSource/spring-framework/wiki/Building-a-distribution-with-dependencies
-[Javadoc]: http://static.springsource.org/spring-framework/docs/current/javadoc-api
-[reference docs]: http://static.springsource.org/spring-framework/docs/current/spring-framework-reference
-[Spring forums]: http://forum.springsource.org
-[spring tag]: http://stackoverflow.com/questions/tagged/spring
-[spring-mvc tag]: http://stackoverflow.com/questions/tagged/spring-mvc
-[Stack Overflow]: http://stackoverflow.com/faq
-[Commercial support]: http://springsource.com/support/springsupport
-[Spring Framework JIRA]: http://jira.springsource.org/browse/SPR
+[Javadoc]: https://docs.spring.io/spring-framework/docs/current/javadoc-api
+[reference docs]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference
+[Spring forums]: https://forum.spring.io/
+[spring tag]: https://stackoverflow.com/questions/tagged/spring
+[spring-mvc tag]: https://stackoverflow.com/questions/tagged/spring-mvc
+[Stack Overflow]: https://stackoverflow.com/faq
+[Commercial support]: https://springsource.com/support/springsupport
+[Spring Framework JIRA]: https://jira.springsource.org/browse/SPR
 [the lifecycle of an issue]: https://github.com/cbeams/spring-framework/wiki/The-Lifecycle-of-an-Issue
 [spring-framework-issues]: https://github.com/SpringSource/spring-framework-issues#readme
 [readme]: https://github.com/SpringSource/spring-framework-issues#readme
-[Gradle]: http://gradle.org
-[`./gradlew`]: http://vimeo.com/34436402
-[Git]: http://help.github.com/set-up-git-redirect
+[Gradle]: https://gradle.org
+[`./gradlew`]: https://vimeo.com/34436402
+[Git]: https://help.github.com/set-up-git-redirect
 [Gradle build and release FAQ]: https://github.com/SpringSource/spring-framework/wiki/Gradle-build-and-release-FAQ
-[Pull requests]: http://help.github.com/send-pull-requests
+[Pull requests]: https://help.github.com/send-pull-requests
 [contributor guidelines]: https://github.com/SpringSource/spring-framework/blob/master/CONTRIBUTING.md
-[@springframework]: http://twitter.com/springframework
-[team members]: http://twitter.com/springframework/team/members
-[team blog]: http://blog.springsource.org
-[news feed]: http://www.springsource.org/news-events
-[Apache License]: http://www.apache.org/licenses/LICENSE-2.0
+[@springframework]: https://twitter.com/springframework
+[team members]: https://twitter.com/springframework/team/members
+[team blog]: https://blog.springsource.org
+[news feed]: https://www.springsource.org/news-events
+[Apache License]: https://www.apache.org/licenses/LICENSE-2.0

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -14,27 +14,24 @@
  * limitations under the License.
  */
 
-package org.springframework.build.gradle.merge
+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.api.tasks.*
 import org.gradle.plugins.ide.eclipse.EclipsePlugin
-import org.gradle.plugins.ide.eclipse.model.EclipseClasspath;
 import org.gradle.plugins.ide.idea.IdeaPlugin
 import org.gradle.api.invocation.*
 
-
 /**
  * Gradle plugin that allows projects to merged together. Primarily developed to
- * allow Spring to support multiple multiple incompatible versions of third-party
+ * 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>
+ * <pre class="code">
  * configure(subprojects) {
  *     apply plugin: MergePlugin
  * }
@@ -67,22 +64,22 @@ class MergePlugin implements Plugin<Project> {
 		project.plugins.apply(IdeaPlugin)
 
 		MergeModel model = project.extensions.create("merge", MergeModel)
-		project.configurations.add("merging")
-		Configuration runtimeMerge = project.configurations.add("runtimeMerge")
+		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
+		project.eclipse.classpath.plusConfigurations += [ runtimeMerge ]
+		project.idea.module.scopes.PROVIDED.plus += [ runtimeMerge ]
 
 		// Hook to perform the actual merge logic
 		project.afterEvaluate{
-			if(it.merge.into != null) {
+			if (it.merge.into != null) {
 				setup(it)
 			}
 		}
 
 		// Hook to build runtimeMerge dependencies
-		if(!attachedProjectsEvaluated) {
+		if (!attachedProjectsEvaluated) {
 			project.gradle.projectsEvaluated{
 				postProcessProjects(it)
 			}
@@ -102,7 +99,7 @@ class MergePlugin implements Plugin<Project> {
 		// invoking a task will invoke the task with the same name on 'into' project
 		["sourcesJar", "jar", "javadocJar", "javadoc", "install", "artifactoryPublish"].each {
 			def task = project.tasks.findByPath(it)
-			if(task) {
+			if (task) {
 				task.enabled = false
 				task.dependsOn(project.merge.into.tasks.findByPath(it))
 			}
@@ -110,7 +107,7 @@ class MergePlugin implements Plugin<Project> {
 
 		// update 'into' project artifacts to contain the source artifact contents
 		project.merge.into.sourcesJar.from(project.sourcesJar.source)
-		project.merge.into.jar.from(project.jar.source)
+		project.merge.into.jar.from(project.sourceSets.main.output)
 		project.merge.into.javadoc {
 			source += project.javadoc.source
 			classpath += project.javadoc.classpath
@@ -120,17 +117,24 @@ class MergePlugin implements Plugin<Project> {
 	private void setupMaven(Project project) {
 		project.configurations.each { configuration ->
 			Conf2ScopeMapping mapping = project.conf2ScopeMappings.getMapping([configuration])
-			if(mapping.scope) {
-				Configuration intoConfiguration = project.merge.into.configurations.add(
+			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])
 				}
-				intoConfiguration.dependencies.addAll(configuration.dependencies)
+				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)
+					}
+				}
+				def index = project.parent.childProjects.findIndexOf {p -> p.getValue() == project}
 				project.merge.into.install.repositories.mavenInstaller.pom.scopeMappings.addMapping(
-					mapping.priority + 100, intoConfiguration, mapping.scope)
+					mapping.priority + 100 + index, intoConfiguration, mapping.scope)
 			}
 		}
 	}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2002-2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.build.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ProjectDependency;
+
+/**
+ * Gradle plugin that automatically updates testCompile dependencies to include
+ * the test source sets of project dependencies.
+ *
+ * @author Phillip Webb
+ */
+class TestSourceSetDependenciesPlugin implements Plugin<Project> {
+
+	@Override
+	public void apply(Project project) {
+		project.afterEvaluate {
+			Set<ProjectDependency> projectDependencies = new LinkedHashSet<ProjectDependency>()
+			collectProjectDependencies(projectDependencies, project)
+			projectDependencies.each {
+				project.dependencies.add("testCompile", it.dependencyProject.sourceSets.test.output)
+			}
+		}
+	}
+
+	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
+		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
+			Configuration configuration = project.getConfigurations().findByName(configurationName)
+			if (configuration) {
+				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
+					projectDependencies.add(it)
+					collectProjectDependencies(projectDependencies, it.dependencyProject)
+				}
+			}
+		}
+	}
+
+}

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

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

buildSrc/src/main/resources/META-INF/gradle-plugins/test-source-set-dependencies.properties

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

gradle.properties

@@ -1 +1 @@
-version=3.2.0.RELEASE
+version=3.2.19.BUILD-SNAPSHOT

gradle/ide.gradle

@@ -1,7 +1,12 @@
 import org.gradle.plugins.ide.eclipse.model.ProjectDependency
+import org.gradle.plugins.ide.eclipse.model.SourceFolder
 
+
+apply plugin: "propdeps-eclipse"
+apply plugin: "propdeps-idea"
+
+// Replace classpath entries with project dependencies (GRADLE-1116)
 eclipse.classpath.file.whenMerged { classpath ->
-	// GRADLE-1116
 	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 ->
@@ -19,3 +24,87 @@ eclipse.classpath.file.whenMerged { classpath ->
 	}
 	classpath.entries.removeAll { entry -> (entry.path =~ /(?!.*?repack.*\.jar).*?\/([^\/]+)\/build\/libs\/[^\/]+\.jar/) }
 }
+
+
+// Use separate main/test outputs (prevents WTP from packaging test classes)
+eclipse.classpath.defaultOutputDir = file(project.name+"/bin/eclipse")
+eclipse.classpath.file.beforeMerged { classpath ->
+	classpath.entries.findAll{ it instanceof SourceFolder }.each {
+		if(it.output.startsWith("bin/")) {
+			it.output = null
+		}
+	}
+}
+eclipse.classpath.file.whenMerged { classpath ->
+	classpath.entries.findAll{ it instanceof SourceFolder }.each {
+		it.output = "bin/" + it.path.split("/")[1]
+	}
+}
+
+// Ensure project dependencies come after 3rd-party libs (SPR-11836)
+// https://jira.spring.io/browse/SPR-11836
+eclipse.classpath.file.whenMerged { classpath ->
+	classpath.entries.findAll { it instanceof ProjectDependency }.each {
+		// delete from original position
+		classpath.entries.remove(it)
+		// append to end of classpath
+		classpath.entries.add(it)
+	}
+}
+
+// Allow projects to be used as WPT modules
+eclipse.project.natures "org.eclipse.wst.common.project.facet.core.nature"
+
+
+// Include project specific settings
+task eclipseSettings(type: Copy) {
+	from rootProject.files(
+		"src/eclipse/org.eclipse.jdt.ui.prefs",
+		"src/eclipse/org.eclipse.wst.common.project.facet.core.xml")
+	into project.file('.settings/')
+	outputs.upToDateWhen { false }
+}
+
+task eclipseWstComponent(type: Copy) {
+	from rootProject.files(
+		"src/eclipse/org.eclipse.wst.common.component")
+	into project.file('.settings/')
+	expand(deployname: project.name)
+	outputs.upToDateWhen { false }
+}
+
+task eclipseJdtPrepare(type: Copy) {
+	from rootProject.file("src/eclipse/org.eclipse.jdt.core.prefs")
+	into project.file(".settings/")
+	outputs.upToDateWhen { false }
+}
+
+task cleanEclipseJdtUi(type: Delete) {
+	delete project.file(".settings/org.eclipse.jdt.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")
+}
+
+tasks["eclipseJdt"].dependsOn(eclipseJdtPrepare)
+tasks["cleanEclipse"].dependsOn(cleanEclipseJdtUi)
+tasks["eclipse"].dependsOn(eclipseSettings, eclipseWstComponent)
+
+
+// Filter 'build' folder
+
+eclipse.project.file.withXml {
+	def node = it.asNode()
+
+	def filteredResources = node.get("filteredResources")
+	if(filteredResources) {
+		node.remove(filteredResources)
+	}
+	def filterNode = node.appendNode("filteredResources").appendNode("filter")
+	filterNode.appendNode("id", "1359048889071")
+	filterNode.appendNode("name", "")
+	filterNode.appendNode("type", "30")
+	def matcherNode = filterNode.appendNode("matcher")
+	matcherNode.appendNode("id", "org.eclipse.ui.ide.multiFilter")
+	matcherNode.appendNode("arguments", "1.0-projectRelativePath-matches-false-false-build")
+}

gradle/jdiff.gradle

@@ -45,7 +45,7 @@ task jdiff {
 				destdir: outputDir,
 				verbose: "off",
 				stats: "on",
-				docchanges: "on") {
+				docchanges: "off") {
 			old(name: "Spring Framework ${oldVersion}") {
 				oldVersionRoot.eachDirMatch( {
 						def candidate = new File(it)

gradle/jdiff/Null.java

@@ -1,6 +1,6 @@
-/** 
+/**
  * This class is used only as a "null" argument for Javadoc when comparing
- * two API files. Javadoc has to have a package, .java or .class file as an 
+ * two API files. Javadoc has to have a package, .java or .class file as an
  * argument, even though JDiff doesn't use it.
  */
 public class Null {

gradle/jdiff/README.txt

@@ -11,7 +11,7 @@ difference between two public Java APIs.
 
 The file jdiff.html contains the reference page for JDiff.  The latest
 version of JDiff can be downloaded at:
-http://sourceforge.net/projects/javadiff
+https://sourceforge.net/projects/javadiff
 
 To use the Ant task on your own project, see example.xml. More examples
 of using JDiff to compare the public APIs of J2SE1.3 and J2SE1.4 can
@@ -40,7 +40,7 @@ Acknowledgements
 JDiff uses Stuart D. Gathman's Java translation of Gene Myers' O(ND) 
 difference algorithm.
 
-JDiff uses Xerces 1.4.2 from http://www.apache.org.
+JDiff uses Xerces 1.4.2 from https://www.apache.org.
 
 JDiff also includes a script to use the classdoc application from
 http://classdoc.sourceforge.net or http://www.jensgulden.de, by Jens
@@ -56,4 +56,4 @@ much of this work.
 Footnote:
 
 If you are looking for a generalized diff tool for XML, try diffmk from
-http://wwws.sun.com/software/xml/developers/diffmk/
+https://wwws.sun.com/software/xml/developers/diffmk/

gradle/jdiff/jdiff.html

@@ -7,10 +7,10 @@
 <BODY BGCOLOR="#ffffff">
 <table width="100%">
 <tr>
-<td align="left"><A href="http://sourceforge.net/projects/javadiff/">
+<td align="left"><A href="https://sourceforge.net/projects/javadiff/">
 <IMG src="http://javadiff.cvs.sourceforge.net/*checkout*/javadiff/jdiff/lib/jdiff_logo.gif"
 width="88" height="31" border="0" alt="JDiff Logo"></A></td>
-<td align="right"><A href="http://sourceforge.net"> <IMG src="http://sourceforge.net/sflogo.php?group_id=37160" width="88" height="31" border="0" alt="SourceForge Logo"></A></td>
+<td align="right"><A href="https://sourceforge.net"> <IMG src="https://sourceforge.net/sflogo.php?group_id=37160" width="88" height="31" border="0" alt="SourceForge Logo"></A></td>
 </tr>
 </table>
 
@@ -21,7 +21,7 @@ width="88" height="31" border="0" alt="JDiff Logo"></A></td>
 
 <BLOCKQUOTE>
 <b>JDiff</b> is a Javadoc <a
-href="http://java.sun.com/j2se/javadoc">doclet</a> which generates an
+href="https://java.sun.com/j2se/javadoc">doclet</a> which generates an
 HTML report of all the packages, classes, constructors, methods, and
 fields which have been removed, added or changed in any way, including
 their documentation, when two APIs are compared. This is very useful
@@ -312,7 +312,7 @@ the HTML output to the given directory.
   <code>-javadocnew</code> &lt;<i>javadoc files location for the new API</i>></DT>
   <DD STYLE="margin-right: 2cm; margin-bottom: 0.5cm">
    The location of existing Javadoc files
-   for the new API, e.g. "http://java.sun.com/j2se/<b>1.5.0</b>/docs/api/" for the
+   for the new API, e.g. "https://java.sun.com/j2se/<b>1.5.0</b>/docs/api/" for the
    public documentation for J2SE1.5.0. The default value is "../", which implies
    that the documentation directory generated by Javadoc is at the same level as
    the "changes.html" file generated by JDiff. Slashes are always
@@ -325,7 +325,7 @@ the HTML output to the given directory.
   <DT STYLE="margin-right: 2cm; margin-bottom: 0.5cm">
   <code>-javadocold</code> &lt;<i>javadoc files location for the old API</i>></DT>
   <DD STYLE="margin-right: 2cm; margin-bottom: 0.5cm"> The location of existing 
-   Javadoc files for the old API, e.g. "http://java.sun.com/j2se/<b>1.5.0</b>/docs/API/" 
+   Javadoc files for the old API, e.g. "https://java.sun.com/j2se/<b>1.5.0</b>/docs/API/" 
    for the public documentation for J2SE1.5.0. The default value is null, which 
    results in no links to Javadoc-generated documentation for the previous 
    release. Slashes are always forward in the argument, since this is an HTML 
@@ -426,7 +426,7 @@ the HTML output to the given directory.
   <code>-showallchanges</code></DT>
   <DD STYLE="margin-right: 2cm; margin-bottom: 0.5cm">
    If this argument is used, JDiff will show changes in
-   native and synchronized modifiers. See <a href="http://java.sun.com/j2se/1.4.1/docs/tooldocs/solaris/javadoc.html#generatedapideclarations">here</a> for why these are not shown by default.
+   native and synchronized modifiers. See <a href="https://java.sun.com/j2se/1.4.1/docs/tooldocs/solaris/javadoc.html#generatedapideclarations">here</a> for why these are not shown by default.
   </DD>
 
   <DT STYLE="margin-right: 2cm; margin-bottom: 0.5cm">
@@ -547,7 +547,7 @@ moved to the end of the file and placed inside XML comments.
 
 <BLOCKQUOTE> The text which is added can be HTML text if necessary, but if the 
   HTML is incorrect, JDiff may fail to read the comments file and exit. Note that 
-  the required HTML is in fact <a href="http://www.w3.org/TR/xhtml1/diffs.html">XHTML</a>. Since this HTML is stored in an XML document, single tags without their closing ("slash") element are not permitted. 
+  the required HTML is in fact <a href="https://www.w3.org/TR/xhtml1/diffs.html">XHTML</a>. Since this HTML is stored in an XML document, single tags without their closing ("slash") element are not permitted. 
   For example, most browsers permit HTML which looks like "&lt;p>Here is some 
   text.", with no closing tag. XML requires that either a closing tag exists ("&lt;/p>"), 
   or that the single tag is closed, e.g. "&lt;p/>Here is some text.". 
@@ -988,7 +988,7 @@ it can tell you how the content has changed.
 Nor does it
 compare what the methods in an API do; if JDiff could tell you what had changed about the way two
 versions of an API execute, the <a
-href="http://en.wikipedia.org/wiki/Halting_Problem">Halting
+href="https://en.wikipedia.org/wiki/Halting_Problem">Halting
 Problem</a> would be solved, and our lives would be very different.</li>
 <li>On a P3 450MHz machine, to scan all of the J2SE <code>Java</code> 
 and <code>javax</code> packages and generate XML takes about 2 minutes
@@ -1002,14 +1002,14 @@ per version. To generate a report from the XML files takes about 30s</li>
 
 <BLOCKQUOTE>
 <UL>
-  <LI><A HREF="http://www.sys-con.com/java">Java Developer's Journal
+  <LI><A HREF="https://www.sys-con.com/java">Java Developer's Journal
 	</A>, April 2002 contained an article about JDiff. The article
 	can also be <a
 	href="http://javadiff.cvs.sourceforge.net/*checkout*/javadiff/jdiff/doc/JDiffArticle.pdf">found
 	here</a>.</LI>
-  <LI><A HREF="http://java.sun.com/j2se/javadoc/">Javadoc</A> and Doclet
+  <LI><A HREF="https://java.sun.com/j2se/javadoc/">Javadoc</A> and Doclet
 	documentation from Sun.</LI>
-  <LI><A HREF="http://java.sun.com/j2se/javadoc/faq.html#doclets">Third-party
+  <LI><A HREF="https://java.sun.com/j2se/javadoc/faq.html#doclets">Third-party
 	doclets</a> as listed by Sun.</LI>
   <LI><A HREF="http://www.doclet.com">Third-party doclets</a> as listed by others.</LI>
 </UL>

gradle/publish-maven.gradle

@@ -13,19 +13,24 @@ def customizePom(pom, gradleProject) {
 			dep.scope == "test"
 		}
 
+		// sort to make pom dependencies order consistent to ease comparison of older poms
+		generatedPom.dependencies = generatedPom.dependencies.sort { dep ->
+			"$dep.scope:$dep.groupId:$dep.artifactId"
+		}
+
 		// add all items necessary for maven central publication
 		generatedPom.project {
 			name = gradleProject.description
 			description = gradleProject.description
-			url = "https://github.com/SpringSource/spring-framework"
+			url = "https://github.com/spring-projects/spring-framework"
 			organization {
 				name = "SpringSource"
-				url = "http://springsource.org/spring-framework"
+				url = "https://spring.io/projects/spring-framework"
 			}
 			licenses {
 				license {
 					name "The Apache Software License, Version 2.0"
-					url "http://www.apache.org/licenses/LICENSE-2.0.txt"
+					url "https://www.apache.org/licenses/LICENSE-2.0.txt"
 					distribution "repo"
 				}
 			}
@@ -38,7 +43,7 @@ def customizePom(pom, gradleProject) {
 				developer {
 					id = "jhoeller"
 					name = "Juergen Hoeller"
-					email = "jhoeller@vmware.com"
+					email = "jhoeller@gopivotal.com"
 				}
 			}
 		}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Wed Nov 28 09:14:59 PST 2012
+#Wed Apr 30 13:06:57 CEST 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.5-bin.zip

import-into-eclipse.bat

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

import-into-eclipse.sh

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

import-into-idea.md

@@ -1,10 +1,10 @@
-The following has been tested against Intellij IDEA 11.0.1
+The following has been tested against Intellij IDEA 12.0
 
 ## Steps
 
 _Within your locally cloned spring-framework working directory:_
 
-1. Generate IDEA metadata with `./gradlew cleanIdea idea`
+1. Generate IDEA metadata with `./gradlew :spring-oxm:compileTestJava cleanIdea idea`
 2. Import into IDEA as usual
 3. Set the Project JDK as appropriate
 4. Add git support
@@ -12,21 +12,21 @@ _Within your locally cloned spring-framework working directory:_
 
 ## Known issues
 
-1. MockServletContext and friends will fail to compile in spring-web. To fix this, uncheck the 'export' setting for all servlet-api and tomcat-servlet-api jars. The problem is that spring-web needs Servlet 2.5, but it's picking up Servlet 3.0 from projects that it depends on.
-2. spring-context will fail to build because there's a duplicate instance of GroovyMessenger in spring-context/src/test/java/org/springframework/scripting/groovy/Messenger.groovy. The solution to this is not known.  It's not a problem on Eclipse, because Eclipse doesn't automatically compile .groovy files like IDEA (apparently) does.
-
-There are no other known problems at this time.  Please add to this list, and if you're ambitious, consider playing with the Gradle IDEA generation DSL to fix these problems automatically, e.g.:
-
-* http://gradle.org/docs/current/dsl/org.gradle.plugins.ide.idea.model.IdeaProject.html
-* http://gradle.org/docs/current/dsl/org.gradle.plugins.ide.idea.model.IdeaModule.html
-* http://gradle.org/docs/current/groovydoc/org/gradle/plugins/ide/idea/model/IdeaModule.html
+1. `spring-aspects` does not compile out of the box due to references to aspect types unknown to IDEA.
+See https://youtrack.jetbrains.com/issue/IDEA-64446 for details. In the meantime, the 'spring-aspects'
+module has been excluded from the overall project to avoid compilation errors.
+2. While all JUnit tests pass from the command line with Gradle, many will fail when run from IDEA.
+Resolving this is a work in progress. If attempting to run all JUnit tests from within IDEA, you will
+likely need to set the following VM options to avoid out of memory errors:
+    -XX:MaxPermSize=2048m -Xmx2048m -XX:MaxHeapSize=2048m
 
 ## Tips
 
-In any case, please do not check in your own generated .iml, .ipr, or .iws files. You'll notice these files are already intentionally in .gitignore. The same policy goes for eclipse metadata.
+In any case, please do not check in your own generated .iml, .ipr, or .iws files.
+You'll notice these files are already intentionally in .gitignore. The same policy goes for eclipse metadata.
 
 ## FAQ
 
-Q. What about IDEA's own [Gradle support](http://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
+Q. What about IDEA's own [Gradle support](https://confluence.jetbrains.net/display/IDEADEV/Gradle+integration)?
 
-A. Unknown. Please report back if you try it and it goes well for you.
+A. Keep an eye on https://youtrack.jetbrains.com/issue/IDEA-53476

settings.gradle

@@ -22,3 +22,8 @@ include "spring-web"
 include "spring-webmvc"
 include "spring-webmvc-portlet"
 include "spring-webmvc-tiles3"
+include "spring-framework-bom"
+
+// Exposes gradle buildSrc for IDE support
+include "buildSrc"
+rootProject.children.find{ it.name == "buildSrc" }.name = "spring-build-src"

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,14 +18,14 @@ package org.springframework.aop;
 
 import org.aopalliance.aop.Advice;
 
-/** 
+/**
  * Base interface holding AOP <b>advice</b> (action to take at a joinpoint)
- * and a filter determining the applicability of the advice (such as 
+ * and a filter determining the applicability of the advice (such as
  * a pointcut). <i>This interface is not for use by Spring users, but to
  * allow for commonality in support for different types of advice.</i>
  *
  * <p>Spring AOP is based around <b>around advice</b> delivered via method
- * <b>interception</b>, compliant with the AOP Alliance interception API. 
+ * <b>interception</b>, compliant with the AOP Alliance interception API.
  * The Advisor interface allows support for different types of advice,
  * such as <b>before</b> and <b>after</b> advice, which need not be
  * implemented using interception.
@@ -50,7 +50,7 @@ public interface Advisor {
 	 * (for example, creating a mixin) or shared with all instances of
 	 * the advised class obtained from the same Spring bean factory.
 	 * <p><b>Note that this method is not currently used by the framework.</b>
-	 * Typical Advisor implementations always return <code>true</code>.
+	 * Typical Advisor implementations always return {@code true}.
 	 * Use singleton/prototype bean definitions or appropriate programmatic
 	 * proxy creation to ensure that Advisors have the correct lifecycle model.
 	 * @return whether this advice is associated with a particular target instance

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -33,7 +33,7 @@ public interface AfterReturningAdvice extends AfterAdvice {
 	 * @param returnValue the value returned by the method, if any
 	 * @param method method being invoked
 	 * @param args arguments to the method
-	 * @param target target of the method invocation. May be <code>null</code>.
+	 * @param target target of the method invocation. May be {@code null}.
 	 * @throws Throwable if this object wishes to abort the call.
 	 * Any exception thrown will be returned to the caller if it's
 	 * allowed by the method signature. Otherwise the exception

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -25,6 +25,7 @@ import org.springframework.core.NestedRuntimeException;
  * @author Juergen Hoeller
  * @since 2.0
  */
+@SuppressWarnings("serial")
 public class AopInvocationException extends NestedRuntimeException {
 
 	/**

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,7 +18,7 @@ package org.springframework.aop;
 
 import org.aopalliance.aop.Advice;
 
-/** 
+/**
  * Subinterface of AOP Alliance Advice that allows additional interfaces
  * to be implemented by an Advice, and available via a proxy using that
  * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
@@ -37,7 +37,7 @@ import org.aopalliance.aop.Advice;
  * @see IntroductionAdvisor
  */
 public interface DynamicIntroductionAdvice extends Advice {
-	
+
 	/**
 	 * Does this introduction advice implement the given interface?
 	 * @param intf the interface to check

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -30,7 +30,7 @@ package org.springframework.aop;
  * @see IntroductionInterceptor
  */
 public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
-	
+
 	/**
 	 * Return the filter determining which target classes this introduction
 	 * should apply to.
@@ -39,7 +39,7 @@ public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
 	 * @return the class filter
 	 */
 	ClassFilter getClassFilter();
-	
+
 	/**
 	 * Can the advised interfaces be implemented by the introduction advice?
 	 * Invoked before adding an IntroductionAdvisor.

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -19,9 +19,9 @@ package org.springframework.aop;
 import java.lang.reflect.Method;
 
 /**
- * A specialized type of MethodMatcher that takes into account introductions when
- * matching methods. If there are no introductions on the target class, a method
- * matcher may be able to optimize matching more effectively for example.
+ * A specialized type of {@link MethodMatcher} that takes into account introductions
+ * when matching methods. If there are no introductions on the target class,
+ * a method matcher may be able to optimize matching more effectively for example.
  *
  * @author Adrian Colyer
  * @since 2.0
@@ -33,12 +33,12 @@ public interface IntroductionAwareMethodMatcher extends MethodMatcher {
 	 * instead of the 2-arg {@link #matches(java.lang.reflect.Method, Class)} method
 	 * if the caller supports the extended IntroductionAwareMethodMatcher interface.
 	 * @param method the candidate method
-	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * @param targetClass the target class (may be {@code null}, in which case
 	 * the candidate class must be taken to be the method's declaring class)
-	 * @param hasIntroductions <code>true</code> if the object on whose behalf we are
-	 * asking is the subject on one or more introductions; <code>false</code> otherwise
+	 * @param hasIntroductions {@code true} if the object on whose behalf we are
+	 * asking is the subject on one or more introductions; {@code false} otherwise
 	 * @return whether or not this method matches statically
 	 */
-	boolean matches(Method method, Class targetClass, boolean hasIntroductions);
+	boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions);
 
 }

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -29,11 +29,11 @@ package org.springframework.aop;
  * @since 1.1.1
  */
 public interface IntroductionInfo {
-	
+
 	/**
 	 * Return the additional interfaces introduced by this Advisor or Advice.
 	 * @return the introduced interfaces
 	 */
-	Class[] getInterfaces();
+	Class<?>[] getInterfaces();
 
 }

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,12 +1,12 @@
 /*
- * Copyright 2002-2005 the original author or authors.
- * 
+ * Copyright 2002-2012 the original author or authors.
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -28,12 +28,12 @@ import java.lang.reflect.Method;
  * @author Rod Johnson
  */
 public interface MethodBeforeAdvice extends BeforeAdvice {
-	
+
 	/**
 	 * Callback before a given method is invoked.
 	 * @param method method being invoked
 	 * @param args arguments to the method
-	 * @param target target of the method invocation. May be <code>null</code>.
+	 * @param target target of the method invocation. May be {@code null}.
 	 * @throws Throwable if this object wishes to abort the call.
 	 * Any exception thrown will be returned to the caller if it's
 	 * allowed by the method signature. Otherwise the exception

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -26,15 +26,15 @@ import java.lang.reflect.Method;
  * also makes arguments for a particular call available, and any effects of running
  * previous advice applying to the joinpoint.
  *
- * <p>If an implementation returns <code>false</code> from its {@link #isRuntime()}
+ * <p>If an implementation returns {@code false} from its {@link #isRuntime()}
  * method, evaluation can be performed statically, and the result will be the same
  * for all invocations of this method, whatever their arguments. This means that
- * if the {@link #isRuntime()} method returns <code>false</code>, the 3-arg
+ * if the {@link #isRuntime()} method returns {@code false}, the 3-arg
  * {@link #matches(java.lang.reflect.Method, Class, Object[])} method will never be invoked.
  *
- * <p>If an implementation returns <code>true</code> from its 2-arg
+ * <p>If an implementation returns {@code true} from its 2-arg
  * {@link #matches(java.lang.reflect.Method, Class)} method and its {@link #isRuntime()} method
- * returns <code>true</code>, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
+ * returns {@code true}, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
  * method will be invoked <i>immediately before each potential execution of the related advice</i>,
  * to decide whether the advice should run. All previous advice, such as earlier interceptors
  * in an interceptor chain, will have run, so any state changes they have produced in
@@ -49,11 +49,11 @@ public interface MethodMatcher {
 
 	/**
 	 * Perform static checking whether the given method matches. If this
-	 * returns <code>false</code> or if the {@link #isRuntime()} method
-	 * returns <code>false</code>, no runtime check (i.e. no.
+	 * returns {@code false} or if the {@link #isRuntime()} method
+	 * returns {@code false}, no runtime check (i.e. no.
 	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call) will be made.
 	 * @param method the candidate method
-	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * @param targetClass the target class (may be {@code null}, in which case
 	 * the candidate class must be taken to be the method's declaring class)
 	 * @return whether or not this method matches statically
 	 */
@@ -62,7 +62,7 @@ public interface MethodMatcher {
 	/**
 	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
 	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
-	 * runtime even if the 2-arg matches method returns <code>true</code>?
+	 * runtime even if the 2-arg matches method returns {@code true}?
 	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
 	 * again before each method invocation,
 	 * @return whether or not a runtime match via the 3-arg
@@ -75,12 +75,12 @@ public interface MethodMatcher {
 	 * Check whether there a runtime (dynamic) match for this method,
 	 * which must have matched statically.
 	 * <p>This method is invoked only if the 2-arg matches method returns
-	 * <code>true</code> for the given method and target class, and if the
-	 * {@link #isRuntime()} method returns <code>true</code>. Invoked
+	 * {@code true} for the given method and target class, and if the
+	 * {@link #isRuntime()} method returns {@code true}. Invoked
 	 * immediately before potential running of the advice, after any
 	 * advice earlier in the advice chain has run.
 	 * @param method the candidate method
-	 * @param targetClass the target class (may be <code>null</code>, in which case
+	 * @param targetClass the target class (may be {@code null}, in which case
 	 * the candidate class must be taken to be the method's declaring class)
 	 * @param args arguments to the method
 	 * @return whether there's a runtime match

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -34,13 +34,13 @@ public interface Pointcut {
 
 	/**
 	 * Return the ClassFilter for this pointcut.
-	 * @return the ClassFilter (never <code>null</code>)
+	 * @return the ClassFilter (never {@code null})
 	 */
 	ClassFilter getClassFilter();
 
 	/**
 	 * Return the MethodMatcher for this pointcut.
-	 * @return the MethodMatcher (never <code>null</code>)
+	 * @return the MethodMatcher (never {@code null})
 	 */
 	MethodMatcher getMethodMatcher();
 

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

@@ -1,12 +1,12 @@
 /*
- * Copyright 2002-2005 the original author or authors.
- * 
+ * Copyright 2002-2012 the original author or authors.
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -40,22 +40,22 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	Object getProxy();
 
 	/**
-	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
-	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * Create a clone of this object. If cloning is done before {@code proceed()}
+	 * is invoked on this object, {@code proceed()} can be invoked once per clone
 	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
 	 * @return an invocable clone of this invocation.
-	 * <code>proceed()</code> can be called once per clone.
+	 * {@code proceed()} can be called once per clone.
 	 */
 	MethodInvocation invocableClone();
 
 	/**
-	 * Create a clone of this object. If cloning is done before <code>proceed()</code>
-	 * is invoked on this object, <code>proceed()</code> can be invoked once per clone
+	 * Create a clone of this object. If cloning is done before {@code proceed()}
+	 * is invoked on this object, {@code proceed()} can be invoked once per clone
 	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
 	 * @param arguments the arguments that the cloned invocation is supposed to use,
 	 * overriding the original arguments
 	 * @return an invocable clone of this invocation.
-	 * <code>proceed()</code> can be called once per clone.
+	 * {@code proceed()} can be called once per clone.
 	 */
 	MethodInvocation invocableClone(Object[] arguments);
 
@@ -71,14 +71,14 @@ public interface ProxyMethodInvocation extends MethodInvocation {
 	 * <p>Such attributes are not used within the AOP framework itself. They are
 	 * just kept as part of the invocation object, for use in special interceptors.
 	 * @param key the name of the attribute
-	 * @param value the value of the attribute, or <code>null</code> to reset it
+	 * @param value the value of the attribute, or {@code null} to reset it
 	 */
 	void setUserAttribute(String key, Object value);
 
 	/**
 	 * Return the value of the specified user attribute.
 	 * @param key the name of the attribute
-	 * @return the value of the attribute, or <code>null</code> if not set
+	 * @return the value of the attribute, or {@code null} if not set
 	 * @see #setUserAttribute
 	 */
 	Object getUserAttribute(String key);

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,7 +32,7 @@ public interface TargetClassAware {
 	/**
 	 * Return the target class behind the implementing object
 	 * (typically a proxy configuration or an actual proxy).
-	 * @return the target Class, or <code>null</code> if not known
+	 * @return the target Class, or {@code null} if not known
 	 */
 	Class<?> getTargetClass();
 

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

@@ -1,11 +1,11 @@
 /*<
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -17,16 +17,16 @@
 package org.springframework.aop;
 
 /**
- * A <code>TargetSource</code> is used to obtain the current "target" of
+ * A {@code TargetSource} is used to obtain the current "target" of
  * an AOP invocation, which will be invoked via reflection if no around
  * advice chooses to end the interceptor chain itself.
  *
- * <p>If a <code>TargetSource</code> is "static", it will always return
+ * <p>If a {@code TargetSource} is "static", it will always return
  * the same target, allowing optimizations in the AOP framework. Dynamic
  * target sources can support pooling, hot swapping, etc.
  *
  * <p>Application developers don't usually need to work with
- * <code>TargetSources</code> directly: this is an AOP framework interface.
+ * {@code TargetSources} directly: this is an AOP framework interface.
  *
  * @author Rod Johnson
  */
@@ -34,8 +34,8 @@ public interface TargetSource extends TargetClassAware {
 
 	/**
 	 * Return the type of targets returned by this {@link TargetSource}.
-	 * <p>Can return <code>null</code>, although certain usages of a
-	 * <code>TargetSource</code> might just work with a predetermined
+	 * <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}
 	 */
@@ -46,7 +46,7 @@ public interface TargetSource extends TargetClassAware {
 	 * <p>In that case, there will be no need to invoke
 	 * {@link #releaseTarget(Object)}, and the AOP framework can cache
 	 * the return value of {@link #getTarget()}.
-	 * @return <code>true</code> if the target is immutable
+	 * @return {@code true} if the target is immutable
 	 * @see #getTarget
 	 */
 	boolean isStatic();

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -23,10 +23,11 @@ import java.io.Serializable;
  *
  * @author Rod Johnson
  */
+@SuppressWarnings("serial")
 class TrueClassFilter implements ClassFilter, Serializable {
-	
+
 	public static final TrueClassFilter INSTANCE = new TrueClassFilter();
-	
+
 	/**
 	 * Enforce Singleton pattern.
 	 */
@@ -36,11 +37,11 @@ class TrueClassFilter implements ClassFilter, Serializable {
 	public boolean matches(Class clazz) {
 		return true;
 	}
-	
+
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding <code>equals()</code>.
+	 * Alternative to overriding {@code equals()}.
 	 */
 	private Object readResolve() {
 		return INSTANCE;

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -24,10 +24,11 @@ import java.lang.reflect.Method;
  *
  * @author Rod Johnson
  */
+@SuppressWarnings("serial")
 class TrueMethodMatcher implements MethodMatcher, Serializable {
-	
+
 	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
-	
+
 	/**
 	 * Enforce Singleton pattern.
 	 */
@@ -46,16 +47,16 @@ class TrueMethodMatcher implements MethodMatcher, Serializable {
 		// Should never be invoked as isRuntime returns false.
 		throw new UnsupportedOperationException();
 	}
-	
+
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding <code>equals()</code>.
+	 * Alternative to overriding {@code equals()}.
 	 */
 	private Object readResolve() {
 		return INSTANCE;
 	}
-	
+
 	@Override
 	public String toString() {
 		return "MethodMatcher.TRUE";

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -23,10 +23,11 @@ import java.io.Serializable;
  *
  * @author Rod Johnson
  */
+@SuppressWarnings("serial")
 class TruePointcut implements Pointcut, Serializable {
-	
+
 	public static final TruePointcut INSTANCE = new TruePointcut();
-	
+
 	/**
 	 * Enforce Singleton pattern.
 	 */
@@ -40,11 +41,11 @@ class TruePointcut implements Pointcut, Serializable {
 	public MethodMatcher getMethodMatcher() {
 		return MethodMatcher.TRUE;
 	}
-	
+
 	/**
 	 * Required to support serialization. Replaces with canonical
 	 * instance on deserialization, protecting Singleton pattern.
-	 * Alternative to overriding <code>equals()</code>.
+	 * Alternative to overriding {@code equals()}.
 	 */
 	private Object readResolve() {
 		return INSTANCE;

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2012 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -120,9 +120,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	/** Non-null if after returning advice binds the return value */
 	private String returningName = null;
 
-	private Class discoveredReturningType = Object.class;
+	private Class<?> discoveredReturningType = Object.class;
 
-	private Class discoveredThrowingType = Object.class;
+	private Class<?> discoveredThrowingType = Object.class;
 
 	/**
 	 * Index for thisJoinPoint argument (currently only
@@ -211,7 +211,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	public void setAspectName(String name) {
 		this.aspectName = name;
 	}
-	
+
 	public String getAspectName() {
 		return this.aspectName;
 	}
@@ -238,7 +238,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		setArgumentNamesFromStringArray(tokens);
 	}
 
-	public void setArgumentNamesFromStringArray(String[] args) {
+	public void setArgumentNamesFromStringArray(String... args) {
 		this.argumentNames = new String[args.length];
 		for (int i = 0; i < args.length; i++) {
 			this.argumentNames[i] = StringUtils.trimWhitespace(args[i]);
@@ -251,7 +251,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (argumentNames != null) {
 			if (aspectJAdviceMethod.getParameterTypes().length == argumentNames.length + 1) {
 				// May need to add implicit join point arg name...
-				Class firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
+				Class<?> firstArgType = aspectJAdviceMethod.getParameterTypes()[0];
 				if (firstArgType == JoinPoint.class ||
 						firstArgType == ProceedingJoinPoint.class ||
 						firstArgType == JoinPoint.StaticPart.class) {
@@ -268,7 +268,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		throw new UnsupportedOperationException("Only afterReturning advice can be used to bind a return value");
 	}
 
-	/** 
+	/**
 	 * We need to hold the returning name at this level for argument binding calculations,
 	 * this method allows the afterReturning advice subclass to set the name.
 	 */
@@ -290,7 +290,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}
 
-	protected Class getDiscoveredReturningType() {
+	protected Class<?> getDiscoveredReturningType() {
 		return this.discoveredReturningType;
 	}
 
@@ -302,7 +302,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		throw new UnsupportedOperationException("Only afterThrowing advice can be used to bind a thrown exception");
 	}
 
-	/** 
+	/**
 	 * We need to hold the throwing name at this level for argument binding calculations,
 	 * this method allows the afterThrowing advice subclass to set the name.
 	 */
@@ -324,7 +324,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}
 
-	protected Class getDiscoveredThrowingType() {
+	protected Class<?> getDiscoveredThrowingType() {
 		return this.discoveredThrowingType;
 	}
 
@@ -347,8 +347,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 	 * on subsequent advice invocations can be as fast as possible.
 	 * <p>If the first argument is of type JoinPoint or ProceedingJoinPoint then we
 	 * pass a JoinPoint in that position (ProceedingJoinPoint for around advice).
-	 * <p>If the first argument is of type <code>JoinPoint.StaticPart</code>
-	 * then we pass a <code>JoinPoint.StaticPart</code> in that position.
+	 * <p>If the first argument is of type {@code JoinPoint.StaticPart}
+	 * then we pass a {@code JoinPoint.StaticPart} in that position.
 	 * <p>Remaining arguments have to be bound by pointcut evaluation at
 	 * a given join point. We will get back a map from argument name to
 	 * value. We need to calculate which advice parameter needs to be bound
@@ -362,14 +362,14 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 
 		int numUnboundArgs = this.adviceInvocationArgumentCount;
-		Class[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
 			numUnboundArgs--;
-		} 
+		}
 		else if (maybeBindJoinPointStaticPart(parameterTypes[0])) {
 			numUnboundArgs--;
 		}
-			
+
 		if (numUnboundArgs > 0) {
 			// need to bind arguments by name as returned from the pointcut match
 			bindArgumentsByName(numUnboundArgs);
@@ -378,7 +378,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		this.argumentsIntrospected = true;
 	}
 
-	private boolean maybeBindJoinPoint(Class candidateParameterType) {
+	private boolean maybeBindJoinPoint(Class<?> candidateParameterType) {
 		if (candidateParameterType.equals(JoinPoint.class)) {
 			this.joinPointArgumentIndex = 0;
 			return true;
@@ -388,7 +388,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}
 
-	private boolean maybeBindProceedingJoinPoint(Class candidateParameterType) {
+	private boolean maybeBindProceedingJoinPoint(Class<?> candidateParameterType) {
 		if (candidateParameterType.equals(ProceedingJoinPoint.class)) {
 			if (!supportsProceedingJoinPoint()) {
 				throw new IllegalArgumentException("ProceedingJoinPoint is only supported for around advice");
@@ -398,18 +398,18 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		else {
 			return false;
-		}		
+		}
 	}
 
 	protected boolean supportsProceedingJoinPoint() {
 		return false;
 	}
 
-	private boolean maybeBindJoinPointStaticPart(Class candidateParameterType) {
+	private boolean maybeBindJoinPointStaticPart(Class<?> candidateParameterType) {
 		if (candidateParameterType.equals(JoinPoint.StaticPart.class)) {
 			this.joinPointStaticPartArgumentIndex = 0;
 			return true;
-		} 
+		}
 		else {
 			return false;
 		}
@@ -422,7 +422,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.argumentNames != null) {
 			// We have been able to determine the arg names.
 			bindExplicitArguments(numArgumentsExpectingToBind);
-		} 
+		}
 		else {
 			throw new IllegalStateException("Advice method [" + this.aspectJAdviceMethod.getName() + "] " +
 					"requires " + numArgumentsExpectingToBind + " arguments to be bound by name, but " +
@@ -471,9 +471,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		// specified, and find the discovered argument types.
 		if (this.returningName != null) {
 			if (!this.argumentBindings.containsKey(this.returningName)) {
-				throw new IllegalStateException("Returning argument name '" 
+				throw new IllegalStateException("Returning argument name '"
 						+ this.returningName + "' was not bound in advice arguments");
-			} 
+			}
 			else {
 				Integer index = this.argumentBindings.get(this.returningName);
 				this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
@@ -482,9 +482,9 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 		if (this.throwingName != null) {
 			if (!this.argumentBindings.containsKey(this.throwingName)) {
-				throw new IllegalStateException("Throwing argument name '" 
+				throw new IllegalStateException("Throwing argument name '"
 						+ this.throwingName + "' was not bound in advice arguments");
-			} 
+			}
 			else {
 				Integer index = this.argumentBindings.get(this.throwingName);
 				this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
@@ -509,8 +509,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			numParametersToRemove++;
 		}
 		String[] pointcutParameterNames = new String[this.argumentNames.length - numParametersToRemove];
-		Class[] pointcutParameterTypes = new Class[pointcutParameterNames.length];
-		Class[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
+		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 
 		int index = 0;
 		for (int i = 0; i < this.argumentNames.length; i++) {
@@ -525,7 +525,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			pointcutParameterTypes[index] = methodParameterTypes[i];
 			index++;
 		}
-		
+
 		this.pointcut.setParameterNames(pointcutParameterNames);
 		this.pointcut.setParameterTypes(pointcutParameterTypes);
 	}
@@ -549,7 +549,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		if (this.joinPointArgumentIndex != -1) {
 			adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
 			numBound++;
-		} 
+		}
 		else if (this.joinPointStaticPartArgumentIndex != -1) {
 			adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
 			numBound++;
@@ -582,8 +582,8 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 
 		if (numBound != this.adviceInvocationArgumentCount) {
 			throw new IllegalStateException("Required to bind " + this.adviceInvocationArgumentCount
-					+ " arguments, but only bound " + numBound + " (JoinPointMatch " + 
-					(jpMatch == null ? "was NOT" : "WAS") + 
+					+ " arguments, but only bound " + numBound + " (JoinPointMatch " +
+					(jpMatch == null ? "was NOT" : "WAS") +
 					" bound in invocation)");
 		}
 
@@ -678,7 +678,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 			this.adviceMethod = adviceMethod;
 		}
 
-		public boolean matches(Method method, 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,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -34,13 +34,13 @@ public interface AspectInstanceFactory extends Ordered {
 
 	/**
 	 * Create an instance of this factory's aspect.
-	 * @return the aspect instance (never <code>null</code>)
+	 * @return the aspect instance (never {@code null})
 	 */
 	Object getAspectInstance();
 
 	/**
 	 * Expose the aspect class loader that this factory uses.
-	 * @return the aspect class loader (never <code>null</code>)
+	 * @return the aspect class loader (never {@code null})
 	 */
 	ClassLoader getAspectClassLoader();
 

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -36,82 +36,82 @@ import org.springframework.util.StringUtils;
 /**
  * {@link ParameterNameDiscoverer} implementation that tries to deduce parameter names
  * for an advice method from the pointcut expression, returning, and throwing clauses.
- * If an unambiguous interpretation is not available, it returns <code>null</code>.
+ * If an unambiguous interpretation is not available, it returns {@code null}.
  *
  * <p>This class interprets arguments in the following way:
  * <ol>
  * <li>If the first parameter of the method is of type {@link JoinPoint}
  * or {@link ProceedingJoinPoint}, it is assumed to be for passing
- * <code>thisJoinPoint</code> to the advice, and the parameter name will
- * be assigned the value <code>"thisJoinPoint"</code>.</li>
+ * {@code thisJoinPoint} to the advice, and the parameter name will
+ * be assigned the value {@code "thisJoinPoint"}.</li>
  * <li>If the first parameter of the method is of type
- * <code>JoinPoint.StaticPart</code>, it is assumed to be for passing
- * <code>"thisJoinPointStaticPart"</code> to the advice, and the parameter name
- * will be assigned the value <code>"thisJoinPointStaticPart"</code>.</li>
+ * {@code JoinPoint.StaticPart}, it is assumed to be for passing
+ * {@code "thisJoinPointStaticPart"} to the advice, and the parameter name
+ * will be assigned the value {@code "thisJoinPointStaticPart"}.</li>
  * <li>If a {@link #setThrowingName(String) throwingName} has been set, and
- * there are no unbound arguments of type <code>Throwable+</code>, then an
+ * there are no unbound arguments of type {@code Throwable+}, then an
  * {@link IllegalArgumentException} is raised. If there is more than one
- * unbound argument of type <code>Throwable+</code>, then an
+ * unbound argument of type {@code Throwable+}, then an
  * {@link AmbiguousBindingException} is raised. If there is exactly one
- * unbound argument of type <code>Throwable+</code>, then the corresponding
+ * unbound argument of type {@code Throwable+}, then the corresponding
  * parameter name is assigned the value &lt;throwingName&gt;.</li>
  * <li>If there remain unbound arguments, then the pointcut expression is
- * examined. Let <code>a</code> be the number of annotation-based pointcut
+ * examined. Let {@code a} be the number of annotation-based pointcut
  * expressions (&#64;annotation, &#64;this, &#64;target, &#64;args,
  * &#64;within, &#64;withincode) that are used in binding form. Usage in
  * binding form has itself to be deduced: if the expression inside the
  * pointcut is a single string literal that meets Java variable name
- * conventions it is assumed to be a variable name. If <code>a</code> is
- * zero we proceed to the next stage. If <code>a</code> &gt; 1 then an
- * <code>AmbiguousBindingException</code> is raised. If <code>a</code> == 1,
- * and there are no unbound arguments of type <code>Annotation+</code>,
- * then an <code>IllegalArgumentException</code> is raised. if there is
+ * conventions it is assumed to be a variable name. If {@code a} is
+ * zero we proceed to the next stage. If {@code a} &gt; 1 then an
+ * {@code AmbiguousBindingException} is raised. If {@code a} == 1,
+ * and there are no unbound arguments of type {@code Annotation+},
+ * then an {@code IllegalArgumentException} is raised. if there is
  * exactly one such argument, then the corresponding parameter name is
  * assigned the value from the pointcut expression.</li>
  * <li>If a returningName has been set, and there are no unbound arguments
- * then an <code>IllegalArgumentException</code> is raised. If there is
+ * then an {@code IllegalArgumentException} is raised. If there is
  * more than one unbound argument then an
- * <code>AmbiguousBindingException</code> is raised. If there is exactly
+ * {@code AmbiguousBindingException} is raised. If there is exactly
  * one unbound argument then the corresponding parameter name is assigned
  * the value &lt;returningName&gt;.</li>
  * <li>If there remain unbound arguments, then the pointcut expression is
- * examined once more for <code>this</code>, <code>target</code>, and
- * <code>args</code> pointcut expressions used in the binding form (binding
+ * examined once more for {@code this}, {@code target}, and
+ * {@code args} pointcut expressions used in the binding form (binding
  * forms are deduced as described for the annotation based pointcuts). If
  * there remains more than one unbound argument of a primitive type (which
- * can only be bound in <code>args</code>) then an
- * <code>AmbiguousBindingException</code> is raised. If there is exactly
- * one argument of a primitive type, then if exactly one <code>args</code>
+ * can only be bound in {@code args}) then an
+ * {@code AmbiguousBindingException} is raised. If there is exactly
+ * one argument of a primitive type, then if exactly one {@code args}
  * bound variable was found, we assign the corresponding parameter name
- * the variable name. If there were no <code>args</code> bound variables
- * found an <code>IllegalStateException</code> is raised. If there are
- * multiple <code>args</code> bound variables, an
- * <code>AmbiguousBindingException</code> is raised. At this point, if
+ * the variable name. If there were no {@code args} bound variables
+ * found an {@code IllegalStateException} is raised. If there are
+ * multiple {@code args} bound variables, an
+ * {@code AmbiguousBindingException} is raised. At this point, if
  * there remains more than one unbound argument we raise an
- * <code>AmbiguousBindingException</code>. If there are no unbound arguments
+ * {@code AmbiguousBindingException}. If there are no unbound arguments
  * remaining, we are done. If there is exactly one unbound argument
  * remaining, and only one candidate variable name unbound from
- * <code>this</code>, <code>target</code>, or <code>args</code>, it is
+ * {@code this}, {@code target}, or {@code args}, it is
  * assigned as the corresponding parameter name. If there are multiple
- * possibilities, an <code>AmbiguousBindingException</code> is raised.</li>
+ * possibilities, an {@code AmbiguousBindingException} is raised.</li>
  * </ol>
  *
- * <p>The behavior on raising an <code>IllegalArgumentException</code> or
- * <code>AmbiguousBindingException</code> is configurable to allow this discoverer
+ * <p>The behavior on raising an {@code IllegalArgumentException} or
+ * {@code AmbiguousBindingException} is configurable to allow this discoverer
  * to be used as part of a chain-of-responsibility. By default the condition will
- * be logged and the <code>getParameterNames(..)</code> method will simply return
- * <code>null</code>. If the {@link #setRaiseExceptions(boolean) raiseExceptions}
- * property is set to <code>true</code>, the conditions will be thrown as
- * <code>IllegalArgumentException</code> and <code>AmbiguousBindingException</code>,
+ * be logged and the {@code getParameterNames(..)} method will simply return
+ * {@code null}. If the {@link #setRaiseExceptions(boolean) raiseExceptions}
+ * property is set to {@code true}, the conditions will be thrown as
+ * {@code IllegalArgumentException} and {@code AmbiguousBindingException},
  * respectively.
  *
  * <p>Was that perfectly clear? ;)
  *
  * <p>Short version: If an unambiguous binding can be deduced, then it is.
- * If the advice requirements cannot possibly be satisfied, then <code>null</code>
+ * If the advice requirements cannot possibly be satisfied, then {@code null}
  * is returned. By setting the {@link #setRaiseExceptions(boolean) raiseExceptions}
- * property to <code>true</code>, descriptive exceptions will be thrown instead of
- * returning <code>null</code> in the case that the parameter names cannot be discovered.
+ * property to {@code true}, descriptive exceptions will be thrown instead of
+ * returning {@code null} in the case that the parameter names cannot be discovered.
  *
  * @author Adrian Colyer
  * @since 2.0
@@ -191,14 +191,14 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	/**
 	 * Indicate whether {@link IllegalArgumentException} and {@link AmbiguousBindingException}
 	 * must be thrown as appropriate in the case of failing to deduce advice parameter names.
-	 * @param raiseExceptions <code>true</code> if exceptions are to be thrown
+	 * @param raiseExceptions {@code true} if exceptions are to be thrown
 	 */
 	public void setRaiseExceptions(boolean raiseExceptions) {
 		this.raiseExceptions = raiseExceptions;
 	}
 
 	/**
-	 * If <code>afterReturning</code> advice binds the return value, the
+	 * If {@code afterReturning} advice binds the return value, the
 	 * returning variable name must be specified.
 	 * @param returningName the name of the returning variable
 	 */
@@ -207,7 +207,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}
 
 	/**
-	 * If <code>afterThrowing</code> advice binds the thrown value, the
+	 * If {@code afterThrowing} advice binds the thrown value, the
 	 * throwing variable name must be specified.
 	 * @param throwingName the name of the throwing variable
 	 */
@@ -305,9 +305,9 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 
 	/**
 	 * An advice method can never be a constructor in Spring.
-	 * @return <code>null</code>
+	 * @return {@code null}
 	 * @throws UnsupportedOperationException if
-	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to <code>true</code>
+	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
 	 */
 	public String[] getParameterNames(Constructor ctor) {
 		if (this.raiseExceptions) {
@@ -493,7 +493,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}
 
 	/**
-	 * Given an args pointcut body (could be <code>args</code> or <code>at_args</code>),
+	 * 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(String argsSpec, List<String> varNames) {
@@ -700,7 +700,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 				// 1 primitive arg, and one candidate...
 				for (int i = 0; i < this.argumentTypes.length; i++) {
 					if (isUnbound(i) && this.argumentTypes[i].isPrimitive()) {
-						bindParameterName(i, (String) varNames.get(0));
+						bindParameterName(i, varNames.get(0));
 						break;
 					}
 				}
@@ -726,7 +726,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	}
 
 	/*
-	 * Return <code>true</code> if the given argument type is a subclass
+	 * Return {@code true} if the given argument type is a subclass
 	 * of the given supertype.
 	 */
 	private boolean isSubtypeOf(Class supertype, int argumentNumber) {
@@ -755,7 +755,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 
 	/*
 	 * Find the argument index with the given type, and bind the given
-	 * <code>varName</code> in that position.
+	 * {@code varName} in that position.
 	 */
 	private void findAndBind(Class argumentType, String varName) {
 		for (int i = 0; i < this.argumentTypes.length; i++) {
@@ -790,6 +790,7 @@ public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscov
 	 * Thrown in response to an ambiguous binding being detected when
 	 * trying to resolve a method's parameter names.
 	 */
+	@SuppressWarnings("serial")
 	public static class AmbiguousBindingException extends RuntimeException {
 
 		/**

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -36,7 +36,7 @@ public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodI
 
 		super(aspectJBeforeAdviceMethod, pointcut, aif);
 	}
-	
+
 	public Object invoke(MethodInvocation mi) throws Throwable {
 		try {
 			return mi.proceed();

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,7 +32,7 @@ import org.springframework.aop.BeforeAdvice;
 public abstract class AspectJAopUtils {
 
 	/**
-	 * Return <code>true</code> if the advisor is a form of before advice.
+	 * Return {@code true} if the advisor is a form of before advice.
 	 */
 	public static boolean isBeforeAdvice(Advisor anAdvisor) {
 		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
@@ -43,7 +43,7 @@ public abstract class AspectJAopUtils {
 	}
 
 	/**
-	 * Return <code>true</code> if the advisor is a form of after advice.
+	 * Return {@code true} if the advisor is a form of after advice.
 	 */
 	public static boolean isAfterAdvice(Advisor anAdvisor) {
 		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
@@ -56,7 +56,7 @@ public abstract class AspectJAopUtils {
 	/**
 	 * Return the AspectJPrecedenceInformation provided by this advisor or its advice.
 	 * If neither the advisor nor the advice have precedence information, this method
-	 * will return <code>null</code>.
+	 * will return {@code null}.
 	 */
 	public static AspectJPrecedenceInformation getAspectJPrecedenceInformationFor(Advisor anAdvisor) {
 		if (anAdvisor instanceof AspectJPrecedenceInformation) {

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -19,6 +19,7 @@ package org.springframework.aop.aspectj;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.lang.reflect.Method;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
@@ -29,7 +30,6 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.aspectj.weaver.BCException;
 import org.aspectj.weaver.patterns.NamePattern;
-import org.aspectj.weaver.reflect.ReflectionWorld;
 import org.aspectj.weaver.reflect.ReflectionWorld.ReflectionWorldException;
 import org.aspectj.weaver.reflect.ShadowMatchImpl;
 import org.aspectj.weaver.tools.ContextBasedMatcher;
@@ -42,6 +42,7 @@ import org.aspectj.weaver.tools.PointcutParameter;
 import org.aspectj.weaver.tools.PointcutParser;
 import org.aspectj.weaver.tools.PointcutPrimitive;
 import org.aspectj.weaver.tools.ShadowMatch;
+
 import org.springframework.aop.ClassFilter;
 import org.springframework.aop.IntroductionAwareMethodMatcher;
 import org.springframework.aop.MethodMatcher;
@@ -55,6 +56,7 @@ import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.BeanFactoryUtils;
 import org.springframework.beans.factory.FactoryBean;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
@@ -76,6 +78,7 @@ import org.springframework.util.StringUtils;
  * @author Dave Syer
  * @since 2.0
  */
+@SuppressWarnings("serial")
 public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
 
@@ -97,14 +100,16 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
 
-	private Class pointcutDeclarationScope;
+	private Class<?> pointcutDeclarationScope;
 
 	private String[] pointcutParameterNames = new String[0];
 
-	private Class[] pointcutParameterTypes = new Class[0];
+	private Class<?>[] pointcutParameterTypes = new Class<?>[0];
 
 	private BeanFactory beanFactory;
 
+	private transient ClassLoader pointcutClassLoader;
+
 	private transient PointcutExpression pointcutExpression;
 
 	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
@@ -122,7 +127,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	 * @param paramNames the parameter names for the pointcut
 	 * @param paramTypes the parameter types for the pointcut
 	 */
-	public AspectJExpressionPointcut(Class declarationScope, String[] paramNames, Class[] paramTypes) {
+	public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes) {
 		this.pointcutDeclarationScope = declarationScope;
 		if (paramNames.length != paramTypes.length) {
 			throw new IllegalStateException(
@@ -136,21 +141,21 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 	/**
 	 * Set the declaration scope for the pointcut.
 	 */
-	public void setPointcutDeclarationScope(Class pointcutDeclarationScope) {
+	public void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope) {
 		this.pointcutDeclarationScope = pointcutDeclarationScope;
 	}
 
 	/**
 	 * Set the parameter names for the pointcut.
 	 */
-	public void setParameterNames(String[] names) {
+	public void setParameterNames(String... names) {
 		this.pointcutParameterNames = names;
 	}
 
 	/**
 	 * Set the parameter types for the pointcut.
 	 */
-	public void setParameterTypes(Class[] types) {
+	public void setParameterTypes(Class<?>... types) {
 		this.pointcutParameterTypes = types;
 	}
 
@@ -179,20 +184,13 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			throw new IllegalStateException("Must set property 'expression' before attempting to match");
 		}
 		if (this.pointcutExpression == null) {
-			this.pointcutExpression = buildPointcutExpression();
+			this.pointcutClassLoader = (this.beanFactory instanceof ConfigurableBeanFactory ?
+					((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
+					ClassUtils.getDefaultClassLoader());
+			this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
 		}
 	}
 
-	/**
-	 * Build the underlying AspectJ pointcut expression.
-	 */
-	private PointcutExpression buildPointcutExpression() {
-		ClassLoader cl = (this.beanFactory instanceof ConfigurableBeanFactory ? ((ConfigurableBeanFactory) this.beanFactory)
-				.getBeanClassLoader() : Thread.currentThread()
-				.getContextClassLoader());
-		return buildPointcutExpression(cl);
-	}
-
 	/**
 	 * Build the underlying AspectJ pointcut expression.
 	 */
@@ -201,11 +199,9 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		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]);
+					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
 		}
-		return parser.parsePointcutExpression(
-				replaceBooleanOperators(getExpression()),
+		return parser.parsePointcutExpression(replaceBooleanOperators(getExpression()),
 				this.pointcutDeclarationScope, pointcutParameters);
 	}
 
@@ -223,9 +219,9 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 	/**
 	 * If a pointcut expression has been specified in XML, the user cannot
-	 * write <code>and</code> as "&&" (though &amp;&amp; will work).
-	 * We also allow <code>and</code> between two pointcut sub-expressions.
-	 * <p>This method converts back to <code>&&</code> for the AspectJ pointcut parser.
+	 * write {@code and} as "&&" (though &amp;&amp; will work).
+	 * We also allow {@code and} between two pointcut sub-expressions.
+	 * <p>This method converts back to {@code &&} for the AspectJ pointcut parser.
 	 */
 	private String replaceBooleanOperators(String pcExpr) {
 		String result = StringUtils.replace(pcExpr, " and ", " && ");
@@ -243,30 +239,28 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return this.pointcutExpression;
 	}
 
-	public boolean matches(Class targetClass) {
+	public boolean matches(Class<?> targetClass) {
 		checkReadyToMatch();
 		try {
-			return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
-		} catch (ReflectionWorldException e) {
-			logger.debug("PointcutExpression matching rejected target class", e);
 			try {
-				// Actually this is still a "maybe" - treat the pointcut as dynamic if we
-				// don't know enough yet
-				return getFallbackPointcutExpression(targetClass).couldMatchJoinPointsInType(targetClass);
-			} catch (BCException ex) {
-				logger.debug(
-						"Fallback PointcutExpression matching rejected target class",
-						ex);
-				return false;
+				return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
 			}
-		} 
+			catch (ReflectionWorldException ex) {
+				logger.debug("PointcutExpression matching rejected target class - trying fallback expression", ex);
+				// Actually this is still a "maybe" - treat the pointcut as dynamic if we don't know enough yet
+				PointcutExpression fallbackExpression = getFallbackPointcutExpression(targetClass);
+				if (fallbackExpression != null) {
+					return fallbackExpression.couldMatchJoinPointsInType(targetClass);
+				}
+			}
+		}
 		catch (BCException ex) {
 			logger.debug("PointcutExpression matching rejected target class", ex);
-			return false;
 		}
+		return false;
 	}
 
-	public boolean matches(Method method, Class targetClass, boolean beanHasIntroductions) {
+	public boolean matches(Method method, Class<?> targetClass, boolean beanHasIntroductions) {
 		checkReadyToMatch();
 		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
 		ShadowMatch shadowMatch = getShadowMatch(targetMethod, method);
@@ -281,12 +275,20 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			return false;
 		}
 		else {
-		  // the maybe case
-		  return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));
+			// the maybe case
+			if (beanHasIntroductions) {
+				return true;
+			}
+			// A match test returned maybe - if there are any subtype sensitive variables
+			// involved in the test (this, target, at_this, at_target, at_annotation) then
+			// we say this is not a match as in Spring there will never be a different
+			// runtime subtype.
+			RuntimeTestWalker walker = getRuntimeTestWalker(shadowMatch);
+			return (!walker.testsSubtypeSensitiveVars() || walker.testTargetInstanceOfResidue(targetClass));
 		}
 	}
 
-	public boolean matches(Method method, Class targetClass) {
+	public boolean matches(Method method, Class<?> targetClass) {
 		return matches(method, targetClass, false);
 	}
 
@@ -295,7 +297,7 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		return this.pointcutExpression.mayNeedDynamicTest();
 	}
 
-	public boolean matches(Method method, Class targetClass, Object[] args) {
+	public boolean matches(Method method, Class<?> targetClass, Object[] args) {
 		checkReadyToMatch();
 		ShadowMatch shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
 		ShadowMatch originalShadowMatch = getShadowMatch(method, method);
@@ -317,31 +319,42 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		catch (IllegalStateException ex) {
 			// No current invocation...
 			// TODO: Should we really proceed here?
-			logger.debug("Couldn't access current invocation - matching with limited context: " + ex);
-		}
-
-		JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
-
-		/*
-		 * Do a final check to see if any this(TYPE) kind of residue match. For
-		 * this purpose, we use the original method's (proxy method's) shadow to
-		 * ensure that 'this' is correctly checked against. Without this check,
-		 * we get incorrect match on this(TYPE) where TYPE matches the target
-		 * type but not 'this' (as would be the case of JDK dynamic proxies).
-		 * <p>See SPR-2979 for the original bug.
-		 */
-		if (pmi != null) {  // there is a current invocation
-			RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(originalShadowMatch);
-			if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
-				return false;
+			if (logger.isDebugEnabled()) {
+				logger.debug("Could not access current invocation - matching with limited context: " + ex);
 			}
 		}
-		if (joinPointMatch.matches() && pmi != null) {
-			bindParameters(pmi, joinPointMatch);
-		}
-		return joinPointMatch.matches();
-	}
 
+		try {
+			JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
+
+			/*
+			 * Do a final check to see if any this(TYPE) kind of residue match. For
+			 * this purpose, we use the original method's (proxy method's) shadow to
+			 * ensure that 'this' is correctly checked against. Without this check,
+			 * we get incorrect match on this(TYPE) where TYPE matches the target
+			 * type but not 'this' (as would be the case of JDK dynamic proxies).
+			 * <p>See SPR-2979 for the original bug.
+			 */
+			if (pmi != null) {  // there is a current invocation
+				RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(originalShadowMatch);
+				if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
+					return false;
+				}
+				if (joinPointMatch.matches()) {
+					bindParameters(pmi, joinPointMatch);
+				}
+			}
+
+			return joinPointMatch.matches();
+		}
+		catch (Throwable ex) {
+			if (logger.isDebugEnabled()) {
+				logger.debug("Failed to evaluate join point for arguments " + Arrays.asList(args) +
+						" - falling back to non-match", ex);
+			}
+			return false;
+		}
+	}
 
 	protected String getCurrentProxiedBeanName() {
 		return ProxyCreationContext.getCurrentProxiedBeanName();
@@ -349,32 +362,24 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 
 	/**
-	 * Get a new pointcut expression based on a target class's loader, rather
-	 * than the default.
+	 * Get a new pointcut expression based on a target class's loader rather than the default.
 	 */
-	private PointcutExpression getFallbackPointcutExpression(
-			Class<?> targetClass) {
-		ClassLoader classLoader = targetClass.getClassLoader();
-		return classLoader == null ? this.pointcutExpression : buildPointcutExpression(classLoader);
-	}
-
-	/**
-	 * A match test returned maybe - if there are any subtype sensitive variables
-	 * involved in the test (this, target, at_this, at_target, at_annotation) then
-	 * we say this is not a match as in Spring there will never be a different
-	 * runtime subtype.
-	 */
-	private boolean matchesIgnoringSubtypes(ShadowMatch shadowMatch) {
-		return !(getRuntimeTestWalker(shadowMatch).testsSubtypeSensitiveVars());
-	}
-
-	private boolean matchesTarget(ShadowMatch shadowMatch, Class targetClass) {
-		return getRuntimeTestWalker(shadowMatch).testTargetInstanceOfResidue(targetClass);
+	private PointcutExpression getFallbackPointcutExpression(Class<?> targetClass) {
+		try {
+			ClassLoader classLoader = targetClass.getClassLoader();
+			if (classLoader != null && classLoader != this.pointcutClassLoader) {
+				return buildPointcutExpression(classLoader);
+			}
+		}
+		catch (Throwable ex) {
+			logger.debug("Failed to create fallback PointcutExpression", ex);
+		}
+		return null;
 	}
 
 	private RuntimeTestWalker getRuntimeTestWalker(ShadowMatch shadowMatch) {
 		if (shadowMatch instanceof DefensiveShadowMatch) {
-			return new RuntimeTestWalker(((DefensiveShadowMatch)shadowMatch).primary);
+			return new RuntimeTestWalker(((DefensiveShadowMatch) shadowMatch).primary);
 		}
 		return new RuntimeTestWalker(shadowMatch);
 	}
@@ -395,44 +400,51 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		if (shadowMatch == null) {
 			synchronized (this.shadowMatchCache) {
 				// Not found - now check again with full lock...
+				PointcutExpression fallbackExpression = null;
 				Method methodToMatch = targetMethod;
-				PointcutExpression fallbackPointcutExpression = null;
-				shadowMatch = this.shadowMatchCache.get(methodToMatch);
+				shadowMatch = this.shadowMatchCache.get(targetMethod);
 				if (shadowMatch == null) {
 					try {
-						shadowMatch = this.pointcutExpression.matchesMethodExecution(targetMethod);
+						shadowMatch = this.pointcutExpression.matchesMethodExecution(methodToMatch);
 					}
-					catch (ReflectionWorld.ReflectionWorldException ex) {
+					catch (ReflectionWorldException ex) {
 						// Failed to introspect target method, probably because it has been loaded
-						// in a special ClassLoader. Let's try the original method instead...
+						// in a special ClassLoader. Let's try the declaring ClassLoader instead...
 						try {
-							fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
-							shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
-						} catch (ReflectionWorld.ReflectionWorldException e) {
-							if (targetMethod == originalMethod) {
-								shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+							fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+							if (fallbackExpression != null) {
+								shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
 							}
-							else {
-								try {
-									shadowMatch = this.pointcutExpression.matchesMethodExecution(originalMethod);
-								}
-								catch (ReflectionWorld.ReflectionWorldException ex2) {
-									// Could neither introspect the target class nor the proxy class ->
-									// let's simply consider this method as non-matching.
-									methodToMatch = originalMethod;
-									fallbackPointcutExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
-									try {
-										shadowMatch = fallbackPointcutExpression.matchesMethodExecution(methodToMatch);
-									} catch (ReflectionWorld.ReflectionWorldException e2) {
-										shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
-									}
+						}
+						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 ex4) {
+								fallbackExpression = null;
+							}
 						}
 					}
-					if (shadowMatch.maybeMatches() && fallbackPointcutExpression!=null) {
+					if (shadowMatch == null) {
+						shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+					}
+					else if (shadowMatch.maybeMatches() && fallbackExpression != null) {
 						shadowMatch = new DefensiveShadowMatch(shadowMatch,
-								fallbackPointcutExpression.matchesMethodExecution(methodToMatch));
+								fallbackExpression.matchesMethodExecution(methodToMatch));
 					}
 					this.shadowMatchCache.put(targetMethod, shadowMatch);
 				}
@@ -494,10 +506,10 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 
 
 	/**
-	 * Handler for the Spring-specific <code>bean()</code> pointcut designator
+	 * Handler for the Spring-specific {@code bean()} pointcut designator
 	 * extension to AspectJ.
 	 * <p>This handler must be added to each pointcut object that needs to
-	 * handle the <code>bean()</code> PCD. Matching context is obtained
+	 * handle the {@code bean()} PCD. Matching context is obtained
 	 * automatically by examining a thread local variable and therefore a matching
 	 * context need not be set on the pointcut.
 	 */
@@ -550,11 +562,11 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 			return false;
 		}
 
-		private FuzzyBoolean contextMatch(Class targetType) {
+		private FuzzyBoolean contextMatch(Class<?> targetType) {
 			String advisedBeanName = getCurrentProxiedBeanName();
 			if (advisedBeanName == null) {  // no proxy creation in progress
 				// abstain; can't return YES, since that will make pointcut with negation fail
-				return FuzzyBoolean.MAYBE; 
+				return FuzzyBoolean.MAYBE;
 			}
 			if (BeanFactoryUtils.isGeneratedBeanName(advisedBeanName)) {
 				return FuzzyBoolean.NO;
@@ -600,9 +612,11 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		this.shadowMatchCache = new ConcurrentHashMap<Method, ShadowMatch>(32);
 	}
 
+
 	private static class DefensiveShadowMatch implements ShadowMatch {
 
 		private final ShadowMatch primary;
+
 		private final ShadowMatch other;
 
 		public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
@@ -611,31 +625,30 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		}
 
 		public boolean alwaysMatches() {
-			return primary.alwaysMatches();
+			return this.primary.alwaysMatches();
 		}
 
 		public boolean maybeMatches() {
-			return primary.maybeMatches();
+			return this.primary.maybeMatches();
 		}
 
 		public boolean neverMatches() {
-			return primary.neverMatches();
+			return this.primary.neverMatches();
 		}
 
-		public JoinPointMatch matchesJoinPoint(Object thisObject,
-				Object targetObject, Object[] args) {
+		public JoinPointMatch matchesJoinPoint(Object thisObject, Object targetObject, Object[] args) {
 			try {
-				return primary.matchesJoinPoint(thisObject, targetObject, args);
-			} catch (ReflectionWorldException e) {
-				return other.matchesJoinPoint(thisObject, targetObject, args);
+				return this.primary.matchesJoinPoint(thisObject, targetObject, args);
+			}
+			catch (ReflectionWorldException ex) {
+				return this.other.matchesJoinPoint(thisObject, targetObject, args);
 			}
 		}
 
 		public void setMatchingContext(MatchingContext aMatchContext) {
-			primary.setMatchingContext(aMatchContext);
-			other.setMatchingContext(aMatchContext);
+			this.primary.setMatchingContext(aMatchContext);
+			this.other.setMatchingContext(aMatchContext);
 		}
-
 	}
 
 }

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -21,10 +21,11 @@ import org.springframework.aop.support.AbstractGenericPointcutAdvisor;
 
 /**
  * Spring AOP Advisor that can be used for any AspectJ pointcut expression.
- * 
+ *
  * @author Rob Harrop
  * @since 2.0
  */
+@SuppressWarnings("serial")
 public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor {
 
 	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
@@ -38,24 +39,24 @@ public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdv
 		this.pointcut.setExpression(expression);
 	}
 
+	public String getExpression() {
+		return this.pointcut.getExpression();
+	}
+
 	public void setLocation(String location) {
 		this.pointcut.setLocation(location);
 	}
 
-	public void setParameterTypes(Class[] types) {
-		this.pointcut.setParameterTypes(types);
-	}
-
-	public void setParameterNames(String[] names) {
-		this.pointcut.setParameterNames(names);
-	}
-
 	public String getLocation() {
 		return this.pointcut.getLocation();
 	}
 
-	public String getExpression() {
-		return this.pointcut.getExpression();
+	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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -30,14 +30,14 @@ import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
  * @since 2.0
  */
 public abstract class AspectJProxyUtils {
-	
+
 	/**
 	 * Add special advisors if necessary to work with a proxy chain that contains AspectJ advisors.
 	 * This will expose the current Spring AOP invocation (necessary for some AspectJ pointcut matching)
 	 * and make available the current AspectJ JoinPoint. The call will have no effect if there are no
 	 * AspectJ advisors in the advisor chain.
 	 * @param advisors Advisors available
-	 * @return <code>true</code> if any special {@link Advisor Advisors} were added, otherwise <code>false</code>.
+	 * @return {@code true} if any special {@link Advisor Advisors} were added, otherwise {@code false}.
 	 */
 	public static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {
 		// Don't add advisors to an empty list; may indicate that proxying is just not required
@@ -64,8 +64,8 @@ public abstract class AspectJProxyUtils {
 	 */
 	private static boolean isAspectJAdvice(Advisor advisor) {
 		return (advisor instanceof InstantiationModelAwarePointcutAdvisor ||
-			   advisor.getAdvice() instanceof AbstractAspectJAdvice ||
-			   (advisor instanceof PointcutAdvisor &&
+				advisor.getAdvice() instanceof AbstractAspectJAdvice ||
+				(advisor instanceof PointcutAdvisor &&
 						 ((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut));
 	}
 

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -27,13 +27,13 @@ import org.aspectj.bridge.IMessageHandler;
  * Implementation of AspectJ's {@link IMessageHandler} interface that
  * routes AspectJ weaving messages through the same logging system as the
  * regular Spring messages.
- * 
+ *
  * <p>Pass the option...
  *
  * <p><code class="code">-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler</code>
  *
  * <p>to the weaver; for example, specifying the following in a
- * "<code>META-INF/aop.xml</code> file:
+ * "{@code META-INF/aop.xml} file:
  *
  * <p><code class="code">&lt;weaver options="..."/&gt;</code>
  *
@@ -44,51 +44,45 @@ import org.aspectj.bridge.IMessageHandler;
 public class AspectJWeaverMessageHandler implements IMessageHandler {
 
 	private static final String AJ_ID = "[AspectJ] ";
-	
-	private static final Log LOGGER = LogFactory.getLog("AspectJ Weaver");
-	
+
+	private static final Log logger = LogFactory.getLog("AspectJ Weaver");
+
 
 	public boolean handleMessage(IMessage message) throws AbortException {
 		Kind messageKind = message.getKind();
-
-		if (LOGGER.isDebugEnabled() || LOGGER.isTraceEnabled()) {
-			if (messageKind == IMessage.DEBUG) {
-				LOGGER.debug(makeMessageFor(message));
-				return true;
-			}
-		} 
-		
-		if (LOGGER.isInfoEnabled()) {
-			if ((messageKind == IMessage.INFO) || (messageKind == IMessage.WEAVEINFO)) {
-				LOGGER.info(makeMessageFor(message));
-				return true;
-			}
-		} 
-		
-		if (LOGGER.isWarnEnabled()) {
-			if (messageKind == IMessage.WARNING) {
-				LOGGER.warn(makeMessageFor(message));
+		if (messageKind == IMessage.DEBUG) {
+			if (logger.isDebugEnabled()) {
+				logger.debug(makeMessageFor(message));
 				return true;
 			}
 		}
-		
-		if (LOGGER.isErrorEnabled()) {
-			if (messageKind == IMessage.ERROR) {
-				LOGGER.error(makeMessageFor(message));
+		else if (messageKind == IMessage.INFO || messageKind == IMessage.WEAVEINFO) {
+			if (logger.isInfoEnabled()) {
+				logger.info(makeMessageFor(message));
 				return true;
 			}
 		}
-		
-		if (LOGGER.isFatalEnabled()) {
-			if (messageKind == IMessage.ABORT) {
-				LOGGER.fatal(makeMessageFor(message));
+		else if (messageKind == IMessage.WARNING) {
+			if (logger.isWarnEnabled()) {
+				logger.warn(makeMessageFor(message));
+				return true;
+			}
+		}
+		else if (messageKind == IMessage.ERROR) {
+			if (logger.isErrorEnabled()) {
+				logger.error(makeMessageFor(message));
+				return true;
+			}
+		}
+		else if (messageKind == IMessage.ABORT) {
+			if (logger.isFatalEnabled()) {
+				logger.fatal(makeMessageFor(message));
 				return true;
 			}
 		}
-		
 		return false;
 	}
-	
+
 	private String makeMessageFor(IMessage aMessage) {
 		return AJ_ID + aMessage.getMessage();
 	}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -34,7 +34,7 @@ import org.springframework.aop.support.DelegatingIntroductionInterceptor;
  */
 public class DeclareParentsAdvisor implements IntroductionAdvisor {
 
-	private final Class introducedInterface;
+	private final Class<?> introducedInterface;
 
 	private final ClassFilter typePatternClassFilter;
 
@@ -47,8 +47,8 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param defaultImpl the default implementation class
 	 */
-	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Class defaultImpl) {
-		this(interfaceType, typePattern, defaultImpl, 
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> defaultImpl) {
+		this(interfaceType, typePattern, defaultImpl,
 			 new DelegatePerTargetObjectIntroductionInterceptor(defaultImpl, interfaceType));
 	}
 
@@ -58,8 +58,8 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param delegateRef the delegate implementation object
 	 */
-	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Object delegateRef) {
-		this(interfaceType, typePattern, delegateRef.getClass(), 
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Object delegateRef) {
+		this(interfaceType, typePattern, delegateRef.getClass(),
 			 new DelegatingIntroductionInterceptor(delegateRef));
 	}
 
@@ -71,13 +71,13 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param implementationClass implementation class
 	 * @param advice delegation advice
 	 */
-	private DeclareParentsAdvisor(Class interfaceType, String typePattern, Class implementationClass, Advice advice) {
+	private DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> implementationClass, Advice advice) {
 		this.introducedInterface = interfaceType;
 		ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);
 
 		// Excludes methods implemented.
 		ClassFilter exclusion = new ClassFilter() {
-			public boolean matches(Class clazz) {
+			public boolean matches(Class<?> clazz) {
 				return !(introducedInterface.isAssignableFrom(clazz));
 			}
 		};
@@ -103,8 +103,8 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 		return this.advice;
 	}
 
-	public Class[] getInterfaces() {
-		return new Class[] {this.introducedInterface};
+	public Class<?>[] getInterfaces() {
+		return new Class<?>[] {this.introducedInterface};
 	}
 
 }

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -34,11 +34,11 @@ import org.springframework.util.Assert;
  * Implementation of AspectJ ProceedingJoinPoint interface
  * wrapping an AOP Alliance MethodInvocation.
  *
- * <p><b>Note</b>: the <code>getThis()</code> method returns the current Spring AOP proxy.
- * The <code>getTarget()</code> method returns the current Spring AOP target (which may be
- * <code>null</code> if there is no target), and is a plain POJO without any advice.
+ * <p><b>Note</b>: the {@code getThis()} method returns the current Spring AOP proxy.
+ * The {@code getTarget()} method returns the current Spring AOP target (which may be
+ * {@code null} if there is no target), and is a plain POJO without any advice.
  * <b>If you want to call the object and have the advice take effect, use
- * <code>getThis()</code>.</b> A common example is casting the object to an
+ * {@code getThis()}.</b> A common example is casting the object to an
  * introduced interface in the implementation of an introduction.
  *
  * <p>Of course there is no such distinction between target and proxy in AspectJ.
@@ -50,7 +50,7 @@ import org.springframework.util.Assert;
  * @since 2.0
  */
 public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {
-	
+
 	private final ProxyMethodInvocation methodInvocation;
 
 	private Object[] defensiveCopyOfArgs;
@@ -92,14 +92,14 @@ public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint,
 	}
 
 	/**
-	 * Returns the Spring AOP proxy. Cannot be <code>null</code>.
+	 * Returns the Spring AOP proxy. Cannot be {@code null}.
 	 */
 	public Object getThis() {
 		return this.methodInvocation.getProxy();
 	}
 
 	/**
-	 * Returns the Spring AOP target. May be <code>null</code> if there is no target.
+	 * Returns the Spring AOP target. May be {@code null} if there is no target.
 	 */
 	public Object getTarget() {
 		return this.methodInvocation.getThis();

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,6 +18,8 @@ package org.springframework.aop.aspectj;
 
 import java.lang.reflect.Field;
 
+import org.aspectj.weaver.ReferenceType;
+import org.aspectj.weaver.ReferenceTypeDelegate;
 import org.aspectj.weaver.ResolvedType;
 import org.aspectj.weaver.ast.And;
 import org.aspectj.weaver.ast.Call;
@@ -30,6 +32,7 @@ import org.aspectj.weaver.ast.Not;
 import org.aspectj.weaver.ast.Or;
 import org.aspectj.weaver.ast.Test;
 import org.aspectj.weaver.internal.tools.MatchingContextBasedTest;
+import org.aspectj.weaver.reflect.ReflectionBasedReferenceTypeDelegate;
 import org.aspectj.weaver.reflect.ReflectionVar;
 import org.aspectj.weaver.reflect.ShadowMatchImpl;
 import org.aspectj.weaver.tools.ShadowMatch;
@@ -39,12 +42,12 @@ import org.springframework.util.ReflectionUtils;
 
 /**
  * This class encapsulates some AspectJ internal knowledge that should be
- * pushed back into the AspectJ project in a future release. 
+ * pushed back into the AspectJ project in a future release.
  *
  * <p>It relies on implementation specific knowledge in AspectJ to break
  * encapsulation and do something AspectJ was not designed to do: query
  * the types of runtime tests that will be performed. The code here should
- * migrate to <code>ShadowMatch.getVariablesInvolvedInRuntimeTest()</code>
+ * migrate to {@code ShadowMatch.getVariablesInvolvedInRuntimeTest()}
  * or some similar operation.
  *
  * <p>See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=151593"/>.
@@ -55,25 +58,36 @@ import org.springframework.util.ReflectionUtils;
  */
 class RuntimeTestWalker {
 
+	private static final Field residualTestField;
+
+	private static final Field varTypeField;
+
+	private static final Field myClassField;
+
+
+	static {
+		try {
+			residualTestField = ShadowMatchImpl.class.getDeclaredField("residualTest");
+			varTypeField = ReflectionVar.class.getDeclaredField("varType");
+			myClassField = ReflectionBasedReferenceTypeDelegate.class.getDeclaredField("myClass");
+		}
+		catch (NoSuchFieldException ex) {
+			throw new IllegalStateException("The version of aspectjtools.jar / aspectjweaver.jar " +
+					"on the classpath is incompatible with this version of Spring: " + ex);
+		}
+	}
+
+
 	private final Test runtimeTest;
 
 
 	public RuntimeTestWalker(ShadowMatch shadowMatch) {
-		ShadowMatchImpl shadowMatchImplementation = (ShadowMatchImpl) shadowMatch;
 		try {
-			Field testField = shadowMatchImplementation.getClass().getDeclaredField("residualTest");
-			ReflectionUtils.makeAccessible(testField);
-			this.runtimeTest = (Test) testField.get(shadowMatch);
+			ReflectionUtils.makeAccessible(residualTestField);
+			this.runtimeTest = (Test) residualTestField.get(shadowMatch);
 		}
-		catch (NoSuchFieldException noSuchFieldEx) {
-			throw new IllegalStateException("The version of aspectjtools.jar / aspectjweaver.jar " +
-					"on the classpath is incompatible with this version of Spring: Expected field " +
-					"'runtimeTest' is not present on ShadowMatchImpl class.");
-		}
-		catch (IllegalAccessException illegalAccessEx) {
-			// Famous last words... but I don't see how this can happen given the
-			// makeAccessible call above
-			throw new IllegalStateException("Unable to access ShadowMatchImpl.residualTest field");
+		catch (IllegalAccessException ex) {
+			throw new IllegalStateException(ex);
 		}
 	}
 
@@ -87,12 +101,12 @@ class RuntimeTestWalker {
 				new SubtypeSensitiveVarTypeTestVisitor().testsSubtypeSensitiveVars(this.runtimeTest));
 	}
 
-	public boolean testThisInstanceOfResidue(Class thisClass) {
+	public boolean testThisInstanceOfResidue(Class<?> thisClass) {
 		return (this.runtimeTest != null &&
 				new ThisInstanceOfResidueTestVisitor(thisClass).thisInstanceOfMatches(this.runtimeTest));
 	}
 
-	public boolean testTargetInstanceOfResidue(Class targetClass) {
+	public boolean testTargetInstanceOfResidue(Class<?> targetClass) {
 		return (this.runtimeTest != null &&
 				new TargetInstanceOfResidueTestVisitor(targetClass).targetInstanceOfMatches(this.runtimeTest));
 	}
@@ -137,22 +151,14 @@ class RuntimeTestWalker {
 
 		public void visit(MatchingContextBasedTest matchingContextTest) {
 		}
-		
+
 		protected int getVarType(ReflectionVar v) {
 			try {
-				Field varTypeField = ReflectionVar.class.getDeclaredField("varType");
 				ReflectionUtils.makeAccessible(varTypeField);
 				return (Integer) varTypeField.get(v);
 			}
-			catch (NoSuchFieldException noSuchFieldEx) {
-				throw new IllegalStateException("the version of aspectjtools.jar / aspectjweaver.jar " +
-						"on the classpath is incompatible with this version of Spring:- expected field " +
-						"'varType' is not present on ReflectionVar class");
-			}
-			catch (IllegalAccessException illegalAccessEx) {
-				// Famous last words... but I don't see how this can happen given the
-				// makeAccessible call above
-				throw new IllegalStateException("Unable to access ReflectionVar.varType field");
+			catch (IllegalAccessException ex) {
+				throw new IllegalStateException(ex);
 			}
 		}
 	}
@@ -160,31 +166,48 @@ class RuntimeTestWalker {
 
 	private static abstract class InstanceOfResidueTestVisitor extends TestVisitorAdapter {
 
-		private Class matchClass;
-		private boolean matches;
-		private int matchVarType;
+		private final Class<?> matchClass;
 
-		public InstanceOfResidueTestVisitor(Class matchClass, boolean defaultMatches, int matchVarType) {
+		private boolean matches;
+
+		private final int matchVarType;
+
+		public InstanceOfResidueTestVisitor(Class<?> matchClass, boolean defaultMatches, int matchVarType) {
 			this.matchClass = matchClass;
 			this.matches = defaultMatches;
 			this.matchVarType = matchVarType;
 		}
-		
+
 		public boolean instanceOfMatches(Test test) {
 			test.accept(this);
-			return matches;
+			return this.matches;
 		}
 
 		@Override
 		public void visit(Instanceof i) {
-			ResolvedType type = (ResolvedType) i.getType();
 			int varType = getVarType((ReflectionVar) i.getVar());
 			if (varType != this.matchVarType) {
 				return;
 			}
+			Class<?> typeClass = null;
+			ResolvedType type = (ResolvedType) i.getType();
+			if (type instanceof ReferenceType) {
+				ReferenceTypeDelegate delegate = ((ReferenceType) type).getDelegate();
+				if (delegate instanceof ReflectionBasedReferenceTypeDelegate) {
+					try {
+						ReflectionUtils.makeAccessible(myClassField);
+						typeClass = (Class<?>) myClassField.get(delegate);
+					}
+					catch (IllegalAccessException ex) {
+						throw new IllegalStateException(ex);
+					}
+				}
+			}
 			try {
-				Class typeClass = ClassUtils.forName(type.getName(), this.matchClass.getClassLoader());
-				// Don't use ReflectionType.isAssignableFrom() as it won't be aware of (Spring) mixins
+				// Don't use ResolvedType.isAssignableFrom() as it won't be aware of (Spring) mixins
+				if (typeClass == null) {
+					typeClass = ClassUtils.forName(type.getName(), this.matchClass.getClassLoader());
+				}
 				this.matches = typeClass.isAssignableFrom(this.matchClass);
 			}
 			catch (ClassNotFoundException ex) {
@@ -199,7 +222,7 @@ class RuntimeTestWalker {
 	 */
 	private static class TargetInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
 
-		public TargetInstanceOfResidueTestVisitor(Class targetClass) {
+		public TargetInstanceOfResidueTestVisitor(Class<?> targetClass) {
 			super(targetClass, false, TARGET_VAR);
 		}
 
@@ -214,7 +237,7 @@ class RuntimeTestWalker {
 	 */
 	private static class ThisInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
 
-		public ThisInstanceOfResidueTestVisitor(Class thisClass) {
+		public ThisInstanceOfResidueTestVisitor(Class<?> thisClass) {
 			super(thisClass, true, THIS_VAR);
 		}
 
@@ -228,20 +251,23 @@ class RuntimeTestWalker {
 	private static class SubtypeSensitiveVarTypeTestVisitor extends TestVisitorAdapter {
 
 		private final Object thisObj = new Object();
+
 		private final Object targetObj = new Object();
+
 		private final Object[] argsObjs = new Object[0];
+
 		private boolean testsSubtypeSensitiveVars = false;
 
 		public boolean testsSubtypeSensitiveVars(Test aTest) {
 			aTest.accept(this);
 			return this.testsSubtypeSensitiveVars;
 		}
-		
+
 		@Override
 		public void visit(Instanceof i) {
 			ReflectionVar v = (ReflectionVar) i.getVar();
-			Object varUnderTest = v.getBindingAtJoinPoint(thisObj,targetObj,argsObjs);
-			if ((varUnderTest == thisObj) || (varUnderTest == targetObj)) {
+			Object varUnderTest = v.getBindingAtJoinPoint(this.thisObj, this.targetObj, this.argsObjs);
+			if (varUnderTest == this.thisObj || varUnderTest == this.targetObj) {
 				this.testsSubtypeSensitiveVars = true;
 			}
 		}
@@ -251,7 +277,7 @@ class RuntimeTestWalker {
 			// If you thought things were bad before, now we sink to new levels of horror...
 			ReflectionVar v = (ReflectionVar) hasAnn.getVar();
 			int varType = getVarType(v);
-				if ((varType == AT_THIS_VAR) || (varType == AT_TARGET_VAR) || (varType == AT_ANNOTATION_VAR)) {
+			if (varType == AT_THIS_VAR || varType == AT_TARGET_VAR || varType == AT_ANNOTATION_VAR) {
 				this.testsSubtypeSensitiveVars = true;
 			}
 		}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -42,7 +42,7 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	}
 
 	/**
-	 * Return the specified aspect class (never <code>null</code>).
+	 * Return the specified aspect class (never {@code null}).
 	 */
 	public final Class getAspectClass() {
 		return this.aspectClass;
@@ -81,7 +81,7 @@ public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
 	 * Determine a fallback order for the case that the aspect instance
 	 * does not express an instance-specific order through implementing
 	 * the {@link org.springframework.core.Ordered} interface.
-	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
 	 * @param aspectClass the aspect class
 	 */
 	protected int getOrderForAspectClass(Class<?> aspectClass) {

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -30,7 +30,7 @@ import org.springframework.util.Assert;
  * @see SimpleAspectInstanceFactory
  */
 public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
-	
+
 	private final Object aspectInstance;
 
 
@@ -71,7 +71,7 @@ public class SingletonAspectInstanceFactory implements AspectInstanceFactory {
 	 * Determine a fallback order for the case that the aspect instance
 	 * does not express an instance-specific order through implementing
 	 * the {@link org.springframework.core.Ordered} interface.
-	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
 	 * @param aspectClass the aspect class
 	 */
 	protected int getOrderForAspectClass(Class<?> aspectClass) {

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -47,11 +47,11 @@ public class TypePatternClassFilter implements ClassFilter {
 	}
 
 	/**
-	 * Create a fully configured {@link TypePatternClassFilter} using the  
+	 * 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</code> is <code>null</code>
-	 * or is recognized as invalid 
+	 * @throws IllegalArgumentException if the supplied {@code typePattern} is {@code null}
+	 * or is recognized as invalid
 	 */
 	public TypePatternClassFilter(String typePattern) {
 		setTypePattern(typePattern);
@@ -68,12 +68,12 @@ public class TypePatternClassFilter implements ClassFilter {
 	 * <code class="code">
 	 * org.springframework.beans.ITestBean+
 	 * </code>
-	 * This will match the <code>ITestBean</code> interface and any class
+	 * This will match the {@code ITestBean} interface and any class
 	 * 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</code> is <code>null</code>
-	 * or is recognized as invalid 
+	 * @throws IllegalArgumentException if the supplied {@code typePattern} is {@code null}
+	 * or is recognized as invalid
 	 */
 	public void setTypePattern(String typePattern) {
 		Assert.notNull(typePattern);
@@ -102,9 +102,9 @@ public class TypePatternClassFilter implements ClassFilter {
 
 	/**
 	 * If a type pattern has been specified in XML, the user cannot
-	 * write <code>and</code> as "&&" (though &amp;&amp; will work).
-	 * We also allow <code>and</code> between two sub-expressions.
-	 * <p>This method converts back to <code>&&</code> for the AspectJ pointcut parser.
+	 * write {@code and} as "&&" (though &amp;&amp; will work).
+	 * We also allow {@code and} between two sub-expressions.
+	 * <p>This method converts back to {@code &&} for the AspectJ pointcut parser.
 	 */
 	private String replaceBooleanOperators(String pcExpr) {
 		pcExpr = StringUtils.replace(pcExpr," and "," && ");

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -58,7 +58,7 @@ import org.springframework.util.StringUtils;
  * @since 2.0
  */
 public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {
-	
+
 	protected static final ParameterNameDiscoverer ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER =
 			new AspectJAnnotationParameterNameDiscoverer();
 
@@ -121,7 +121,7 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 
 	/**
 	 * We need to detect this as "code-style" AspectJ aspects should not be
-	 * interpreted by Spring AOP. 
+	 * interpreted by Spring AOP.
 	 */
 	private boolean compiledByAjc(Class<?> clazz) {
 		// The AJTypeSystem goes to great lengths to provide a uniform appearance between code-style and
@@ -154,11 +154,11 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
 			throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
 					"This is not supported in Spring AOP.");
-		}	
+		}
 	}
 
 	/**
-	 * The pointcut and advice annotations both have an "argNames" member which contains a 
+	 * 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.
 	 */
@@ -169,13 +169,13 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 		if (pointcutParameterNames != null) {
 			pointcutParameterTypes = extractPointcutParameterTypes(pointcutParameterNames,annotatedMethod);
 		}
-		
+
 		AspectJExpressionPointcut ajexp =
 				new AspectJExpressionPointcut(declarationScope,pointcutParameterNames,pointcutParameterTypes);
 		ajexp.setLocation(annotatedMethod.toString());
 		return ajexp;
 	}
-	
+
 	/**
 	 * 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
@@ -326,10 +326,10 @@ public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFac
 				return names;
 			}
 			else {
-				return null; 				
+				return null;
 			}
 		}
-		
+
 		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,11 +1,11 @@
 /*
- * Copyright 2002-2009 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -45,6 +45,7 @@ import org.springframework.util.Assert;
  * @since 2.0
  * @see org.springframework.aop.aspectj.annotation.AspectJAdvisorFactory
  */
+@SuppressWarnings("serial")
 public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
 
 	private List<Pattern> includePatterns;
@@ -66,7 +67,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 	}
 
 	public void setAspectJAdvisorFactory(AspectJAdvisorFactory aspectJAdvisorFactory) {
-		Assert.notNull(this.aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
+		Assert.notNull(aspectJAdvisorFactory, "AspectJAdvisorFactory must not be null");
 		this.aspectJAdvisorFactory = aspectJAdvisorFactory;
 	}
 
@@ -88,7 +89,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 	}
 
 	@Override
-	protected boolean isInfrastructureClass(Class beanClass) {
+	protected boolean isInfrastructureClass(Class<?> beanClass) {
 		// Previously we setProxyTargetClass(true) in the constructor, but that has too
 		// broad an impact. Instead we now override isInfrastructureClass to avoid proxying
 		// aspects. I'm not entirely happy with that as there is no good reason not
@@ -103,7 +104,7 @@ public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorA
 	/**
 	 * Check whether the given aspect bean is eligible for auto-proxying.
 	 * <p>If no &lt;aop:include&gt; elements were used then "includePatterns" will be
-	 * <code>null</code> and all beans are included. If "includePatterns" is non-null,
+	 * {@code null} and all beans are included. If "includePatterns" is non-null,
 	 * then one of the patterns must match.
 	 */
 	protected boolean isEligibleAspectBean(String beanName) {

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -40,7 +40,7 @@ public interface AspectJAdvisorFactory {
 	/**
 	 * Determine whether or not the given class is an aspect, as reported
 	 * by AspectJ's {@link org.aspectj.lang.reflect.AjTypeSystem}.
-	 * <p>Will simply return <code>false</code> if the supposed aspect is
+	 * <p>Will simply return {@code false} if the supposed aspect is
 	 * invalid (such as an extension of a concrete aspect class).
 	 * Will return true for some aspects that Spring AOP cannot process,
 	 * such as those with unsupported instantiation models.
@@ -75,7 +75,7 @@ public interface AspectJAdvisorFactory {
 	 * @param aif the aspect instance factory
 	 * @param declarationOrderInAspect the declaration order within the aspect
 	 * @param aspectName the name of the aspect
-	 * @return <code>null</code> if the method is not an AspectJ advice method
+	 * @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
 	 */
@@ -89,7 +89,7 @@ public interface AspectJAdvisorFactory {
 	 * @param aif the aspect instance factory
 	 * @param declarationOrderInAspect the declaration order within the aspect
 	 * @param aspectName the name of the aspect
-	 * @return <code>null</code> if the method is not an AspectJ advice method
+	 * @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
 	 * @see org.springframework.aop.aspectj.AspectJAroundAdvice

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -46,6 +46,7 @@ import org.springframework.util.ClassUtils;
  * @see #getProxy(ClassLoader)
  * @see org.springframework.aop.framework.ProxyFactory
  */
+@SuppressWarnings("serial")
 public class AspectJProxyFactory extends ProxyCreatorSupport {
 
 	/** Cache for singleton aspect instances */
@@ -72,7 +73,7 @@ public class AspectJProxyFactory extends ProxyCreatorSupport {
 	}
 
 	/**
-	 * Create a new <code>AspectJProxyFactory</code>.
+	 * Create a new {@code AspectJProxyFactory}.
 	 * No target, only interfaces. Must add interceptors.
 	 */
 	public AspectJProxyFactory(Class[] interfaces) {

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -55,8 +55,8 @@ public class AspectMetadata {
 	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 
+	 * 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;
@@ -109,7 +109,7 @@ public class AspectMetadata {
 	}
 
 	/**
-	 * Extract contents from String of form <code>pertarget(contents)</code>.
+	 * 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
@@ -144,7 +144,7 @@ public class AspectMetadata {
 
 	/**
 	 * Return a Spring pointcut expression for a singleton aspect.
-	 * (e.g. <code>Pointcut.TRUE</code> if it's a singleton).
+	 * (e.g. {@code Pointcut.TRUE} if it's a singleton).
 	 */
 	public Pointcut getPerClausePointcut() {
 		return this.perClausePointcut;

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * 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
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,8 +18,11 @@ package org.springframework.aop.aspectj.annotation;
 
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.beans.factory.support.AbstractBeanFactory;
 import org.springframework.core.Ordered;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.annotation.Order;
+import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
@@ -27,7 +30,7 @@ import org.springframework.util.ClassUtils;
  * backed by a Spring {@link org.springframework.beans.factory.BeanFactory}.
  *
  * <p>Note that this may instantiate multiple times if using a prototype,
- * which probably won't give the semantics you expect. 
+ * which probably won't give the semantics you expect.
  * Use a {@link LazySingletonAspectInstanceFactoryDecorator}
  * to wrap this to ensure only one new aspect comes back.
  *
@@ -56,7 +59,7 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name) {
 		this(beanFactory, name, beanFactory.getType(name));
 	}
-	
+
 	/**
 	 * Create a BeanFactoryAspectInstanceFactory, providing a type that AspectJ should
 	 * introspect to create AJType metadata. Use if the BeanFactory may consider the type
@@ -65,7 +68,9 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	 * @param name the name of the bean
 	 * @param type the type that should be introspected by AspectJ
 	 */
-	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class type) {
+	public BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class<?> type) {
+		Assert.notNull(beanFactory, "BeanFactory must not be null");
+		Assert.notNull(name, "Bean name must not be null");
 		this.beanFactory = beanFactory;
 		this.name = name;
 		this.aspectMetadata = new AspectMetadata(type, name);
@@ -77,18 +82,31 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 	}
 
 	public ClassLoader getAspectClassLoader() {
-		if (this.beanFactory instanceof ConfigurableBeanFactory) {
-			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
-		}
-		else {
-			return ClassUtils.getDefaultClassLoader();
-		}
+		return (this.beanFactory instanceof ConfigurableBeanFactory ?
+				((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader() :
+				ClassUtils.getDefaultClassLoader());
 	}
 
 	public AspectMetadata getAspectMetadata() {
 		return this.aspectMetadata;
 	}
 
+	public Object getAspectCreationMutex() {
+		if (this.beanFactory != null) {
+			if (this.beanFactory.isSingleton(this.name)) {
+				// Rely on singleton semantics provided by the factory -> no local lock.
+				return null;
+			}
+			else if (this.beanFactory instanceof AbstractBeanFactory) {
+				// 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 ((AbstractBeanFactory) this.beanFactory).getSingletonMutex();
+			}
+		}
+		return this;
+	}
+
 	/**
 	 * Determine the order for this factory's target aspect, either
 	 * an instance-specific order expressed through implementing the
@@ -105,7 +123,7 @@ public class BeanFactoryAspectInstanceFactory implements MetadataAwareAspectInst
 			if (Ordered.class.isAssignableFrom(type) && this.beanFactory.isSingleton(this.name)) {
 				return ((Ordered) this.beanFactory.getBean(this.name)).getOrder();
 			}
-			Order order = type.getAnnotation(Order.class);
+			Order order = AnnotationUtils.findAnnotation(type, Order.class);
 			if (order != null) {
 				return order.value();
 			}

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -41,30 +41,30 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		implements InstantiationModelAwarePointcutAdvisor, AspectJPrecedenceInformation {
 
 	private final AspectJExpressionPointcut declaredPointcut;
-	
+
 	private Pointcut pointcut;
-	
+
 	private final MetadataAwareAspectInstanceFactory aspectInstanceFactory;
-	
+
 	private final Method method;
-	
+
 	private final boolean lazy;
-	
+
 	private final AspectJAdvisorFactory atAspectJAdvisorFactory;
-	
+
 	private Advice instantiatedAdvice;
 
 	private int declarationOrder;
-	
+
 	private String aspectName;
-	
+
 	private Boolean isBeforeAdvice;
 
 	private Boolean isAfterAdvice;
 
 
-	public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af,  AspectJExpressionPointcut ajexp,
-			MetadataAwareAspectInstanceFactory aif,  Method method, int declarationOrderInAspect, String aspectName) {
+	public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp,
+			MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName) {
 
 		this.declaredPointcut = ajexp;
 		this.method = method;
@@ -72,12 +72,12 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		this.aspectInstanceFactory = aif;
 		this.declarationOrder = declarationOrderInAspect;
 		this.aspectName = aspectName;
-		
+
 		if (aif.getAspectMetadata().isLazilyInstantiated()) {
 			// Static part of the pointcut is a lazy type.
 			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.
@@ -103,13 +103,13 @@ class InstantiationModelAwarePointcutAdvisorImpl
 
 	/**
 	 * This is only of interest for Spring AOP: AspectJ instantiation semantics
-	 * are much richer. In AspectJ terminology, all a return of <code>true</code>
+	 * are much richer. In AspectJ terminology, all a return of {@code true}
 	 * means here is that the aspect is not a SINGLETON.
 	 */
 	public boolean isPerInstance() {
 		return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON);
 	}
-	
+
 	/**
 	 * Return the AspectJ AspectMetadata for this advisor.
 	 */
@@ -126,7 +126,7 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		}
 		return this.instantiatedAdvice;
 	}
-	
+
 	public boolean isLazy() {
 		return this.lazy;
 	}
@@ -140,7 +140,7 @@ class InstantiationModelAwarePointcutAdvisorImpl
 		return this.atAspectJAdvisorFactory.getAdvice(
 				this.method, pcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
 	}
-	
+
 	public MetadataAwareAspectInstanceFactory getAspectInstanceFactory() {
 		return this.aspectInstanceFactory;
 	}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * 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
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -42,11 +42,20 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 	}
 
 
-	public synchronized Object getAspectInstance() {
+	public Object getAspectInstance() {
 		if (this.materialized == null) {
-			synchronized (this) {
-				if (this.materialized == null) {
-					this.materialized = this.maaif.getAspectInstance();
+			Object mutex = this;
+			if (this.maaif instanceof BeanFactoryAspectInstanceFactory) {
+				mutex = ((BeanFactoryAspectInstanceFactory) this.maaif).getAspectCreationMutex();
+			}
+			if (mutex == null) {
+				this.materialized = this.maaif.getAspectInstance();
+			}
+			else {
+				synchronized (mutex) {
+					if (this.materialized == null) {
+						this.materialized = this.maaif.getAspectInstance();
+					}
 				}
 			}
 		}

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -26,6 +26,7 @@ import org.springframework.aop.framework.AopConfigException;
  * @author Rod Johnson
  * @since 2.0
  */
+@SuppressWarnings("serial")
 public class NotAnAtAspectException extends AopConfigException {
 
 	private Class<?> nonAspectClass;

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -144,7 +144,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 	 * for the given introduction field.
 	 * <p>Resulting Advisors will need to be evaluated for targets.
 	 * @param introductionField the field to introspect
-	 * @return <code>null</code> if not an Advisor
+	 * @return {@code null} if not an Advisor
 	 */
 	private Advisor getDeclareParentsAdvisor(Field introductionField) {
 		DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
@@ -203,7 +203,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
 			return null;
 		}
 
-		// If we get here, we know we have an AspectJ method. 
+		// If we get here, we know we have an AspectJ method.
 		// Check that it's an AspectJ-annotated class
 		if (!isAspect(candidateAspectClass)) {
 			throw new AopConfigException("Advice must be declared inside an aspect type: " +

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,6 +18,7 @@ package org.springframework.aop.aspectj.annotation;
 
 import org.springframework.aop.aspectj.SimpleAspectInstanceFactory;
 import org.springframework.core.Ordered;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.annotation.Order;
 
 /**
@@ -53,12 +54,12 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 	 * Determine a fallback order for the case that the aspect instance
 	 * does not express an instance-specific order through implementing
 	 * the {@link org.springframework.core.Ordered} interface.
-	 * <p>The default implementation simply returns <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
 	 * @param aspectClass the aspect class
 	 */
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
-		Order order = aspectClass.getAnnotation(Order.class);
+		Order order = AnnotationUtils.findAnnotation(aspectClass, Order.class);
 		if (order != null) {
 			return order.value();
 		}

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -18,6 +18,7 @@ package org.springframework.aop.aspectj.annotation;
 
 import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
 import org.springframework.core.Ordered;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.annotation.Order;
 
 /**
@@ -54,12 +55,12 @@ public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspect
 	/**
 	 * Check whether the aspect class carries an
 	 * {@link org.springframework.core.annotation.Order} annotation,
-	 * falling back to <code>Ordered.LOWEST_PRECEDENCE</code>.
+	 * falling back to {@code Ordered.LOWEST_PRECEDENCE}.
 	 * @see org.springframework.core.annotation.Order
 	 */
 	@Override
 	protected int getOrderForAspectClass(Class<?> aspectClass) {
-		Order order = aspectClass.getAnnotation(Order.class);
+		Order order = AnnotationUtils.findAnnotation(aspectClass, Order.class);
 		if (order != null) {
 			return order.value();
 		}

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

@@ -2,7 +2,7 @@
 /**
  *
  * Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
- * 
+ *
  * <p>Normally to be used through an AspectJAutoProxyCreator rather than directly.
  *
  */

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2008 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -16,8 +16,8 @@
 
 package org.springframework.aop.aspectj.autoproxy;
 
+import java.util.ArrayList;
 import java.util.Comparator;
-import java.util.LinkedList;
 import java.util.List;
 
 import org.aopalliance.aop.Advice;
@@ -43,6 +43,7 @@ import org.springframework.util.ClassUtils;
  * @author Ramnivas Laddad
  * @since 2.0
  */
+@SuppressWarnings("serial")
 public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
 
 	private static final Comparator DEFAULT_PRECEDENCE_COMPARATOR = new AspectJPrecedenceComparator();
@@ -66,29 +67,24 @@ public class AspectJAwareAdvisorAutoProxyCreator extends AbstractAdvisorAutoProx
 	@Override
 	@SuppressWarnings("unchecked")
 	protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
-		// build list for sorting
 		List<PartiallyComparableAdvisorHolder> partiallyComparableAdvisors =
-				new LinkedList<PartiallyComparableAdvisorHolder>();
+				new ArrayList<PartiallyComparableAdvisorHolder>(advisors.size());
 		for (Advisor element : advisors) {
 			partiallyComparableAdvisors.add(
 					new PartiallyComparableAdvisorHolder(element, DEFAULT_PRECEDENCE_COMPARATOR));
-		}		
-		
-		// sort it
+		}
 		List<PartiallyComparableAdvisorHolder> sorted =
-				(List<PartiallyComparableAdvisorHolder>) PartialOrder.sort(partiallyComparableAdvisors);
-		if (sorted == null) {
-			// TODO: work harder to give a better error message here.
-			throw new IllegalArgumentException("Advice precedence circularity error");
+				PartialOrder.sort(partiallyComparableAdvisors);
+		if (sorted != null) {
+			List<Advisor> result = new ArrayList<Advisor>(advisors.size());
+			for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
+				result.add(pcAdvisor.getAdvisor());
+			}
+			return result;
 		}
-		
-		// extract results again
-		List<Advisor> result = new LinkedList<Advisor>();
-		for (PartiallyComparableAdvisorHolder pcAdvisor : sorted) {
-			result.add(pcAdvisor.getAdvisor());
+		else {
+			return super.sortAdvisors(advisors);
 		}
-		
-		return result;
 	}
 
 	/**

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 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.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -27,15 +27,15 @@ import org.springframework.util.Assert;
 /**
  * Orders AspectJ advice/advisors by precedence (<i>not</i> invocation order).
  *
- * <p>Given two pieces of advice, <code>a</code> and <code>b</code>:
+ * <p>Given two pieces of advice, {@code a} and {@code b}:
  * <ul>
- *   <li>if <code>a</code> and <code>b</code> are defined in different
+ *   <li>if {@code a} and {@code b} are defined in different
  *   aspects, then the advice in the aspect with the lowest order
  *   value has the highest precedence</li>
- *   <li>if <code>a</code> and <code>b</code> are defined in the same
- *   aspect, then if one of <code>a</code> or <code>b</code> is a form of
+ *   <li>if {@code a} and {@code b} are defined in the same
+ *   aspect, then if one of {@code a} or {@code b} is a form of
  *   after advice, then the advice declared last in the aspect has the
- *   highest precedence. If neither <code>a</code> nor <code>b</code> is a
+ *   highest precedence. If neither {@code a} nor {@code b} is a
  *   form of after advice, then the advice declared first in the aspect has
  *   the highest precedence.</li>
  * </ul>
@@ -53,7 +53,6 @@ class AspectJPrecedenceComparator implements Comparator {
 	private static final int HIGHER_PRECEDENCE = -1;
 	private static final int SAME_PRECEDENCE = 0;
 	private static final int LOWER_PRECEDENCE = 1;
-	private static final int NOT_COMPARABLE = 0;
 
 	private final Comparator<? super Advisor> advisorComparator;
 
@@ -85,35 +84,25 @@ class AspectJPrecedenceComparator implements Comparator {
 
 		Advisor advisor1 = (Advisor) o1;
 		Advisor advisor2 = (Advisor) o2;
-
-		boolean oneOrOtherIsAfterAdvice =
-				(AspectJAopUtils.isAfterAdvice(advisor1) || AspectJAopUtils.isAfterAdvice(advisor2));
-		boolean oneOrOtherIsBeforeAdvice =
-				(AspectJAopUtils.isBeforeAdvice(advisor1) || AspectJAopUtils.isBeforeAdvice(advisor2));
-		if (oneOrOtherIsAfterAdvice && oneOrOtherIsBeforeAdvice) {
-			return NOT_COMPARABLE;
-		}
-		else {
-			int advisorPrecedence = this.advisorComparator.compare(advisor1, advisor2);
-			if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(advisor1, advisor2)) {
-				advisorPrecedence = comparePrecedenceWithinAspect(advisor1, advisor2);
-			}
-			return advisorPrecedence;
+		int advisorPrecedence = this.advisorComparator.compare(advisor1, advisor2);
+		if (advisorPrecedence == SAME_PRECEDENCE && declaredInSameAspect(advisor1, advisor2)) {
+			advisorPrecedence = comparePrecedenceWithinAspect(advisor1, advisor2);
 		}
+		return advisorPrecedence;
 	}
 
 	private int comparePrecedenceWithinAspect(Advisor advisor1, Advisor advisor2) {
 		boolean oneOrOtherIsAfterAdvice =
 				(AspectJAopUtils.isAfterAdvice(advisor1) || AspectJAopUtils.isAfterAdvice(advisor2));
 		int adviceDeclarationOrderDelta = getAspectDeclarationOrder(advisor1) - getAspectDeclarationOrder(advisor2);
-		
+
 		if (oneOrOtherIsAfterAdvice) {
 			// the advice declared last has higher precedence
 			if (adviceDeclarationOrderDelta < 0) {
 				// advice1 was declared before advice2
 				// so advice1 has lower precedence
 				return LOWER_PRECEDENCE;
-			} 
+			}
 			else if (adviceDeclarationOrderDelta == 0) {
 				return SAME_PRECEDENCE;
 			}
@@ -153,7 +142,7 @@ class AspectJPrecedenceComparator implements Comparator {
 	}
 
 	private int getAspectDeclarationOrder(Advisor anAdvisor) {
-		AspectJPrecedenceInformation precedenceInfo = 
+		AspectJPrecedenceInformation precedenceInfo =
 			AspectJAopUtils.getAspectJPrecedenceInformationFor(anAdvisor);
 		if (precedenceInfo != null) {
 			return precedenceInfo.getDeclarationOrder();

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

@@ -1,12 +1,11 @@
-
 /**
  *
  * AspectJ integration package. Includes Spring AOP advice implementations for AspectJ 5
  * annotation-style methods, and an AspectJExpressionPointcut: a Spring AOP Pointcut
  * implementation that allows use of the AspectJ pointcut expression language with the Spring AOP
  * runtime framework.
- * 
- * <p>Note that use of this package does <i>not</i> require the use of the <code>ajc</code> compiler
+ *
+ * <p>Note that use of this package does <i>not</i> require the use of the {@code ajc} compiler
  * or AspectJ load-time weaver. It is intended to enable the use of a valuable subset of AspectJ
  * functionality, with consistent semantics, with the proxy-based Spring AOP framework.
  *

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -40,7 +40,7 @@ import org.springframework.util.StringUtils;
  * to the resulting bean.
  *
  * <p>This base class controls the creation of the {@link ProxyFactoryBean} bean definition
- * and wraps the original as an inner-bean definition for the <code>target</code> property
+ * and wraps the original as an inner-bean definition for the {@code target} property
  * of {@link ProxyFactoryBean}.
  *
  * <p>Chaining is correctly handled, ensuring that only one {@link ProxyFactoryBean} definition
@@ -48,7 +48,7 @@ import org.springframework.util.StringUtils;
  * already created the {@link org.springframework.aop.framework.ProxyFactoryBean} then the
  * interceptor is simply added to the existing definition.
  *
- * <p>Subclasses have only to create the <code>BeanDefinition</code> to the interceptor that
+ * <p>Subclasses have only to create the {@code BeanDefinition} to the interceptor that
  * they wish to add.
  *
  * @author Rob Harrop
@@ -60,7 +60,7 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 
 	public final BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder definitionHolder, ParserContext parserContext) {
 		BeanDefinitionRegistry registry = parserContext.getRegistry();
-		
+
 		// get the root bean name - will be the name of the generated proxy factory bean
 		String existingBeanName = definitionHolder.getBeanName();
 		BeanDefinition targetDefinition = definitionHolder.getBeanDefinition();
@@ -118,7 +118,7 @@ public abstract class AbstractInterceptorDrivenBeanDefinitionDecorator implement
 	}
 
 	/**
-	 * Subclasses should implement this method to return the <code>BeanDefinition</code>
+	 * Subclasses should implement this method to return the {@code BeanDefinition}
 	 * for the interceptor they wish to apply to the bean being decorated.
 	 */
 	protected abstract BeanDefinition createInterceptorDefinition(Node node);

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -20,7 +20,7 @@ import org.springframework.beans.factory.parsing.ParseState;
 
 /**
  * {@link ParseState} entry representing an advice element.
- * 
+ *
  * @author Mark Fisher
  * @since 2.0
  */

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -25,7 +25,7 @@ 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>&lt;aop:advisor&gt;</code> tag and the component definition
+ * by the {@code &lt;aop:advisor&gt;} tag and the component definition
  * infrastructure.
  *
  * @author Rob Harrop

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2006 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -20,7 +20,7 @@ import org.springframework.beans.factory.parsing.ParseState;
 
 /**
  * {@link ParseState} entry representing an advisor.
- * 
+ *
  * @author Mark Fisher
  * @since 2.0
  */

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -31,10 +31,10 @@ import org.springframework.util.Assert;
 /**
  * Utility class for handling registration of AOP auto-proxy creators.
  *
- * <p>Only a single auto-proxy creator can be registered yet multiple concrete 
- * implementations are available. Therefore this class wraps a simple escalation 
+ * <p>Only a single auto-proxy creator can be registered yet multiple concrete
+ * implementations are available. Therefore this class wraps a simple escalation
  * protocol, allowing classes to request a particular auto-proxy creator and know
- * that class, <code>or a subclass thereof</code>, will eventually be resident
+ * that class, {@code or a subclass thereof}, will eventually be resident
  * in the application context.
  *
  * @author Rob Harrop

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2007 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -21,21 +21,21 @@ import org.springframework.beans.factory.xml.BeanDefinitionParser;
 import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
 
 /**
- * <code>NamespaceHandler</code> for the <code>aop</code> namespace.
+ * {@code NamespaceHandler} for the {@code aop} namespace.
  *
  * <p>Provides a {@link org.springframework.beans.factory.xml.BeanDefinitionParser} for the
- * <code>&lt;aop:config&gt;</code> tag. A <code>config</code> tag can include nested
- * <code>pointcut</code>, <code>advisor</code> and <code>aspect</code> tags.
+ * {@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</code> tag allows for creation of named
+ * <p>The {@code pointcut} tag allows for creation of named
  * {@link AspectJExpressionPointcut} beans using a simple syntax:
  * <pre class="code">
  * &lt;aop:pointcut id=&quot;getNameCalls&quot; expression=&quot;execution(* *..ITestBean.getName(..))&quot;/&gt;
  * </pre>
  *
- * <p>Using the <code>advisor</code> tag you can configure an {@link org.springframework.aop.Advisor}
+ * <p>Using the {@code advisor} tag you can configure an {@link org.springframework.aop.Advisor}
  * and have it applied to all relevant beans in you {@link org.springframework.beans.factory.BeanFactory}
- * automatically. The <code>advisor</code> tag supports both in-line and referenced
+ * automatically. The {@code advisor} tag supports both in-line and referenced
  * {@link org.springframework.aop.Pointcut Pointcuts}:
  *
  * <pre class="code">
@@ -56,8 +56,8 @@ public class AopNamespaceHandler extends NamespaceHandlerSupport {
 
 	/**
 	 * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
-	 * '<code>config</code>', '<code>spring-configured</code>', '<code>aspectj-autoproxy</code>'
-	 * and '<code>scoped-proxy</code>' tags.
+	 * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
+	 * and '{@code scoped-proxy}' tags.
 	 */
 	public void init() {
 		// In 2.0 XSD as well as in 2.1 XSD.

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2010 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -25,7 +25,7 @@ import org.springframework.beans.factory.xml.ParserContext;
 
 /**
  * Utility class for handling registration of auto-proxy creators used internally
- * by the '<code>aop</code>' namespace tags.
+ * by the '{@code aop}' namespace tags.
  *
  * <p>Only a single auto-proxy creator can be registered and multiple tags may wish
  * to register different concrete implementations. As such this class delegates to
@@ -42,12 +42,12 @@ import org.springframework.beans.factory.xml.ParserContext;
 public abstract class AopNamespaceUtils {
 
 	/**
-	 * The <code>proxy-target-class</code> attribute as found on AOP-related XML tags.
+	 * The {@code proxy-target-class} attribute as found on AOP-related XML tags.
 	 */
 	public static final String PROXY_TARGET_CLASS_ATTRIBUTE = "proxy-target-class";
 
 	/**
-	 * The <code>expose-proxy</code> attribute as found on AOP-related XML tags.
+	 * The {@code expose-proxy} attribute as found on AOP-related XML tags.
 	 */
 	private static final String EXPOSE_PROXY_ATTRIBUTE = "expose-proxy";
 

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -27,7 +27,7 @@ import org.springframework.beans.factory.xml.BeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
 
 /**
- * {@link BeanDefinitionParser} for the <code>aspectj-autoproxy</code> tag,
+ * {@link BeanDefinitionParser} for the {@code aspectj-autoproxy} tag,
  * enabling the automatic application of @AspectJ-style aspects found in
  * the {@link org.springframework.beans.factory.BeanFactory}.
  *

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2002-2008 the original author or authors.
+ * Copyright 2002-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *      http://www.apache.org/licenses/LICENSE-2.0
+ *      https://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -49,7 +49,7 @@ import org.springframework.util.StringUtils;
 import org.springframework.util.xml.DomUtils;
 
 /**
- * {@link BeanDefinitionParser} for the <code>&lt;aop:config&gt;</code> tag.
+ * {@link BeanDefinitionParser} for the {@code &lt;aop:config&gt;} tag.
  *
  * @author Rob Harrop
  * @author Juergen Hoeller
@@ -93,7 +93,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	private static final int ASPECT_INSTANCE_FACTORY_INDEX = 2;
 
 	private ParseState parseState = new ParseState();
-	
+
 
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 		CompositeComponentDefinition compositeDef =
@@ -122,8 +122,8 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 	/**
 	 * Configures the auto proxy creator needed to support the {@link BeanDefinition BeanDefinitions}
-	 * created by the '<code>&lt;aop:config/&gt;</code>' tag. Will force class proxying if the
-	 * '<code>proxy-target-class</code>' attribute is set to '<code>true</code>'.
+	 * 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
 	 */
 	private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
@@ -131,7 +131,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses the supplied <code>&lt;advisor&gt;</code> 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}.
 	 */
@@ -168,7 +168,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 
 	/**
 	 * Create a {@link RootBeanDefinition} for the advisor described in the supplied. Does <strong>not</strong>
-	 * parse any associated '<code>pointcut</code>' or '<code>pointcut-ref</code>' attributes.
+	 * parse any associated '{@code pointcut}' or '{@code pointcut-ref}' attributes.
 	 */
 	private AbstractBeanDefinition createAdvisorBeanDefinition(Element advisorElement, ParserContext parserContext) {
 		RootBeanDefinition advisorDefinition = new RootBeanDefinition(DefaultBeanFactoryPointcutAdvisor.class);
@@ -257,9 +257,9 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Return <code>true</code> if the supplied node describes an advice type. May be one of:
-	 * '<code>before</code>', '<code>after</code>', '<code>after-returning</code>',
-	 * '<code>after-throwing</code>' or '<code>around</code>'.
+	 * Return {@code true} if the supplied node describes an advice type. May be one of:
+	 * '{@code before}', '{@code after}', '{@code after-returning}',
+	 * '{@code after-throwing}' or '{@code around}'.
 	 */
 	private boolean isAdviceNode(Node aNode, ParserContext parserContext) {
 		if (!(aNode instanceof Element)) {
@@ -273,7 +273,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parse a '<code>declare-parents</code>' element and register the appropriate
+	 * Parse a '{@code declare-parents}' element and register the appropriate
 	 * DeclareParentsAdvisor with the BeanDefinitionRegistry encapsulated in the
 	 * supplied ParserContext.
 	 */
@@ -281,10 +281,10 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 		BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(DeclareParentsAdvisor.class);
 		builder.addConstructorArgValue(declareParentsElement.getAttribute(IMPLEMENT_INTERFACE));
 		builder.addConstructorArgValue(declareParentsElement.getAttribute(TYPE_PATTERN));
-		
+
 		String defaultImpl = declareParentsElement.getAttribute(DEFAULT_IMPL);
 		String delegateRef = declareParentsElement.getAttribute(DELEGATE_REF);
-		
+
 		if (StringUtils.hasText(defaultImpl) && !StringUtils.hasText(delegateRef)) {
 			builder.addConstructorArgValue(defaultImpl);
 		}
@@ -304,8 +304,8 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses one of '<code>before</code>', '<code>after</code>', '<code>after-returning</code>',
-	 * '<code>after-throwing</code>' or '<code>around</code>' and registers the resulting
+	 * Parses one of '{@code before}', '{@code after}', '{@code after-returning}',
+	 * '{@code after-throwing}' or '{@code around}' and registers the resulting
 	 * BeanDefinition with the supplied BeanDefinitionRegistry.
 	 * @return the generated advice RootBeanDefinition
 	 */
@@ -427,7 +427,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses the supplied <code>&lt;pointcut&gt;</code> 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) {
@@ -435,7 +435,7 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 		String expression = pointcutElement.getAttribute(EXPRESSION);
 
 		AbstractBeanDefinition pointcutDefinition = null;
-		
+
 		try {
 			this.parseState.push(new PointcutEntry(id));
 			pointcutDefinition = createPointcutDefinition(expression);
@@ -460,8 +460,8 @@ class ConfigBeanDefinitionParser implements BeanDefinitionParser {
 	}
 
 	/**
-	 * Parses the <code>pointcut</code> or <code>pointcut-ref</code> attributes of the supplied
-	 * {@link Element} and add a <code>pointcut</code> property as appropriate. Generates a
+	 * Parses the {@code pointcut} or {@code pointcut-ref} attributes of the supplied
+	 * {@link Element} and add a {@code pointcut} property as appropriate. Generates a
 	 * {@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.
 	 */