Release version 3.2.17.RELEASE

Update changelog for 3.2.17.RELEASE
AbstractRequestLoggingFilter ignores non-available query string
2026-06-08 17:33:33 +00:00 · 2016-05-06 10:23:44 +00:00 · 2016-05-06 11:47:00 +02:00 · 2016-05-04 18:48:54 +02:00 · 2016-05-04 18:48:15 +02:00 · 2016-05-04 09:25:00 +02:00
1083 changed files with 30126 additions and 18980 deletions
@@ -30,6 +30,7 @@ spring-*/src/main/java/META-INF/MANIFEST.MF
 *.iml
 *.ipr
 *.iws
+.idea
 out
 test-output
 atlassian-ide-plugin.xml
@@ -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> 
@@ -19,14 +19,6 @@ 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
@@ -1,10 +1,16 @@
 buildscript {
 	repositories {
-		maven { url "http://repo.springsource.org/plugins-release" }
+		maven { url "https://repo.spring.io/plugins-release" }
 	}
 	dependencies {
-		classpath("org.springframework.build.gradle:propdeps-plugin:0.0.3")
-		classpath("org.springframework.build.gradle:docbook-reference-plugin:0.2.6")
+		classpath("org.springframework.build.gradle:propdeps-plugin:0.0.7")
+		classpath("org.springframework.build.gradle:docbook-reference-plugin:0.2.8")
+	}
+}
+
+ext {
+	moduleProjects  = subprojects.findAll {
+		!it.name.equals('spring-build-src') && !it.name.equals('spring-framework-bom')
 	}
 }

@@ -12,10 +18,10 @@ configure(allprojects) { project ->
 	group = "org.springframework"
 	version = qualifyVersionIfNecessary(version)

-	ext.aspectjVersion  = "1.7.2"
+	ext.aspectjVersion  = "1.7.4"
 	ext.hsqldbVersion   = "1.8.0.10"
 	ext.junitVersion    = "4.11"
-	ext.slf4jVersion    = "1.6.1"
+	ext.slf4jVersion    = "1.6.6"
 	ext.gradleScriptDir = "${rootProject.projectDir}/gradle"

 	apply plugin: "propdeps"
@@ -58,10 +64,17 @@ configure(allprojects) { project ->
 	test {
 		systemProperty("java.awt.headless", "true")
 		systemProperty("testGroups", project.properties.get("testGroups"))
+		scanForTestClasses = false
+		// Do not include "**/*Test.class" since some *Test classes are broken.
+		include(["**/*Tests.class"])
+		// Since we set scanForTestClasses to false, we need to filter out inner
+		// classes with the "$" pattern; otherwise, using -Dtest.single=MyTests to
+		// run MyTests by itself will fail if MyTests contains any inner classes. 
+		exclude(["**/Abstract*.class", '**/*$*'])
 	}

 	repositories {
-		maven { url "http://repo.springsource.org/libs-release" }
+		maven { url "https://repo.spring.io/libs-release" }
 	}

 	dependencies {
@@ -71,25 +84,28 @@ configure(allprojects) { project ->
 	}

 	ext.javadocLinks = [
-		"http://docs.oracle.com/javase/6/docs/api",
-		"http://docs.oracle.com/javaee/6/api",
-		"http://portals.apache.org/pluto/portlet-2.0-apidocs/",
-		"http://commons.apache.org/proper/commons-lang/javadocs/api-release/",
-		"http://commons.apache.org/proper/commons-codec/apidocs/",
+		"http://docs.oracle.com/javase/7/docs/api/",
+		"http://docs.oracle.com/javaee/6/api/",
+		"http://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/", // CommonJ
+		"http://pic.dhe.ibm.com/infocenter/wasinfo/v7r0/topic/com.ibm.websphere.javadoc.doc/web/apidocs/",
+		"http://glassfish.java.net/nonav/docs/v3/api/",
 		"http://docs.jboss.org/jbossas/javadoc/4.0.5/connector/",
 		"http://docs.jboss.org/jbossas/javadoc/7.1.2.Final/",
-		"http://aopalliance.sourceforge.net/doc/",
-		"http://glassfish.java.net/nonav/docs/v3/api/",
-		"http://docs.oracle.com/cd/E13222_01/wls/docs90/javadocs/", // commonj
-		"http://quartz-scheduler.org/api/2.1.5/",
-		"http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
-		"http://hc.apache.org/httpclient-3.x/apidocs/",
-		"http://fasterxml.github.com/jackson-core/javadoc/2.0.0/",
-		"http://jackson.codehaus.org/1.4.2/javadoc/",
-		"http://pic.dhe.ibm.com/infocenter/wasinfo/v7r0/topic/com.ibm.websphere.javadoc.doc/web/apidocs/",
-		"http://ibatis.apache.org/docs/java/dev/",
-		"http://tiles.apache.org/framework/apidocs/",
+		"http://commons.apache.org/proper/commons-lang/javadocs/api-2.5/",
+		"http://commons.apache.org/proper/commons-codec/apidocs/",
 		"http://commons.apache.org/proper/commons-dbcp/apidocs/",
+		"http://portals.apache.org/pluto/portlet-2.0-apidocs/",
+		"http://tiles.apache.org/tiles-request/apidocs/",
+		"http://tiles.apache.org/framework/apidocs/",
+		"http://aopalliance.sourceforge.net/doc/",
+		"http://www.eclipse.org/aspectj/doc/released/aspectj5rt-api/",
+		"http://ehcache.org/apidocs/",
+		"http://quartz-scheduler.org/api/2.2.0/",
+		"http://jackson.codehaus.org/1.9.4/javadoc/",
+		"http://fasterxml.github.com/jackson-core/javadoc/2.3.0/",
+		"http://fasterxml.github.com/jackson-databind/javadoc/2.3.0/",
+		"http://hc.apache.org/httpcomponents-client-ga/httpclient/apidocs",
+		"http://ibatis.apache.org/docs/java/dev/"
 	] as String[]
 }

@@ -118,6 +134,9 @@ configure(subprojects - project(":spring-build-src")) { subproject ->
 		options.author = true
 		options.header = project.name
 		options.links(project.ext.javadocLinks)
+		if (JavaVersion.current().isJava8Compatible()) {
+			options.addStringOption('Xdoclint:none', '-quiet')
+		}

 		// suppress warnings due to cross-module @see and @link references;
 		// note that global 'api' task does display all warnings.
@@ -125,10 +144,10 @@ configure(subprojects - project(":spring-build-src")) { subproject ->
 		logging.captureStandardOutput LogLevel.INFO // suppress "## warnings" message
 	}

-	task sourcesJar(type: Jar, dependsOn:classes) {
-		classifier = "sources"
-		from sourceSets.main.allJava.srcDirs
-		include "**/*.java", "**/*.aj"
+	task sourcesJar(type: Jar, dependsOn: classes) {
+		classifier = 'sources'
+		from sourceSets.main.allSource
+		// don't include or exclude anything explicitly by default. See SPR-12085.
 	}

 	task javadocJar(type: Jar) {
@@ -148,7 +167,7 @@ project("spring-build-src") {

 	dependencies {
 		compile gradleApi()
-		groovy localGroovy()
+		compile localGroovy()
 	}

 	configurations.archives.artifacts.clear()
@@ -157,14 +176,14 @@ project("spring-build-src") {
 project("spring-core") {
 	description = "Spring Core"

-	// As of Spring 3.2 spring-core repackages both asm 4.0 and cglib 3.0 and inlines both
-	// into the spring-core jar. cglib 3.0 itself depends on asm 4.0, and is therefore
+	// As of Spring 3.2.9, spring-core repackages asm 5.0 and cglib 3.1, inlining both
+	// into the spring-core jar. cglib 3.1 itself depends on asm 4+, and is therefore
 	// further transformed by the JarJar task to depend on org.springframework.asm; this
 	// avoids including two different copies of asm unnecessarily. If however future cglib
 	// versions drift from the version of asm used by Spring internally, this duplication
 	// will become necessary.
-	def asmVersion = "4.0"
-	def cglibVersion = "3.0"
+	def asmVersion = "5.0.4"
+	def cglibVersion = "3.1"

 	configurations {
 		jarjar
@@ -219,10 +238,11 @@ project("spring-core") {
 		cglib("cglib:cglib:${cglibVersion}@jar")
 		jarjar("com.googlecode.jarjar:jarjar:1.3")

+		compile(files(cglibRepackJar))
 		compile(files(asmRepackJar))
-		compile("commons-logging:commons-logging:1.1.1")
+		compile("commons-logging:commons-logging:1.1.3")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
-		optional("net.sf.jopt-simple:jopt-simple:3.0")
+		optional("net.sf.jopt-simple:jopt-simple:3.3")
 		optional("log4j:log4j:1.2.17")
 		testCompile("xmlunit:xmlunit:1.3")
 		testCompile("org.codehaus.woodstox:wstx-asl:3.2.7") {
@@ -245,30 +265,33 @@ project("spring-core") {

 project("spring-beans") {
 	description = "Spring Beans"
+
 	dependencies {
 		compile(project(":spring-core"))
 		compile(files(project(":spring-core").cglibRepackJar))
-		provided("javax.el:el-api:1.0")
-		provided("javax.inject:javax.inject:1")
+		optional("javax.el:el-api:1.0")
+		optional("javax.inject:javax.inject:1")
 		testCompile("log4j:log4j:1.2.17")
 	}
 }

 project("spring-aop") {
 	description = "Spring AOP"
+
 	dependencies {
+		compile(project(":spring-beans"))
 		compile(project(":spring-core"))
 		compile(files(project(":spring-core").cglibRepackJar))
-		compile(project(":spring-beans"))
 		compile("aopalliance:aopalliance:1.0")
-		optional("com.jamonapi:jamon:2.4")
-		optional("commons-pool:commons-pool:1.5.3")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
+		optional("commons-pool:commons-pool:1.5.7")
+		optional("com.jamonapi:jamon:2.4")
 	}
 }

 project("spring-expression") {
 	description = "Spring Expression Language (SpEL)"
+
 	dependencies {
 		compile(project(":spring-core"))
 	}
@@ -276,17 +299,19 @@ project("spring-expression") {

 project("spring-instrument") {
 	description = "Spring Instrument"
-	dependencies {
-		compile(project(":spring-core"))
-	}
+
 	jar {
 		manifest.attributes["Premain-Class"] =
 			"org.springframework.instrument.InstrumentationSavingAgent"
+		manifest.attributes["Can-Redefine-Classes"] = "true"
+		manifest.attributes["Can-Retransform-Classes"] = "true"
+		manifest.attributes["Can-Set-Native-Method-Prefix"] = "false"
 	}
 }

 project("spring-instrument-tomcat") {
 	description = "Spring Instrument Tomcat"
+
 	dependencies {
 		provided("org.apache.tomcat:catalina:6.0.16")
 	}
@@ -294,31 +319,34 @@ project("spring-instrument-tomcat") {

 project("spring-context") {
 	description = "Spring Context"
+
 	dependencies {
-		optional(project(":spring-instrument"))
 		compile(project(":spring-aop"))
 		compile(project(":spring-beans"))
 		compile(project(":spring-expression"))
 		compile(project(":spring-core"))
 		compile(files(project(":spring-core").cglibRepackJar))
-		optional("backport-util-concurrent:backport-util-concurrent:3.0")
-		optional("javax.ejb:ejb-api:3.0")
+		optional(project(":spring-instrument"))
 		optional("javax.inject:javax.inject:1")
+		optional("javax.ejb:ejb-api:3.0")
 		optional("org.apache.geronimo.specs:geronimo-jms_1.1_spec:1.1")
+		optional("backport-util-concurrent:backport-util-concurrent:3.0")
 		optional("javax.persistence:persistence-api:1.0")
 		optional("javax.validation:validation-api:1.0.0.GA")
-		optional("org.beanshell:bsh:2.0b4")
-		optional("org.codehaus.groovy:groovy-all:1.8.8")
-		optional("org.jruby:jruby:1.6.5.1")
-		optional("joda-time:joda-time:2.1")
-		optional("org.slf4j:slf4j-api:${slf4jVersion}")
-		optional("org.hibernate:hibernate-validator:4.3.0.Final")
+		optional("org.hibernate:hibernate-validator:4.3.1.Final")
+		optional("joda-time:joda-time:2.2")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
-		optional("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1")
-		testCompile("commons-dbcp:commons-dbcp:1.2.2")
+		optional("org.codehaus.groovy:groovy-all:1.8.9")
+		optional("org.beanshell:bsh:2.0b4")
+		optional("org.jruby:jruby:1.7.12")
 		testCompile("javax.inject:javax.inject-tck:1")
+		testCompile("commons-dbcp:commons-dbcp:1.3")
+		testCompile("org.slf4j:slf4j-api:${slf4jVersion}")
 	}

+	// pick up RmiInvocationWrapperRTD.xml in src/main
+	sourceSets.main.resources.srcDirs += "src/main/java"
+
 	test {
 		jvmArgs = ["-disableassertions:org.aspectj.weaver.UnresolvedType"] // SPR-7989
 	}
@@ -326,18 +354,19 @@ project("spring-context") {

 project("spring-tx") {
 	description = "Spring Transaction"
+
 	dependencies {
-		optional(project(":spring-context")) // for JCA, @EnableTransactionManagement
-		optional(project(":spring-aop"))
 		compile(project(":spring-beans"))
 		compile(project(":spring-core"))
-		compile("aopalliance:aopalliance:1.0")
-		provided("com.ibm.websphere:uow:6.0.2.17")
-		optional("javax.resource:connector-api:1.5")
+		optional(project(":spring-aop"))
+		optional(project(":spring-context"))  // for JCA, @EnableTransactionManagement
+		optional("aopalliance:aopalliance:1.0")
 		optional("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1")
+		optional("javax.resource:connector-api:1.5")
 		optional("javax.ejb:ejb-api:3.0")
-		testCompile("javax.persistence:persistence-api:1.0")
+		optional("com.ibm.websphere:uow:6.0.2.17")
 		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
+		testCompile("javax.persistence:persistence-api:1.0")
 	}
 }

@@ -355,16 +384,24 @@ project("spring-oxm") {
 	dependencies {
 		compile(project(":spring-beans"))
 		compile(project(":spring-core"))
-		optional(project(":spring-context")) // for Jaxb2Marshaller
-		compile("commons-lang:commons-lang:2.5")
-		optional("com.thoughtworks.xstream:xstream:1.3.1")
-		optional("com.sun.xml.bind:jaxb-impl:2.1.7")
-		optional("org.jibx:jibx-run:1.2.3")
-		optional("org.apache.xmlbeans:xmlbeans:2.4.0")
-		optional("org.codehaus.castor:castor-xml:1.3.2")
-		testCompile("org.codehaus.jettison:jettison:1.0.1")
+		optional("org.codehaus.castor:castor-xml:1.3.3")  {
+			exclude group: 'stax', module: 'stax-api'
+			exclude group: "org.springframework", module: "spring-context"
+		}
+		optional("org.apache.xmlbeans:xmlbeans:2.6.0") {
+			exclude group: 'stax', module: 'stax-api'
+		}
+		optional("com.thoughtworks.xstream:xstream:1.4.7") {
+			exclude group: 'xpp3', module: 'xpp3_min'
+			exclude group: 'xmlpull', module: 'xmlpull'
+		}
+		optional("org.jibx:jibx-run:1.2.5")
+		testCompile(project(":spring-context"))
 		testCompile("xmlunit:xmlunit:1.3")
 		testCompile("xmlpull:xmlpull:1.1.3.4a")
+		testCompile("org.codehaus.jettison:jettison:1.0.1") {
+			exclude group: 'stax', module: 'stax-api'
+		}
 		testCompile(files(genCastor.classesDir).builtBy(genCastor))
 		testCompile(files(genJaxb.classesDir).builtBy(genJaxb))
 		testCompile(files(genXmlbeans.classesDir).builtBy(genXmlbeans))
@@ -373,61 +410,64 @@ project("spring-oxm") {

 project("spring-jms") {
 	description = "Spring JMS"
+
 	dependencies {
 		compile(project(":spring-core"))
 		compile(project(":spring-beans"))
 		compile(project(":spring-aop"))
 		compile(project(":spring-context"))
 		compile(project(":spring-tx"))
-		optional(project(":spring-oxm"))
-		compile("aopalliance:aopalliance:1.0")
 		provided("org.apache.geronimo.specs:geronimo-jms_1.1_spec:1.1")
+		optional(project(":spring-oxm"))
+		optional("aopalliance:aopalliance:1.0")
 		optional("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1")
 		optional("javax.resource:connector-api:1.5")
-		optional("org.codehaus.jackson:jackson-mapper-asl:1.4.2")
-		optional("com.fasterxml.jackson.core:jackson-databind:2.0.1")
+		optional("org.codehaus.jackson:jackson-mapper-asl:1.7.9")
+		optional("com.fasterxml.jackson.core:jackson-databind:2.0.6")
 	}
 }

 project("spring-jdbc") {
 	description = "Spring JDBC"
+
 	dependencies {
-		compile(project(":spring-core"))
 		compile(project(":spring-beans"))
-		optional(project(":spring-context")) // for JndiDataSourceLookup
+		compile(project(":spring-core"))
 		compile(project(":spring-tx"))
+		optional(project(":spring-context"))  // for JndiDataSourceLookup
+		optional("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1")
 		optional("c3p0:c3p0:0.9.1.2")
 		optional("hsqldb:hsqldb:${hsqldbVersion}")
-		optional("com.h2database:h2:1.0.71")
+		optional("com.h2database:h2:1.0.79")
 		optional("org.apache.derby:derby:10.5.3.0_1")
 		optional("org.apache.derby:derbyclient:10.5.3.0_1")
-		optional("org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1")
 	}
 }

 project("spring-context-support") {
 	description = "Spring Context Support"
+
 	dependencies {
 		compile(project(":spring-core"))
 		compile(project(":spring-beans"))
 		compile(project(":spring-context"))
-		optional(project(":spring-jdbc")) // for Quartz support
-		optional(project(":spring-tx")) // for Quartz support
-		optional("javax.mail:mail:1.4")
+		provided("javax.activation:activation:1.1")
+		optional(project(":spring-jdbc"))  // for Quartz support
+		optional(project(":spring-tx"))  // for Quartz support
+		optional("javax.mail:mail:1.4.7")
 		optional("javax.cache:cache-api:0.5")
-		optional("net.sf.ehcache:ehcache-core:2.0.0")
-		optional("opensymphony:quartz:1.6.2")
+		optional("net.sf.ehcache:ehcache-core:2.0.1")
+		optional("org.quartz-scheduler:quartz:1.7.3")
 		optional("org.codehaus.fabric3.api:commonj:1.1.0")
 		optional("velocity:velocity:1.5")
-		optional("org.freemarker:freemarker:2.3.15")
+		optional("org.freemarker:freemarker:2.3.20")
 		optional("com.lowagie:itext:2.1.7")
-		optional("jasperreports:jasperreports:2.0.5")
-		optional("org.slf4j:slf4j-api:${slf4jVersion}")
-		provided("javax.activation:activation:1.1")
-		testCompile("org.apache.poi:poi:3.0.2-FINAL")
-		testCompile("commons-beanutils:commons-beanutils:1.8.0") // for Velocity/JasperReports
-		testCompile("commons-digester:commons-digester:1.8.1") // for Velocity/JasperReports
+		optional("net.sf.jasperreports:jasperreports:3.7.6")
+		testCompile("org.apache.poi:poi:3.6")
+		testCompile("commons-beanutils:commons-beanutils:1.8.0")  // for Velocity/JasperReports
+		testCompile("commons-digester:commons-digester:1.8.1")  // for Velocity/JasperReports
 		testCompile("hsqldb:hsqldb:${hsqldbVersion}")
+		testCompile("org.slf4j:slf4j-api:${slf4jVersion}")
 	}

 	// pick up **/*.types files in src/main
@@ -436,29 +476,30 @@ project("spring-context-support") {

 project("spring-web") {
 	description = "Spring Web"
+
 	dependencies {
-		compile(project(":spring-core"))
-		compile(project(":spring-beans")) // for MultiPartFilter
-		compile(project(":spring-aop")) // for JaxWsPortProxyFactoryBean
+		compile(project(":spring-aop"))  // for JaxWsPortProxyFactoryBean
+		compile(project(":spring-beans"))  // for MultipartFilter
 		compile(project(":spring-context"))
-		optional(project(":spring-oxm")) // for MarshallingHttpMessageConverter
-		compile("aopalliance:aopalliance:1.0")
-		optional("com.caucho:hessian:3.2.1")
-		optional("rome:rome:1.0")
+		compile(project(":spring-core"))
+		provided("javax.servlet:javax.servlet-api:3.0.1")
+		provided("javax.activation:activation:1.1")
+		optional(project(":spring-oxm"))  // for MarshallingHttpMessageConverter
+		optional("javax.servlet.jsp:jsp-api:2.1")
+		optional("javax.portlet:portlet-api:2.0")
 		optional("javax.el:el-api:1.0")
 		optional("javax.faces:jsf-api:1.2_08")
-		provided("javax.portlet:portlet-api:2.0")
-		provided("javax.servlet:javax.servlet-api:3.0.1")
-		provided("javax.servlet.jsp:jsp-api:2.1")
 		optional("javax.xml:jaxrpc-api:1.1")
-		provided("javax.xml.soap:saaj-api:1.3")
-		provided("javax.activation:activation:1.1")
-		optional("commons-fileupload:commons-fileupload:1.2")
+		optional("javax.xml.soap:saaj-api:1.3")
+		optional("aopalliance:aopalliance:1.0")
+		optional("com.caucho:hessian:3.2.1")
+		optional("commons-fileupload:commons-fileupload:1.3.1")
 		optional("commons-io:commons-io:1.3")
 		optional("commons-httpclient:commons-httpclient:3.1")
-		optional("org.apache.httpcomponents:httpclient:4.2")
-		optional("org.codehaus.jackson:jackson-mapper-asl:1.4.2")
-		optional("com.fasterxml.jackson.core:jackson-databind:2.0.1")
+		optional("org.apache.httpcomponents:httpclient:4.2.6")
+		optional("org.codehaus.jackson:jackson-mapper-asl:1.7.9")
+		optional("com.fasterxml.jackson.core:jackson-databind:2.0.6")
+		optional("rome:rome:1.0")
 		optional("taglibs:standard:1.1.2")
 		optional("org.eclipse.jetty:jetty-servlet:8.1.5.v20120716") {
 			exclude group: "org.eclipse.jetty.orbit", module: "javax.servlet"
@@ -479,85 +520,85 @@ project("spring-orm") {
 	description = "Spring Object/Relational Mapping"

 	compileTestJava {
-		// necessary to avoid java.lang.VerifyError on toplink compilation
-		// TODO: remove this block when we remove toplink
+		// necessary to avoid java.lang.VerifyError on TopLink compilation
 		sourceCompatibility=1.6
 		targetCompatibility=1.6
 	}

 	dependencies {
-		compile("aopalliance:aopalliance:1.0")
+		compile(project(":spring-beans"))
+		compile(project(":spring-core"))
+		compile(project(":spring-jdbc"))
+		compile(project(":spring-tx"))
+		optional(project(":spring-aop"))
+		optional(project(":spring-context"))
+		optional(project(":spring-web"))
+		optional("aopalliance:aopalliance:1.0")
+		optional("javax.persistence:persistence-api:1.0")
+		optional("org.eclipse.persistence:org.eclipse.persistence.core:1.0.1")
+		optional("org.eclipse.persistence:org.eclipse.persistence.jpa:1.0.1")
 		optional("org.hibernate:hibernate-core:3.3.2.GA")
 		optional("org.hibernate:hibernate-annotations:3.4.0.GA")
 		optional("org.hibernate:hibernate-entitymanager:3.4.0.GA")
 		optional("org.apache.openjpa:openjpa:1.1.0")
-		optional("org.eclipse.persistence:org.eclipse.persistence.core:1.0.1")
-		optional("org.eclipse.persistence:org.eclipse.persistence.jpa:1.0.1")
 		optional("toplink.essentials:toplink-essentials:2.0-41b")
 		optional("javax.jdo:jdo-api:3.0")
 		optional("org.apache.ibatis:ibatis-sqlmap:2.3.4.726")
-		optional("javax.persistence:persistence-api:1.0")
-		provided("javax.servlet:servlet-api:2.5")
+		optional("javax.servlet:servlet-api:2.5")
 		testCompile("javax.servlet:javax.servlet-api:3.0.1")
-		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
-		testCompile("commons-dbcp:commons-dbcp:1.2.2")
 		testCompile("org.eclipse.persistence:org.eclipse.persistence.asm:1.0.1")
 		testCompile("org.eclipse.persistence:org.eclipse.persistence.antlr:1.0.1")
+		testCompile("commons-dbcp:commons-dbcp:1.3")
 		testCompile("hsqldb:hsqldb:${hsqldbVersion}")
-		compile(project(":spring-core"))
-		compile(project(":spring-beans"))
-		optional(project(":spring-aop"))
-		optional(project(":spring-context"))
-		compile(project(":spring-tx"))
-		compile(project(":spring-jdbc"))
-		optional(project(":spring-web"))
+		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
 	}
 }

 project("spring-orm-hibernate4") {
 	description = "Spring Object/Relational Mapping - Hibernate 4 support"
 	merge.into = project(":spring-orm")
+
 	dependencies {
-		provided(project(":spring-tx"))
 		provided(project(":spring-jdbc"))
-		optional("org.hibernate:hibernate-core:4.1.0.Final")
-		optional("org.hibernate:hibernate-entitymanager:4.1.0.Final")
+		provided(project(":spring-tx"))
 		optional(project(":spring-web"))
+		optional("org.hibernate:hibernate-core:4.2.21.Final")
+		optional("org.hibernate:hibernate-entitymanager:4.2.21.Final")
 		optional("javax.servlet:servlet-api:2.5")
 	}
 }

 project("spring-webmvc") {
 	description = "Spring Web MVC"
+
 	dependencies {
+		compile(project(":spring-beans"))
+		compile(project(":spring-context"))
 		compile(project(":spring-core"))
 		compile(project(":spring-expression"))
-		compile(project(":spring-beans"))
 		compile(project(":spring-web"))
-		compile(project(":spring-context"))
-		optional(project(":spring-context-support")) // for Velocity support
-		optional(project(":spring-oxm")) // for MarshallingView
+		provided("javax.servlet:javax.servlet-api:3.0.1")
+		optional(project(":spring-context-support"))  // for Velocity support
+		optional(project(":spring-oxm"))  // for MarshallingView
+		optional("javax.servlet.jsp:jsp-api:2.1")
+		optional("javax.servlet:jstl:1.2")
+		optional("net.sourceforge.jexcelapi:jxl:2.6.12")
+		optional("org.apache.poi:poi:3.6")
+		optional("velocity:velocity:1.5")
+		optional("velocity-tools:velocity-tools-view:1.4")
+		optional("org.freemarker:freemarker:2.3.20")
+		optional("com.lowagie:itext:2.1.7")
+		optional("net.sf.jasperreports:jasperreports:3.7.6") {
+			exclude group: "xml-apis", module: "xml-apis"
+		}
+		optional("org.codehaus.jackson:jackson-mapper-asl:1.7.9")
+		optional("com.fasterxml.jackson.core:jackson-databind:2.0.6")
+		optional("rome:rome:1.0")
 		optional("org.apache.tiles:tiles-api:2.1.2")
 		optional("org.apache.tiles:tiles-core:2.1.2")
 		optional("org.apache.tiles:tiles-jsp:2.1.2")
 		optional("org.apache.tiles:tiles-servlet:2.1.2")
-		optional("velocity-tools:velocity-tools-view:1.4")
-		optional("net.sourceforge.jexcelapi:jxl:2.6.3")
-		optional("org.apache.poi:poi:3.0.2-FINAL")
-		optional("com.lowagie:itext:2.1.7")
-		optional("jasperreports:jasperreports:2.0.5") {
-			exclude group: "xml-apis", module: "xml-apis"
-		}
-		optional("rome:rome:1.0")
-		optional("velocity:velocity:1.5")
-		optional("org.freemarker:freemarker:2.3.15")
-		optional("org.codehaus.jackson:jackson-mapper-asl:1.4.2")
-		optional("com.fasterxml.jackson.core:jackson-databind:2.0.1")
-		provided("javax.servlet:jstl:1.2")
-		provided("javax.servlet:javax.servlet-api:3.0.1")
-		provided("javax.servlet.jsp:jsp-api:2.1")
 		testCompile(project(":spring-aop"))
-		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
 		testCompile("rhino:js:1.7R1")
 		testCompile("xmlunit:xmlunit:1.3")
 		testCompile("dom4j:dom4j:1.6.1") {
@@ -575,10 +616,11 @@ project("spring-webmvc") {
 			exclude group: "org.eclipse.jetty.orbit", module: "javax.servlet"
 		}
 		testCompile("javax.validation:validation-api:1.0.0.GA")
-		testCompile("commons-fileupload:commons-fileupload:1.2")
+		testCompile("org.hibernate:hibernate-validator:4.3.1.Final")
+		testCompile("org.apache.httpcomponents:httpclient:4.2.6")
+		testCompile("commons-fileupload:commons-fileupload:1.3.1")
 		testCompile("commons-io:commons-io:1.3")
-		testCompile("org.hibernate:hibernate-validator:4.3.0.Final")
-		testCompile("org.apache.httpcomponents:httpclient:4.2")
+		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
 	}

 	// pick up DispatcherServlet.properties in src/main
@@ -588,45 +630,47 @@ project("spring-webmvc") {
 project("spring-webmvc-tiles3") {
 	description = "Spring Framework Tiles3 Integration"
 	merge.into = project(":spring-webmvc")
+
 	dependencies {
 		provided(project(":spring-context"))
 		provided(project(":spring-web"))
-		provided("javax.el:el-api:1.0")
-		provided("javax.servlet:jstl:1.2")
-		provided("javax.servlet.jsp:jsp-api:2.1")
-		optional("org.apache.tiles:tiles-request-api:1.0.1")
-		optional("org.apache.tiles:tiles-api:3.0.1")
-		optional("org.apache.tiles:tiles-core:3.0.1") {
-			exclude group: "org.slf4j", module: "jcl-over-slf4j"
-		}
-		optional("org.apache.tiles:tiles-servlet:3.0.1") {
-			exclude group: "org.slf4j", module: "jcl-over-slf4j"
-		}
-		optional("org.apache.tiles:tiles-jsp:3.0.1") {
-			exclude group: "org.slf4j", module: "jcl-over-slf4j"
-		}
-		optional("org.apache.tiles:tiles-extras:3.0.1") {
-			exclude group: "org.slf4j", module: "jcl-over-slf4j"
-		}
-		optional("org.apache.tiles:tiles-el:3.0.1") {
-			exclude group: "org.slf4j", module: "jcl-over-slf4j"
-		}
 		provided("javax.servlet:javax.servlet-api:3.0.1")
+		optional("javax.servlet.jsp:jsp-api:2.1")
+		optional("javax.servlet:jstl:1.2")
+		optional("javax.el:el-api:1.0")
+		optional("org.apache.tiles:tiles-api:3.0.4")
+		optional("org.apache.tiles:tiles-core:3.0.4") {
+			exclude group: "org.slf4j", module: "jcl-over-slf4j"
+		}
+		optional("org.apache.tiles:tiles-servlet:3.0.4") {
+			exclude group: "org.slf4j", module: "jcl-over-slf4j"
+		}
+		optional("org.apache.tiles:tiles-jsp:3.0.4") {
+			exclude group: "org.slf4j", module: "jcl-over-slf4j"
+		}
+		optional("org.apache.tiles:tiles-el:3.0.4") {
+			exclude group: "org.slf4j", module: "jcl-over-slf4j"
+		}
+		optional("org.apache.tiles:tiles-extras:3.0.4") {
+			exclude group: "org.slf4j", module: "jcl-over-slf4j"
+			exclude group: "org.springframework", module: "spring-web"
+		}
 		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
 	}
 }

 project("spring-webmvc-portlet") {
 	description = "Spring Web Portlet"
+
 	dependencies {
-		provided("javax.servlet:servlet-api:2.5")
-		provided("javax.portlet:portlet-api:2.0")
-		compile(project(":spring-core"))
 		compile(project(":spring-beans"))
 		compile(project(":spring-context"))
+		compile(project(":spring-core"))
 		compile(project(":spring-web"))
 		compile(project(":spring-webmvc"))
-		optional("commons-fileupload:commons-fileupload:1.2")
+		provided("javax.servlet:servlet-api:2.5")
+		provided("javax.portlet:portlet-api:2.0")
+		optional("commons-fileupload:commons-fileupload:1.3.1")
 	}

 	// pick up DispatcherPortlet.properties in src/main
@@ -636,23 +680,9 @@ project("spring-webmvc-portlet") {
 project("spring-test") {
 	description = "Spring TestContext Framework"

-	task testNG(type: Test) {
-		useTestNG()
-		// "TestCase" classes are run by other test classes, not the build.
-		exclude "**/*TestCase.class"
-		// Generate TestNG reports alongside JUnit reports.
-		testReport true
-	}
-
-	test {
-		dependsOn testNG
-		useJUnit()
-		// "TestCase" classes are run by other test classes, not the build.
-		exclude(["**/*TestCase.class", "**/*TestSuite.class"])
-	}
-
 	dependencies {
 		compile(project(":spring-core"))
+		provided("javax.activation:activation:1.1")
 		optional(project(":spring-beans"))
 		optional(project(":spring-context"))
 		optional(project(":spring-jdbc"))
@@ -660,20 +690,42 @@ project("spring-test") {
 		optional(project(":spring-orm"))
 		optional(project(":spring-web"))
 		optional(project(":spring-webmvc"))
-		optional(project(":spring-webmvc-portlet"), )
+		optional(project(":spring-webmvc-portlet"))
 		optional("junit:junit:${junitVersion}")
-		optional("org.testng:testng:6.5.2")
+		optional("org.testng:testng:6.8.8")
+		optional("javax.inject:javax.inject:1")
 		optional("javax.servlet:servlet-api:2.5")
 		optional("javax.servlet.jsp:jsp-api:2.1")
+		optional("javax.servlet:jstl:1.2")
 		optional("javax.portlet:portlet-api:2.0")
 		optional("javax.persistence:persistence-api:1.0")
 		optional("org.aspectj:aspectjweaver:${aspectjVersion}")
 		testCompile("org.hibernate:hibernate-core:3.3.2.GA")
-		provided("javax.inject:javax.inject:1")
-		provided("javax.activation:activation:1.1")
-		provided("javax.servlet:jstl:1.2")
-		testCompile "org.slf4j:slf4j-jcl:${slf4jVersion}"
 		testCompile("hsqldb:hsqldb:${hsqldbVersion}")
+		testCompile "org.slf4j:slf4j-jcl:${slf4jVersion}"
+	}
+
+	task testNG(type: Test) {
+		useTestNG()
+		// forkEvery 1
+		scanForTestClasses = false
+		include "**/testng/**/*.*"
+		exclude "**/FailingBeforeAndAfterMethodsTests.class"
+		// "TestCase" classes are run by other test classes, not the build.
+		exclude "**/*TestCase.class"
+		// Generate TestNG reports alongside JUnit reports.
+		getReports().getHtml().setEnabled(true)
+		// show standard out and standard error of the test JVM(s) on the console
+		// testLogging.showStandardStreams = true
+	}
+
+	test {
+		dependsOn testNG
+		useJUnit()
+		exclude "**/testng/**/*.*"
+		include "**/testng/FailingBeforeAndAfterMethodsTests"
+		// "TestCase" classes are run by other test classes, not the build.
+		exclude(["**/*TestCase.class", "**/*TestSuite.class"])
 	}
 }

@@ -681,33 +733,30 @@ project("spring-test-mvc") {
 	description = "Spring Test MVC Framework"
 	merge.into = project(":spring-test")
 	dependencies {
-		optional(project(":spring-context"))
 		provided(project(":spring-webmvc"))
 		provided("javax.servlet:javax.servlet-api:3.0.1")
+		provided("javax.activation:activation:1.1")
+		optional(project(":spring-context"))
 		optional("org.hamcrest:hamcrest-core:1.3")
 		optional("com.jayway.jsonpath:json-path:0.8.1")
 		optional("xmlunit:xmlunit:1.3")
-		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
-		testCompile("javax.servlet:jstl:1.2")
-		testCompile("org.hibernate:hibernate-validator:4.3.0.Final")
-		testCompile("org.codehaus.jackson:jackson-mapper-asl:1.4.2")
-		testCompile("com.fasterxml.jackson.core:jackson-databind:2.0.1")
 		testCompile(project(":spring-context-support"))
 		testCompile(project(":spring-oxm"))
-		testCompile("com.thoughtworks.xstream:xstream:1.3.1")
-		testCompile("cglib:cglib-nodep:2.2")
+		testCompile("javax.servlet:jstl:1.2")
+		testCompile("javax.mail:mail:1.4.7")
+		testCompile("org.hibernate:hibernate-validator:4.3.1.Final")
+		testCompile("com.thoughtworks.xstream:xstream:1.4.7")
+		testCompile("org.codehaus.jackson:jackson-mapper-asl:1.7.9")
+		testCompile("com.fasterxml.jackson.core:jackson-databind:2.0.6")
 		testCompile("rome:rome:1.0")
-		testCompile("javax.activation:activation:1.1")
-		testCompile("javax.mail:mail:1.4")
-		testCompile("javax.xml.bind:jaxb-api:2.2.6")
-		testCompile("org.apache.tiles:tiles-request-api:1.0.1")
-		testCompile("org.apache.tiles:tiles-api:3.0.1")
-		testCompile("org.apache.tiles:tiles-core:3.0.1") {
+		testCompile("org.apache.tiles:tiles-api:3.0.4")
+		testCompile("org.apache.tiles:tiles-core:3.0.4") {
 			exclude group: "org.slf4j", module: "jcl-over-slf4j"
 		}
-		testCompile("org.apache.tiles:tiles-servlet:3.0.1") {
+		testCompile("org.apache.tiles:tiles-servlet:3.0.4") {
 			exclude group: "org.slf4j", module: "jcl-over-slf4j"
 		}
+		testCompile("org.slf4j:slf4j-jcl:${slf4jVersion}")
 	}
 }

@@ -730,23 +779,24 @@ project("spring-struts") {
 project("spring-aspects") {
 	description = "Spring Aspects"
 	apply from: "aspects.gradle"
+
 	dependencies {
-		optional(project(":spring-beans")) // for @Configurable support
-		optional(project(":spring-aop")) // for @Async support
-		optional(project(":spring-context")) // for @Enable* support
-		compile(project(":spring-context-support")) // for JavaMail support
-		optional(project(":spring-tx")) // for JPA, @Transactional support
-		optional(project(":spring-orm")) // for JPA exception translation support
 		aspects(project(":spring-orm"))
-		provided("javax.persistence:persistence-api:1.0")
-		testCompile("javax.mail:mail:1.4")
 		ajc("org.aspectj:aspectjtools:${aspectjVersion}")
 		rt("org.aspectj:aspectjrt:${aspectjVersion}")
 		compile("org.aspectj:aspectjweaver:${aspectjVersion}")
-		testCompile(project(":spring-core")) // for CodeStyleAspect
-		compile(project(":spring-beans")) // for "p" namespace visibility
+		provided("javax.persistence:persistence-api:1.0")
+		optional(project(":spring-aop"))  // for @Async support
+		optional(project(":spring-beans"))  // for @Configurable support
+		optional(project(":spring-context"))  // for @Enable* support
+		optional(project(":spring-context-support"))  // for JavaMail support
+		optional(project(":spring-orm"))  // for JPA exception translation support
+		optional(project(":spring-tx"))  // for JPA, @Transactional support
+		testCompile(project(":spring-core"))  // for CodeStyleAspect
 		testCompile(project(":spring-test"))
+		testCompile("javax.mail:mail:1.4.7")
 	}
+
 	eclipse.project {
 		natures += "org.eclipse.ajdt.ui.ajnature"
 		buildCommands = [new org.gradle.plugins.ide.eclipse.model.
@@ -754,12 +804,48 @@ project("spring-aspects") {
 	}
 }

+project("spring-framework-bom") {
+	description = "Spring Framework (Bill of Materials)"
+
+	configurations.archives.artifacts.clear()
+	artifacts {
+		// work around GRADLE-2406 by attaching text artifact
+		archives(file("spring-framework-bom.txt"))
+	}
+
+	install {
+		repositories.mavenInstaller {
+			pom.whenConfigured {
+				packaging = "pom"
+				withXml {
+					asNode().children().last() + {
+						delegate.dependencyManagement {
+							delegate.dependencies {
+								parent.subprojects.sort { "$it.name" }.each { p ->
+									if (p.hasProperty("merge") && p.merge.into == null && p != project) {
+										delegate.dependency {
+											delegate.groupId(p.group)
+											delegate.artifactId(p.name)
+											delegate.version(p.version)
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
 configure(rootProject) {
 	description = "Spring Framework"

 	apply plugin: "docbook-reference"
 	apply plugin: "groovy"
-	apply plugin: "detect-split-packages"
+
+	// apply plugin: "detect-split-packages"
 	apply from: "${gradleScriptDir}/jdiff.gradle"

 	reference {
@@ -767,31 +853,33 @@ configure(rootProject) {
 		pdfFilename = "spring-framework-reference.pdf"
 	}

-	detectSplitPackages {
-		projectsToScan -= project(":spring-instrument-tomcat")
-	}
+	// TODO: DetectSplitPackagesPlugin fails in line 154 due to method not found on java.io.File.
+	// TODO: Possibly related to user rights or OS differences on OpenJDK 8; works fine on JDK 7.
+	// detectSplitPackages {
+	//	projectsToScan -= project(":spring-instrument-tomcat")
+	// }

 	// don't publish the default jar for the root project
 	configurations.archives.artifacts.clear()

 	dependencies { // for integration tests
-		testCompile(project(":spring-core"))
-		testCompile(project(":spring-beans"))
 		testCompile(project(":spring-aop"))
-		testCompile(project(":spring-expression"))
+		testCompile(project(":spring-beans"))
 		testCompile(project(":spring-context"))
-		testCompile(project(":spring-tx"))
+		testCompile(project(":spring-core"))
+		testCompile(project(":spring-expression"))
 		testCompile(project(":spring-jdbc"))
+		testCompile(project(":spring-orm"))
 		testCompile(project(":spring-test"))
+		testCompile(project(":spring-tx"))
 		testCompile(project(":spring-web"))
 		testCompile(project(":spring-webmvc-portlet"))
-		testCompile(project(":spring-orm"))
-		testCompile("org.hibernate:hibernate-core:4.1.0.Final")
 		testCompile("javax.servlet:servlet-api:2.5")
 		testCompile("javax.portlet:portlet-api:2.0")
 		testCompile("javax.inject:javax.inject:1")
 		testCompile("javax.resource:connector-api:1.5")
 		testCompile("org.aspectj:aspectjweaver:${aspectjVersion}")
+		testCompile("org.hibernate:hibernate-core:4.2.21.Final")
 		testCompile("hsqldb:hsqldb:${hsqldbVersion}")
 	}

@@ -812,6 +900,9 @@ configure(rootProject) {
 		options.stylesheetFile = file("src/api/stylesheet.css")
 		options.splitIndex = true
 		options.links(project.ext.javadocLinks)
+		if (JavaVersion.current().isJava8Compatible()) {
+			options.addStringOption('Xdoclint:none', '-quiet')
+		}

 		source subprojects.collect { project ->
 			project.sourceSets.main.allJava
@@ -822,7 +913,7 @@ configure(rootProject) {

 		doFirst {
 			classpath = files(
-				// ensure servlet 3.x and Hibernate 4.x have precedence on the Javadoc
+				// ensure Servlet 3.x and Hibernate 4.x have precedence on the javadoc
 				// classpath over their respective 2.5 and 3.x variants
 				project(":spring-webmvc").sourceSets.main.compileClasspath.files.find { it =~ "servlet-api" },
 				rootProject.sourceSets.test.compileClasspath.files.find { it =~ "hibernate-core" },
@@ -833,7 +924,7 @@ configure(rootProject) {
 		}
 	}

-	task docsZip(type: Zip) {
+	task docsZip(type: Zip, dependsOn: 'reference') {
 		group = "Distribution"
 		baseName = "spring-framework"
 		classifier = "docs"
@@ -859,8 +950,8 @@ configure(rootProject) {
 		classifier = "schema"
 		description = "Builds -${classifier} archive containing all " +
 			"XSDs for deployment at http://springframework.org/schema."
-
-		subprojects.each { subproject ->
+		duplicatesStrategy 'exclude'
+		moduleProjects.each { subproject ->
 			def Properties schemas = new Properties();

 			subproject.sourceSets.main.resources.find {
@@ -906,7 +997,7 @@ configure(rootProject) {
 			into "${baseDir}/schema"
 		}

-		subprojects.each { subproject ->
+		moduleProjects.each { subproject ->
 			into ("${baseDir}/libs") {
 				from subproject.jar
 				if (subproject.tasks.findByPath("sourcesJar")) {
@@ -959,7 +1050,7 @@ configure(rootProject) {

 	task wrapper(type: Wrapper) {
 		description = "Generates gradlew[.bat] scripts"
-		gradleVersion = "1.3"
+		gradleVersion = "1.12"

 		doLast() {
 			def gradleOpts = "-XX:MaxPermSize=1024m -Xmx1024m"
@@ -49,7 +49,7 @@ import org.gradle.api.tasks.TaskAction
 public class DetectSplitPackagesPlugin implements Plugin<Project> {
 	public void apply(Project project) {
 		def tasks = project.tasks
-		Task detectSplitPackages = tasks.add("detectSplitPackages", DetectSplitPackagesTask.class)
+		Task detectSplitPackages = tasks.create("detectSplitPackages", DetectSplitPackagesTask.class)
 		if (tasks.asMap.containsKey("check")) {
 			tasks.getByName("check").dependsOn detectSplitPackages
 		}
@@ -21,20 +21,17 @@ 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,8 +64,8 @@ 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]
@@ -76,13 +73,13 @@ class MergePlugin implements Plugin<Project> {

 		// 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))
 			}
@@ -120,8 +117,8 @@ 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([
@@ -131,7 +128,7 @@ class MergePlugin implements Plugin<Project> {
 				configuration.dependencies.each {
 					def intoCompile = project.merge.into.configurations.getByName("compile")
 					// Protect against changing a compile scope dependency (SPR-10218)
-					if(!intoCompile.dependencies.contains(it)) {
+					if (!intoCompile.dependencies.contains(it)) {
 						intoConfiguration.dependencies.add(it)
 					}
 				}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -21,7 +21,6 @@ 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.
@@ -41,11 +40,10 @@ class TestSourceSetDependenciesPlugin implements Plugin<Project> {
 		}
 	}

-	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies,
-			Project project) {
-		for(def configurationName in ["compile", "optional", "provided", "testCompile"]) {
+	private void collectProjectDependencies(Set<ProjectDependency> projectDependencies, Project project) {
+		for (def configurationName in ["compile", "optional", "provided", "testCompile"]) {
 			Configuration configuration = project.getConfigurations().findByName(configurationName)
-			if(configuration) {
+			if (configuration) {
 				configuration.dependencies.findAll { it instanceof ProjectDependency }.each {
 					projectDependencies.add(it)
 					collectProjectDependencies(projectDependencies, it.dependencyProject)
@@ -1 +1 @@
-version=3.2.3.BUILD-SNAPSHOT
+version=3.2.17.RELEASE
@@ -41,6 +41,17 @@ eclipse.classpath.file.whenMerged { classpath ->
 	}
 }

+// Ensure project dependencies come after 3rd-party libs (SPR-11836)
+// https://jira.spring.io/browse/SPR-11836
+eclipse.classpath.file.whenMerged { classpath ->
+	classpath.entries.findAll { it instanceof ProjectDependency }.each {
+		// delete from original position
+		classpath.entries.remove(it)
+		// append to end of classpath
+		classpath.entries.add(it)
+	}
+}
+
 // Allow projects to be used as WPT modules
 eclipse.project.natures "org.eclipse.wst.common.project.facet.core.nature"

@@ -43,7 +43,7 @@ def customizePom(pom, gradleProject) {
 				developer {
 					id = "jhoeller"
 					name = "Juergen Hoeller"
-					email = "jhoeller@vmware.com"
+					email = "jhoeller@gopivotal.com"
 				}
 			}
 		}
@@ -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-1.12-bin.zip
@@ -22,6 +22,7 @@ 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"
@@ -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.
@@ -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
@@ -39,6 +39,6 @@ public interface IntroductionAwareMethodMatcher extends MethodMatcher {
 	 * asking is the subject on one or more introductions; {@code false} otherwise
 	 * @return whether or not this method matches statically
 	 */
-	boolean matches(Method method, Class targetClass, boolean hasIntroductions);
+	boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions);

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

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -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
@@ -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) {
@@ -290,7 +290,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		}
 	}

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

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

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

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

 		int numUnboundArgs = this.adviceInvocationArgumentCount;
-		Class[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
 		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0])) {
 			numUnboundArgs--;
 		}
@@ -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");
@@ -405,7 +405,7 @@ public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedence
 		return false;
 	}

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

 		int index = 0;
 		for (int i = 0; i < this.argumentNames.length; i++) {
@@ -678,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);
 		}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -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;

@@ -98,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);
@@ -123,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(
@@ -137,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;
 	}

@@ -180,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.
 	 */
@@ -202,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);
 	}

@@ -244,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);
@@ -283,11 +276,19 @@ public class AspectJExpressionPointcut extends AbstractExpressionPointcut
 		}
 		else {
 			// the maybe case
-			return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));
+			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);
 	}

@@ -296,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);
@@ -318,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();
@@ -350,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);
 	}
@@ -396,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);
 				}
@@ -551,7 +562,7 @@ 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
@@ -601,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) {
@@ -612,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);
 		}
-
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -39,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);
 	}

 }
@@ -45,43 +45,41 @@ 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 (messageKind == IMessage.DEBUG) {
-			if (LOGGER.isDebugEnabled() || LOGGER.isTraceEnabled()) {
-				LOGGER.debug(makeMessageFor(message));
+			if (logger.isDebugEnabled()) {
+				logger.debug(makeMessageFor(message));
 				return true;
 			}
 		}
-		else if ((messageKind == IMessage.INFO) || (messageKind == IMessage.WEAVEINFO)) {
-			if (LOGGER.isInfoEnabled()) {
-				LOGGER.info(makeMessageFor(message));
+		else if (messageKind == IMessage.INFO || messageKind == IMessage.WEAVEINFO) {
+			if (logger.isInfoEnabled()) {
+				logger.info(makeMessageFor(message));
 				return true;
 			}
 		}
 		else if (messageKind == IMessage.WARNING) {
-			if (LOGGER.isWarnEnabled()) {
-				LOGGER.warn(makeMessageFor(message));
+			if (logger.isWarnEnabled()) {
+				logger.warn(makeMessageFor(message));
 				return true;
 			}
 		}
 		else if (messageKind == IMessage.ERROR) {
-			if (LOGGER.isErrorEnabled()) {
-				LOGGER.error(makeMessageFor(message));
+			if (logger.isErrorEnabled()) {
+				logger.error(makeMessageFor(message));
 				return true;
 			}
 		}
 		else if (messageKind == IMessage.ABORT) {
-			if (LOGGER.isFatalEnabled()) {
-				LOGGER.fatal(makeMessageFor(message));
+			if (logger.isFatalEnabled()) {
+				logger.fatal(makeMessageFor(message));
 				return true;
 			}
 		}
-
 		return false;
 	}

@@ -34,7 +34,7 @@ import org.springframework.aop.support.DelegatingIntroductionInterceptor;
 */
 public class DeclareParentsAdvisor implements IntroductionAdvisor {

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

 	private final ClassFilter typePatternClassFilter;

@@ -47,7 +47,7 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param defaultImpl the default implementation class
 	 */
-	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Class defaultImpl) {
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> defaultImpl) {
 		this(interfaceType, typePattern, defaultImpl,
 			 new DelegatePerTargetObjectIntroductionInterceptor(defaultImpl, interfaceType));
 	}
@@ -58,7 +58,7 @@ public class DeclareParentsAdvisor implements IntroductionAdvisor {
 	 * @param typePattern type pattern the introduction is restricted to
 	 * @param delegateRef the delegate implementation object
 	 */
-	public DeclareParentsAdvisor(Class interfaceType, String typePattern, Object delegateRef) {
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Object delegateRef) {
 		this(interfaceType, typePattern, delegateRef.getClass(),
 			 new DelegatingIntroductionInterceptor(delegateRef));
 	}
@@ -71,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};
 	}

 }
@@ -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.
@@ -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;
@@ -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));
 	}
@@ -140,19 +154,11 @@ class RuntimeTestWalker {

 		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,11 +166,13 @@ 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;
@@ -172,19 +180,34 @@ class RuntimeTestWalker {

 		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,8 +251,11 @@ 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) {
@@ -240,8 +266,8 @@ class RuntimeTestWalker {
 		@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;
 			}
 		}
@@ -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.
@@ -67,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;
 	}

@@ -89,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
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -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;

 /**
@@ -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,20 @@ 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() {
+		return (this.beanFactory instanceof AbstractBeanFactory ?
+				((AbstractBeanFactory) this.beanFactory).getSingletonMutex() : this);
+	}
+
 	/**
 	 * Determine the order for this factory's target aspect, either
 	 * an instance-specific order expressed through implementing the
@@ -105,7 +112,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();
 			}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -42,9 +42,13 @@ public class LazySingletonAspectInstanceFactoryDecorator implements MetadataAwar
 	}


-	public synchronized Object getAspectInstance() {
+	public Object getAspectInstance() {
 		if (this.materialized == null) {
-			synchronized (this) {
+			Object mutex = this;
+			if (this.maaif instanceof BeanFactoryAspectInstanceFactory) {
+				mutex = ((BeanFactoryAspectInstanceFactory) this.maaif).getAspectCreationMutex();
+			}
+			synchronized (mutex) {
 				if (this.materialized == null) {
 					this.materialized = this.maaif.getAspectInstance();
 				}
@@ -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.
@@ -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;

 /**
@@ -58,7 +59,7 @@ public class SimpleMetadataAwareAspectInstanceFactory extends SimpleAspectInstan
 	 */
 	@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();
 		}
@@ -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.
@@ -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;

 /**
@@ -59,7 +60,7 @@ public class SingletonMetadataAwareAspectInstanceFactory extends SingletonAspect
 	 */
 	@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();
 		}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -49,7 +49,7 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyConfig
 	 */
 	private int order = Ordered.LOWEST_PRECEDENCE;

-	private final Map<Class, Boolean> eligibleBeans = new ConcurrentHashMap<Class, Boolean>(64);
+	private final Map<Class<?>, Boolean> eligibleBeans = new ConcurrentHashMap<Class<?>, Boolean>(64);


 	/**
@@ -87,9 +87,11 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyConfig
 			// Ignore AOP infrastructure such as scoped proxies.
 			return bean;
 		}
-		if (isEligible(bean, beanName)) {
-			if (bean instanceof Advised) {
-				Advised advised = (Advised) bean;
+
+		if (bean instanceof Advised) {
+			Advised advised = (Advised) bean;
+			if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) {
+				// Add our local Advisor to the existing proxy's Advisor chain...
 				if (this.beforeExistingAdvisors) {
 					advised.addAdvisor(0, this.advisor);
 				}
@@ -98,32 +100,47 @@ public abstract class AbstractAdvisingBeanPostProcessor extends ProxyConfig
 				}
 				return bean;
 			}
-			else {
-				ProxyFactory proxyFactory = new ProxyFactory(bean);
-				// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
-				proxyFactory.copyFrom(this);
-				proxyFactory.addAdvisor(this.advisor);
-				return proxyFactory.getProxy(this.beanClassLoader);
-			}
 		}
-		else {
-			// No async proxy needed.
-			return bean;
+
+		if (isEligible(bean, beanName)) {
+			ProxyFactory proxyFactory = new ProxyFactory(bean);
+			// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
+			proxyFactory.copyFrom(this);
+			proxyFactory.addAdvisor(this.advisor);
+			return proxyFactory.getProxy(this.beanClassLoader);
 		}
+
+		// No async proxy needed.
+		return bean;
 	}

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

 	/**
 	 * Determine whether the given interface is proxied.
 	 * @param intf the interface to check
 	 */
-	boolean isInterfaceProxied(Class intf);
+	boolean isInterfaceProxied(Class<?> intf);


 	/**
@@ -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.
@@ -158,7 +158,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @see #setTargetSource
 	 * @see #setTarget
 	 */
-	public void setTargetClass(Class targetClass) {
+	public void setTargetClass(Class<?> targetClass) {
 		this.targetSource = EmptyTargetSource.forClass(targetClass);
 	}

@@ -194,7 +194,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	/**
 	 * Set the interfaces to be proxied.
 	 */
-	public void setInterfaces(Class[] interfaces) {
+	public void setInterfaces(Class<?>... interfaces) {
 		Assert.notNull(interfaces, "Interfaces must not be null");
 		this.interfaces.clear();
 		for (Class ifc : interfaces) {
@@ -206,7 +206,7 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * Add a new proxied interface.
 	 * @param intf the additional interface to proxy
 	 */
-	public void addInterface(Class intf) {
+	public void addInterface(Class<?> intf) {
 		Assert.notNull(intf, "Interface must not be null");
 		if (!intf.isInterface()) {
 			throw new IllegalArgumentException("[" + intf.getName() + "] is not an interface");
@@ -224,15 +224,15 @@ public class AdvisedSupport extends ProxyConfig implements Advised {
 	 * @return {@code true} if the interface was removed; {@code false}
 	 * if the interface was not found and hence could not be removed
 	 */
-	public boolean removeInterface(Class intf) {
+	public boolean removeInterface(Class<?> intf) {
 		return this.interfaces.remove(intf);
 	}

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

-	public boolean isInterfaceProxied(Class intf) {
+	public boolean isInterfaceProxied(Class<?> intf) {
 		for (Class proxyIntf : this.interfaces) {
 			if (intf.isAssignableFrom(proxyIntf)) {
 				return true;
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -25,7 +25,19 @@ import java.util.List;
 import java.util.Map;
 import java.util.WeakHashMap;

+import org.aopalliance.aop.Advice;
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.AopInvocationException;
+import org.springframework.aop.PointcutAdvisor;
+import org.springframework.aop.RawTargetAccess;
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.support.AopUtils;
 import org.springframework.cglib.core.CodeGenerationException;
+import org.springframework.cglib.core.SpringNamingPolicy;
 import org.springframework.cglib.proxy.Callback;
 import org.springframework.cglib.proxy.CallbackFilter;
 import org.springframework.cglib.proxy.Dispatcher;
@@ -34,18 +46,7 @@ import org.springframework.cglib.proxy.Factory;
 import org.springframework.cglib.proxy.MethodInterceptor;
 import org.springframework.cglib.proxy.MethodProxy;
 import org.springframework.cglib.proxy.NoOp;
-import org.springframework.cglib.transform.impl.UndeclaredThrowableStrategy;
-
-import org.aopalliance.aop.Advice;
-import org.aopalliance.intercept.MethodInvocation;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.springframework.aop.Advisor;
-import org.springframework.aop.AopInvocationException;
-import org.springframework.aop.PointcutAdvisor;
-import org.springframework.aop.RawTargetAccess;
-import org.springframework.aop.TargetSource;
-import org.springframework.aop.support.AopUtils;
+import org.springframework.cglib.transform.impl.MemorySafeUndeclaredThrowableStrategy;
 import org.springframework.core.SmartClassLoader;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -181,20 +182,20 @@ final class CglibAopProxy implements AopProxy, Serializable {
 				}
 			}
 			enhancer.setSuperclass(proxySuperClass);
-			enhancer.setStrategy(new UndeclaredThrowableStrategy(UndeclaredThrowableException.class));
 			enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
+			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
+			enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
 			enhancer.setInterceptDuringConstruction(false);

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

 			// Generate the proxy class and create a proxy instance.
 			Object proxy;
@@ -253,11 +254,14 @@ final class CglibAopProxy implements AopProxy, Serializable {
 	 * for each one found.
 	 */
 	private void doValidateClass(Class<?> proxySuperClass) {
-		Method[] methods = proxySuperClass.getMethods();
-		for (Method method : methods) {
-			if (!Object.class.equals(method.getDeclaringClass()) && Modifier.isFinal(method.getModifiers())) {
-				logger.warn("Unable to proxy method [" + method + "] because it is final: " +
-						"All calls to this method via a proxy will be routed directly to the proxy.");
+		if (logger.isWarnEnabled()) {
+			Method[] methods = proxySuperClass.getMethods();
+			for (Method method : methods) {
+				if (!Object.class.equals(method.getDeclaringClass()) && !Modifier.isStatic(method.getModifiers()) &&
+						Modifier.isFinal(method.getModifiers())) {
+					logger.warn("Unable to proxy method [" + method + "] because it is final: " +
+							"All calls to this method via a proxy will NOT be routed to the target instance.");
+				}
 			}
 		}
 	}
@@ -309,8 +313,7 @@ final class CglibAopProxy implements AopProxy, Serializable {
 			Callback[] fixedCallbacks = new Callback[methods.length];
 			this.fixedInterceptorMap = new HashMap<String, Integer>(methods.length);

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

-		private AdvisedSupport advised;
+		private final AdvisedSupport advised;

 		public DynamicAdvisedInterceptor(AdvisedSupport advised) {
 			this.advised = advised;
@@ -609,8 +611,8 @@ final class CglibAopProxy implements AopProxy, Serializable {
 					oldProxy = AopContext.setCurrentProxy(proxy);
 					setProxyContext = true;
 				}
-				// May be null Get as late as possible to minimize the time we
-				// "own" the target, in case it comes from a pool.
+				// May be null. Get as late as possible to minimize the time we
+				// "own" the target, in case it comes from a pool...
 				target = getTarget();
 				if (target != null) {
 					targetClass = target.getClass();
@@ -815,8 +817,8 @@ final class CglibAopProxy implements AopProxy, Serializable {
 				// of the target type. If so we know it never needs to have return type
 				// massage and can use a dispatcher.
 				// If the proxy is being exposed, then must use the interceptor the
-				// correct one is already configured. If the target is not static cannot
-				// use a Dispatcher because the target can not then be released.
+				// correct one is already configured. If the target is not static, then
+				// cannot use a dispatcher because the target cannot be released.
 				if (exposeProxy || !isStatic) {
 					return INVOKE_TARGET;
 				}
@@ -848,7 +850,7 @@ final class CglibAopProxy implements AopProxy, Serializable {

 		@Override
 		public boolean equals(Object other) {
-			if (other == this) {
+			if (this == other) {
 				return true;
 			}
 			if (!(other instanceof ProxyCallbackFilter)) {
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -75,7 +75,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 */

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

 	/** Config used to configure this proxy */
 	private final AdvisedSupport advised;
@@ -114,7 +114,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		if (logger.isDebugEnabled()) {
 			logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
 		}
-		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
+		Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
 		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
 		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
 	}
@@ -124,8 +124,8 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 	 * on the supplied set of interfaces.
 	 * @param proxiedInterfaces the interfaces to introspect
 	 */
-	private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
-		for (Class proxiedInterface : proxiedInterfaces) {
+	private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
+		for (Class<?> proxiedInterface : proxiedInterfaces) {
 			Method[] methods = proxiedInterface.getDeclaredMethods();
 			for (Method method : methods) {
 				if (AopUtils.isEqualsMethod(method)) {
@@ -153,7 +153,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 		boolean setProxyContext = false;

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

 		try {
@@ -212,8 +212,10 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
 				// is type-compatible. Note that we can't help if the target sets
 				// a reference to itself in another returned object.
 				retVal = proxy;
-			} else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
-				throw new AopInvocationException("Null return value from advice does not match primitive return type for: " + method);
+			}
+			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
+				throw new AopInvocationException(
+						"Null return value from advice does not match primitive return type for: " + method);
 			}
 			return retVal;
 		}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -19,7 +19,6 @@ package org.springframework.aop.framework;
 import org.aopalliance.intercept.Interceptor;

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

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

 	/**
@@ -57,7 +55,7 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * <p>No target, only interfaces. Must add interceptors.
 	 * @param proxyInterfaces the interfaces that the proxy should implement
 	 */
-	public ProxyFactory(Class[] proxyInterfaces) {
+	public ProxyFactory(Class<?>... proxyInterfaces) {
 		setInterfaces(proxyInterfaces);
 	}

@@ -69,7 +67,7 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @param proxyInterface the interface that the proxy should implement
 	 * @param interceptor the interceptor that the proxy should invoke
 	 */
-	public ProxyFactory(Class proxyInterface, Interceptor interceptor) {
+	public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
 		addInterface(proxyInterface);
 		addAdvice(interceptor);
 	}
@@ -80,7 +78,7 @@ public class ProxyFactory extends ProxyCreatorSupport {
 	 * @param proxyInterface the interface that the proxy should implement
 	 * @param targetSource the TargetSource that the proxy should invoke
 	 */
-	public ProxyFactory(Class proxyInterface, TargetSource targetSource) {
+	public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
 		addInterface(proxyInterface);
 		setTargetSource(targetSource);
 	}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -133,7 +133,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @see #setInterfaces
 	 * @see AbstractSingletonProxyFactoryBean#setProxyInterfaces
 	 */
-	public void setProxyInterfaces(Class[] proxyInterfaces) throws ClassNotFoundException {
+	public void setProxyInterfaces(Class<?>[] proxyInterfaces) throws ClassNotFoundException {
 		setInterfaces(proxyInterfaces);
 	}

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

@@ -263,7 +263,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 				return this.singletonInstance.getClass();
 			}
 		}
-		Class[] ifcs = getProxiedInterfaces();
+		Class<?>[] ifcs = getProxiedInterfaces();
 		if (ifcs.length == 1) {
 			return ifcs[0];
 		}
@@ -292,7 +292,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @return the merged interface as Class
 	 * @see java.lang.reflect.Proxy#getProxyClass
 	 */
-	protected Class createCompositeInterface(Class[] interfaces) {
+	protected Class<?> createCompositeInterface(Class<?>[] interfaces) {
 		return ClassUtils.createCompositeInterface(interfaces, this.proxyClassLoader);
 	}

@@ -306,7 +306,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 			this.targetSource = freshTargetSource();
 			if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
 				// Rely on AOP infrastructure to tell us what interfaces to proxy.
-				Class targetClass = getTargetClass();
+				Class<?> targetClass = getTargetClass();
 				if (targetClass == null) {
 					throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
 				}
@@ -396,7 +396,7 @@ public class ProxyFactoryBean extends ProxyCreatorSupport
 	 * @return {@code true} if it's an Advisor or Advice
 	 */
 	private boolean isNamedBeanAnAdvisorOrAdvice(String beanName) {
-		Class namedBeanClass = this.beanFactory.getType(beanName);
+		Class<?> namedBeanClass = this.beanFactory.getType(beanName);
 		if (namedBeanClass != null) {
 			return (Advisor.class.isAssignableFrom(namedBeanClass) || Advice.class.isAssignableFrom(namedBeanClass));
 		}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -198,7 +198,7 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig
 	 * Ordering is significant: The TargetSource returned from the first matching
 	 * TargetSourceCreator (that is, the first that returns non-null) will be used.
 	 */
-	public void setCustomTargetSourceCreators(TargetSourceCreator[] targetSourceCreators) {
+	public void setCustomTargetSourceCreators(TargetSourceCreator... targetSourceCreators) {
 		this.customTargetSourceCreators = targetSourceCreators;
 	}

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

@@ -262,7 +262,9 @@ public abstract class AbstractAutoProxyCreator extends ProxyConfig

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

@@ -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.
@@ -81,24 +81,32 @@ public class BeanFactoryAdvisorRetrievalHelper {

 		List<Advisor> advisors = new LinkedList<Advisor>();
 		for (String name : advisorNames) {
-			if (isEligibleBean(name) && !this.beanFactory.isCurrentlyInCreation(name)) {
-				try {
-					advisors.add(this.beanFactory.getBean(name, Advisor.class));
-				}
-				catch (BeanCreationException ex) {
-					Throwable rootCause = ex.getMostSpecificCause();
-					if (rootCause instanceof BeanCurrentlyInCreationException) {
-						BeanCreationException bce = (BeanCreationException) rootCause;
-						if (this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
-							if (logger.isDebugEnabled()) {
-								logger.debug("Ignoring currently created advisor '" + name + "': " + ex.getMessage());
-							}
-							// Ignore: indicates a reference back to the bean we're trying to advise.
-							// We want to find advisors other than the currently created bean itself.
-							continue;
-						}
+			if (isEligibleBean(name)) {
+				if (this.beanFactory.isCurrentlyInCreation(name)) {
+					if (logger.isDebugEnabled()) {
+						logger.debug("Skipping currently created advisor '" + name + "'");
+					}
+				}
+				else {
+					try {
+						advisors.add(this.beanFactory.getBean(name, Advisor.class));
+					}
+					catch (BeanCreationException ex) {
+						Throwable rootCause = ex.getMostSpecificCause();
+						if (rootCause instanceof BeanCurrentlyInCreationException) {
+							BeanCreationException bce = (BeanCreationException) rootCause;
+							if (this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
+								if (logger.isDebugEnabled()) {
+									logger.debug("Skipping advisor '" + name +
+											"' with dependency on currently created bean: " + ex.getMessage());
+								}
+								// Ignore: indicates a reference back to the bean we're trying to advise.
+								// We want to find advisors other than the currently created bean itself.
+								continue;
+							}
+						}
+						throw ex;
 					}
-					throw ex;
 				}
 			}
 		}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -60,7 +60,7 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 	 * @see org.springframework.beans.factory.FactoryBean
 	 * @see org.springframework.beans.factory.BeanFactory#FACTORY_BEAN_PREFIX
 	 */
-	public void setBeanNames(String[] beanNames) {
+	public void setBeanNames(String... beanNames) {
 		Assert.notEmpty(beanNames, "'beanNames' must not be empty");
 		this.beanNames = new ArrayList<String>(beanNames.length);
 		for (String mappedName : beanNames) {
@@ -73,7 +73,7 @@ public class BeanNameAutoProxyCreator extends AbstractAutoProxyCreator {
 	 * Identify as bean to proxy if the bean name is in the configured list of names.
 	 */
 	@Override
-	protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
+	protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
 		if (this.beanNames != null) {
 			for (String mappedName : this.beanNames) {
 				if (FactoryBean.class.isAssignableFrom(beanClass)) {
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -25,7 +25,7 @@ import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 * TargetSourceCreator that enforces a LazyInitTargetSource for each bean
 * that is defined as "lazy-init". This will lead to a proxy created for
 * each of those beans, allowing to fetch a reference to such a bean
- * without actually initialized the target bean instance.
+ * without actually initializing the target bean instance.
 *
 * <p>To be registered as custom TargetSourceCreator for an auto-proxy creator,
 * in combination with custom interceptors for specific beans or for the
@@ -60,7 +60,7 @@ public class LazyInitTargetSourceCreator extends AbstractBeanFactoryBasedTargetS

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

 		if (getBeanFactory() instanceof ConfigurableListableBeanFactory) {
 			BeanDefinition definition =
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -21,7 +21,6 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;

-import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
@@ -32,7 +31,7 @@ import org.springframework.util.StringUtils;

 /**
 * Base class for asynchronous method execution aspects, such as
- * {@link org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor}
+ * {@code org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor}
 * or {@code org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect}.
 *
 * <p>Provides support for <i>executor qualification</i> on a method-by-method basis.
@@ -80,14 +79,14 @@ public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
 	/**
 	 * Set the {@link BeanFactory} to be used when looking up executors by qualifier.
 	 */
-	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+	public void setBeanFactory(BeanFactory beanFactory) {
 		this.beanFactory = beanFactory;
 	}


 	/**
 	 * Determine the specific executor to use when executing the given method.
-	 * @return the executor to use (never {@code null})
+	 * @return the executor to use (or {@code null}, but just if no default executor has been set)
 	 */
 	protected AsyncTaskExecutor determineAsyncExecutor(Method method) {
 		AsyncTaskExecutor executor = this.executors.get(method);
@@ -101,8 +100,7 @@ public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
 						this.beanFactory, Executor.class, qualifier);
 			}
 			else if (executorToUse == null) {
-				throw new IllegalStateException("No executor qualifier specified and no default executor set on " +
-						getClass().getSimpleName() + " either");
+				return null;
 			}
 			executor = (executorToUse instanceof AsyncTaskExecutor ?
 					(AsyncTaskExecutor) executorToUse : new TaskExecutorAdapter(executorToUse));
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -62,11 +62,11 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport

 	/**
 	 * Create a new {@code AsyncExecutionInterceptor}.
-	 * @param executor the {@link Executor} (typically a Spring {@link AsyncTaskExecutor}
-	 * or {@link java.util.concurrent.ExecutorService}) to delegate to.
+	 * @param defaultExecutor the {@link Executor} (typically a Spring {@link AsyncTaskExecutor}
+	 * or {@link java.util.concurrent.ExecutorService}) to delegate to
 	 */
-	public AsyncExecutionInterceptor(Executor executor) {
-		super(executor);
+	public AsyncExecutionInterceptor(Executor defaultExecutor) {
+		super(defaultExecutor);
 	}


@@ -82,7 +82,13 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport
 		Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);
 		specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

-		Future<?> result = determineAsyncExecutor(specificMethod).submit(
+		AsyncTaskExecutor executor = determineAsyncExecutor(specificMethod);
+		if (executor == null) {
+			throw new IllegalStateException(
+					"No executor specified and no default executor set on AsyncExecutionInterceptor either");
+		}
+
+		Future<?> result = executor.submit(
 				new Callable<Object>() {
 					public Object call() throws Exception {
 						try {
@@ -111,8 +117,8 @@ public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport
 	 * Subclasses may override to provide support for extracting qualifier information,
 	 * e.g. via an annotation on the given method.
 	 * @return always {@code null}
-	 * @see #determineAsyncExecutor(Method)
 	 * @since 3.1.2
+	 * @see #determineAsyncExecutor(Method)
 	 */
 	@Override
 	protected String getExecutorQualifier(Method method) {
@@ -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.
@@ -151,7 +151,7 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 	/**
 	 * The {@code Set} of allowed placeholders.
 	 */
-	private static final Set ALLOWED_PLACEHOLDERS =
+	private static final Set<Object> ALLOWED_PLACEHOLDERS =
 			new Constants(CustomizableTraceInterceptor.class).getValues("PLACEHOLDER_");


@@ -258,7 +258,7 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 			return returnValue;
 		}
 		catch (Throwable ex) {
-			if(stopWatch.isRunning()) {
+			if (stopWatch.isRunning()) {
 				stopWatch.stop();
 			}
 			exitThroughException = true;
@@ -268,7 +268,7 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 		}
 		finally {
 			if (!exitThroughException) {
-				if(stopWatch.isRunning()) {
+				if (stopWatch.isRunning()) {
 					stopWatch.stop();
 				}
 				writeToLog(logger,
@@ -325,18 +325,19 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 		while (matcher.find()) {
 			String match = matcher.group();
 			if (PLACEHOLDER_METHOD_NAME.equals(match)) {
-				matcher.appendReplacement(output, escape(methodInvocation.getMethod().getName()));
+				matcher.appendReplacement(output, Matcher.quoteReplacement(methodInvocation.getMethod().getName()));
 			}
 			else if (PLACEHOLDER_TARGET_CLASS_NAME.equals(match)) {
 				String className = getClassForLogging(methodInvocation.getThis()).getName();
-				matcher.appendReplacement(output, escape(className));
+				matcher.appendReplacement(output, Matcher.quoteReplacement(className));
 			}
 			else if (PLACEHOLDER_TARGET_CLASS_SHORT_NAME.equals(match)) {
 				String shortName = ClassUtils.getShortName(getClassForLogging(methodInvocation.getThis()));
-				matcher.appendReplacement(output, escape(shortName));
+				matcher.appendReplacement(output, Matcher.quoteReplacement(shortName));
 			}
 			else if (PLACEHOLDER_ARGUMENTS.equals(match)) {
-				matcher.appendReplacement(output, escape(StringUtils.arrayToCommaDelimitedString(methodInvocation.getArguments())));
+				matcher.appendReplacement(output,
+						Matcher.quoteReplacement(StringUtils.arrayToCommaDelimitedString(methodInvocation.getArguments())));
 			}
 			else if (PLACEHOLDER_ARGUMENT_TYPES.equals(match)) {
 				appendArgumentTypes(methodInvocation, matcher, output);
@@ -345,7 +346,7 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 				appendReturnValue(methodInvocation, matcher, output, returnValue);
 			}
 			else if (throwable != null && PLACEHOLDER_EXCEPTION.equals(match)) {
-				matcher.appendReplacement(output, escape(throwable.toString()));
+				matcher.appendReplacement(output, Matcher.quoteReplacement(throwable.toString()));
 			}
 			else if (PLACEHOLDER_INVOCATION_TIME.equals(match)) {
 				matcher.appendReplacement(output, Long.toString(invocationTime));
@@ -379,7 +380,7 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 			matcher.appendReplacement(output, "null");
 		}
 		else {
-			matcher.appendReplacement(output, escape(returnValue.toString()));
+			matcher.appendReplacement(output, Matcher.quoteReplacement(returnValue.toString()));
 		}
 	}

@@ -394,12 +395,13 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 	 * @param output the {@code StringBuffer} containing the output
 	 */
 	private void appendArgumentTypes(MethodInvocation methodInvocation, Matcher matcher, StringBuffer output) {
-		Class[] argumentTypes = methodInvocation.getMethod().getParameterTypes();
+		Class<?>[] argumentTypes = methodInvocation.getMethod().getParameterTypes();
 		String[] argumentTypeShortNames = new String[argumentTypes.length];
 		for (int i = 0; i < argumentTypeShortNames.length; i++) {
 			argumentTypeShortNames[i] = ClassUtils.getShortName(argumentTypes[i]);
 		}
-		matcher.appendReplacement(output, escape(StringUtils.arrayToCommaDelimitedString(argumentTypeShortNames)));
+		matcher.appendReplacement(output,
+				Matcher.quoteReplacement(StringUtils.arrayToCommaDelimitedString(argumentTypeShortNames)));
 	}

 	/**
@@ -417,27 +419,4 @@ public class CustomizableTraceInterceptor extends AbstractTraceInterceptor {
 		}
 	}

-	/**
-	 * Replaces {@code $} in inner class names with {@code \$}.
-	 * <p>This code is equivalent to JDK 1.5's {@code quoteReplacement}
-	 * method in the Matcher class itself. We're keeping our own version
-	 * here for JDK 1.4 compliance reasons only.
-	 */
-	private String escape(String input) {
-		StringBuilder sb = new StringBuilder();
-		for (int i = 0; i < input.length(); i++) {
-			char c = input.charAt(i);
-			if (c == '\\') {
-				sb.append("\\\\");
-			}
-			else if (c == '$') {
-				sb.append("\\$");
-			}
-			else {
-				sb.append(c);
-			}
-		}
-		return sb.toString();
-	}
-
 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -90,7 +90,7 @@ public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean<O
 		pf.copyFrom(this);
 		pf.setTargetSource(this.scopedTargetSource);

-		Class beanType = beanFactory.getType(this.targetBeanName);
+		Class<?> beanType = beanFactory.getType(this.targetBeanName);
 		if (beanType == null) {
 			throw new IllegalStateException("Cannot create scoped proxy for bean '" + this.targetBeanName +
 					"': Target type could not be determined at the time of proxy creation.");
@@ -122,10 +122,7 @@ public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean<O
 		if (this.proxy != null) {
 			return this.proxy.getClass();
 		}
-		if (this.scopedTargetSource != null) {
-			return this.scopedTargetSource.getTargetClass();
-		}
-		return null;
+		return this.scopedTargetSource.getTargetClass();
 	}

 	public boolean isSingleton() {
@@ -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.
@@ -38,7 +38,7 @@ public abstract class ScopedProxyUtils {


 	/**
-	 * Generates a scoped proxy for the supplied target bean, registering the target
+	 * Generate a scoped proxy for the supplied target bean, registering the target
 	 * bean with an internal name and setting 'targetBeanName' on the scoped proxy.
 	 * @param definition the original bean definition
 	 * @param registry the bean definition registry
@@ -50,20 +50,20 @@ public abstract class ScopedProxyUtils {

 		String originalBeanName = definition.getBeanName();
 		BeanDefinition targetDefinition = definition.getBeanDefinition();
+		String targetBeanName = getTargetBeanName(originalBeanName);

 		// Create a scoped proxy definition for the original bean name,
 		// "hiding" the target bean in an internal target definition.
 		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
-		proxyDefinition.setOriginatingBeanDefinition(definition.getBeanDefinition());
+		proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
+		proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
 		proxyDefinition.setSource(definition.getSource());
 		proxyDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

-		String targetBeanName = getTargetBeanName(originalBeanName);
 		proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
-
 		if (proxyTargetClass) {
 			targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
-			// ScopedFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
+			// ScopedProxyFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
 		}
 		else {
 			proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
@@ -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.
@@ -29,17 +29,16 @@ import org.springframework.util.StringUtils;
 * <ul>
 * <li>pattern: regular expression for the fully-qualified method names to match.
 * The exact regexp syntax will depend on the subclass (e.g. Perl5 regular expressions)
- * <li>patterns: alternative property taking a String array of patterns. The result will
- * be the union of these patterns.
+ * <li>patterns: alternative property taking a String array of patterns.
+ * The result will be the union of these patterns.
 * </ul>
 *
 * <p>Note: the regular expressions must be a match. For example,
 * {@code .*get.*} will match com.mycom.Foo.getBar().
 * {@code get.*} will not.
 *
- * <p>This base class is serializable. Subclasses should declare all fields transient
- * - the initPatternRepresentation method in this class will be invoked again on the
- * client side on deserialization.
+ * <p>This base class is serializable. Subclasses should declare all fields transient;
+ * the {@link #initPatternRepresentation} method will be invoked again on deserialization.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
@@ -51,10 +50,14 @@ import org.springframework.util.StringUtils;
 public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPointcut
 		implements Serializable {

-	/** Regular expressions to match */
+	/**
+	 * Regular expressions to match.
+	 */
 	private String[] patterns = new String[0];

-	/** Regular expressions <strong>not</strong> to match */
+	/**
+	 * Regular expressions <strong>not</strong> to match.
+	 */
 	private String[] excludedPatterns = new String[0];


@@ -64,15 +67,15 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	 * @see #setPatterns
 	 */
 	public void setPattern(String pattern) {
-		setPatterns(new String[] {pattern});
+		setPatterns(pattern);
 	}

 	/**
 	 * Set the regular expressions defining methods to match.
-	 * Matching will be the union of all these; if any match,
-	 * the pointcut matches.
+	 * Matching will be the union of all these; if any match, the pointcut matches.
+	 * @see #setPattern
 	 */
-	public void setPatterns(String[] patterns) {
+	public void setPatterns(String... patterns) {
 		Assert.notEmpty(patterns, "'patterns' must not be empty");
 		this.patterns = new String[patterns.length];
 		for (int i = 0; i < patterns.length; i++) {
@@ -94,15 +97,15 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	 * @see #setExcludedPatterns
 	 */
 	public void setExcludedPattern(String excludedPattern) {
-		setExcludedPatterns(new String[] {excludedPattern});
+		setExcludedPatterns(excludedPattern);
 	}

 	/**
 	 * Set the regular expressions defining methods to match for exclusion.
-	 * Matching will be the union of all these; if any match,
-	 * the pointcut matches.
+	 * Matching will be the union of all these; if any match, the pointcut matches.
+	 * @see #setExcludedPattern
 	 */
-	public void setExcludedPatterns(String[] excludedPatterns) {
+	public void setExcludedPatterns(String... excludedPatterns) {
 		Assert.notEmpty(excludedPatterns, "'excludedPatterns' must not be empty");
 		this.excludedPatterns = new String[excludedPatterns.length];
 		for (int i = 0; i < excludedPatterns.length; i++) {
@@ -124,7 +127,7 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	 * of the target class as well as against the method's declaring class,
 	 * plus the name of the method.
 	 */
-	public boolean matches(Method method, Class targetClass) {
+	public boolean matches(Method method, Class<?> targetClass) {
 		return ((targetClass != null && matchesPattern(targetClass.getName() + "." + method.getName())) ||
 				matchesPattern(method.getDeclaringClass().getName() + "." + method.getName()));
 	}
@@ -172,18 +175,18 @@ public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPo
 	protected abstract void initExcludedPatternRepresentation(String[] patterns) throws IllegalArgumentException;

 	/**
-	 * Does the pattern at the given index match this string?
-	 * @param pattern {@code String} pattern to match
-	 * @param patternIndex index of pattern from 0
-	 * @return {@code true} if there is a match, else {@code false}.
+	 * Does the pattern at the given index match the given String?
+	 * @param pattern the {@code String} pattern to match
+	 * @param patternIndex index of pattern (starting from 0)
+	 * @return {@code true} if there is a match, {@code false} otherwise
 	 */
 	protected abstract boolean matches(String pattern, int patternIndex);

 	/**
-	 * Does the exclusion pattern at the given index match this string?
-	 * @param pattern {@code String} pattern to match.
-	 * @param patternIndex index of pattern starting from 0.
-	 * @return {@code true} if there is a match, else {@code false}.
+	 * Does the exclusion pattern at the given index match the given String?
+	 * @param pattern the {@code String} pattern to match
+	 * @param patternIndex index of pattern (starting from 0)
+	 * @return {@code true} if there is a match, {@code false} otherwise
 	 */
 	protected abstract boolean matchesExclusion(String pattern, int patternIndex);

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -19,7 +19,7 @@ package org.springframework.aop.support;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
@@ -215,7 +215,7 @@ public abstract class AopUtils {
 			introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
 		}

-		Set<Class> classes = new HashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
+		Set<Class> classes = new LinkedHashSet<Class>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
 		classes.add(targetClass);
 		for (Class<?> clazz : classes) {
 			Method[] methods = clazz.getMethods();
@@ -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.
@@ -23,8 +23,7 @@ import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;

 /**
- * Static utility methods for composing
- * {@link org.springframework.aop.ClassFilter ClassFilters}.
+ * Static utility methods for composing {@link ClassFilter ClassFilters}.
 *
 * @author Rod Johnson
 * @author Rob Harrop
@@ -96,9 +95,9 @@ public abstract class ClassFilters {
 			this.filters = filters;
 		}

-		public boolean matches(Class clazz) {
-			for (int i = 0; i < this.filters.length; i++) {
-				if (this.filters[i].matches(clazz)) {
+		public boolean matches(Class<?> clazz) {
+			for (ClassFilter filter : this.filters) {
+				if (filter.matches(clazz)) {
 					return true;
 				}
 			}
@@ -130,9 +129,9 @@ public abstract class ClassFilters {
 			this.filters = filters;
 		}

-		public boolean matches(Class clazz) {
-			for (int i = 0; i < this.filters.length; i++) {
-				if (!this.filters[i].matches(clazz)) {
+		public boolean matches(Class<?> clazz) {
+			for (ClassFilter filter : this.filters) {
+				if (!filter.matches(clazz)) {
 					return false;
 				}
 			}
@@ -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.
@@ -178,7 +178,6 @@ public class ComposablePointcut implements Pointcut, Serializable {
 		return this.methodMatcher;
 	}

-
 	@Override
 	public boolean equals(Object other) {
 		if (this == other) {
@@ -187,7 +186,6 @@ public class ComposablePointcut implements Pointcut, Serializable {
 		if (!(other instanceof ComposablePointcut)) {
 			return false;
 		}
-
 		ComposablePointcut that = (ComposablePointcut) other;
 		return ObjectUtils.nullSafeEquals(that.classFilter, this.classFilter) &&
 				ObjectUtils.nullSafeEquals(that.methodMatcher, this.methodMatcher);
@@ -207,8 +205,7 @@ public class ComposablePointcut implements Pointcut, Serializable {

 	@Override
 	public String toString() {
-		return "ComposablePointcut: ClassFilter [" + this.classFilter +
-				"], MethodMatcher [" + this.methodMatcher + "]";
+		return "ComposablePointcut: " + this.classFilter + ", " +this.methodMatcher;
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -17,7 +17,7 @@
 package org.springframework.aop.support;

 import java.io.Serializable;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Set;

 import org.aopalliance.aop.Advice;
@@ -43,7 +43,7 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil

 	private final Advice advice;

-	private final Set<Class> interfaces = new HashSet<Class>();
+	private final Set<Class> interfaces = new LinkedHashSet<Class>();

 	private int order = Integer.MAX_VALUE;

@@ -68,11 +68,11 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil
 		Assert.notNull(advice, "Advice must not be null");
 		this.advice = advice;
 		if (introductionInfo != null) {
-			Class[] introducedInterfaces = introductionInfo.getInterfaces();
+			Class<?>[] introducedInterfaces = introductionInfo.getInterfaces();
 			if (introducedInterfaces.length == 0) {
 				throw new IllegalArgumentException("IntroductionAdviceSupport implements no interfaces");
 			}
-			for (Class ifc : introducedInterfaces) {
+			for (Class<?> ifc : introducedInterfaces) {
 				addInterface(ifc);
 			}
 		}
@@ -83,7 +83,7 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil
 	 * @param advice the Advice to apply
 	 * @param intf the interface to introduce
 	 */
-	public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class intf) {
+	public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> intf) {
 		Assert.notNull(advice, "Advice must not be null");
 		this.advice = advice;
 		addInterface(intf);
@@ -94,7 +94,7 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil
 	 * Add the specified interface to the list of interfaces to introduce.
 	 * @param intf the interface to introduce
 	 */
-	public void addInterface(Class intf) {
+	public void addInterface(Class<?> intf) {
 		Assert.notNull(intf, "Interface must not be null");
 		if (!intf.isInterface()) {
 			throw new IllegalArgumentException("Specified class [" + intf.getName() + "] must be an interface");
@@ -102,12 +102,13 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil
 		this.interfaces.add(intf);
 	}

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

+	@Override
 	public void validateInterfaces() throws IllegalArgumentException {
-		for (Class ifc : this.interfaces) {
+		for (Class<?> ifc : this.interfaces) {
 			if (this.advice instanceof DynamicIntroductionAdvice &&
 					!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {
 			 throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +
@@ -138,7 +139,7 @@ public class DefaultIntroductionAdvisor implements IntroductionAdvisor, ClassFil
 		return this;
 	}

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

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -20,7 +20,7 @@ import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
 import java.lang.reflect.Method;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -43,7 +43,7 @@ import org.springframework.util.ClassUtils;
@SuppressWarnings("serial")
 public class IntroductionInfoSupport implements IntroductionInfo, Serializable {

-	protected final Set<Class> publishedInterfaces = new HashSet<Class>();
+	protected final Set<Class> publishedInterfaces = new LinkedHashSet<Class>();

 	private transient Map<Method, Boolean> rememberedMethods = new ConcurrentHashMap<Method, Boolean>(32);

@@ -55,12 +55,12 @@ public class IntroductionInfoSupport implements IntroductionInfo, Serializable {
 	 * <p>Does nothing if the interface is not implemented by the delegate.
 	 * @param intf the interface to suppress
 	 */
-	public void suppressInterface(Class intf) {
+	public void suppressInterface(Class<?> intf) {
 		this.publishedInterfaces.remove(intf);
 	}

-	public Class[] getInterfaces() {
-		return this.publishedInterfaces.toArray(new Class[this.publishedInterfaces.size()]);
+	public Class<?>[] getInterfaces() {
+		return this.publishedInterfaces.toArray(new Class<?>[this.publishedInterfaces.size()]);
 	}

 	/**
@@ -68,8 +68,8 @@ public class IntroductionInfoSupport implements IntroductionInfo, Serializable {
 	 * @param ifc the interface to check
 	 * @return whether the interface is part of this introduction
 	 */
-	public boolean implementsInterface(Class ifc) {
-		for (Class pubIfc : this.publishedInterfaces) {
+	public boolean implementsInterface(Class<?> ifc) {
+		for (Class<?> pubIfc : this.publishedInterfaces) {
 			if (ifc.isInterface() && ifc.isAssignableFrom(pubIfc)) {
 				return true;
 			}
@@ -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.
@@ -25,12 +25,11 @@ import org.springframework.aop.MethodMatcher;
 import org.springframework.util.Assert;

 /**
- * Static utility methods for composing
- * {@link org.springframework.aop.MethodMatcher MethodMatchers}.
+ * Static utility methods for composing {@link MethodMatcher MethodMatchers}.
 *
- * <p>A MethodMatcher may be evaluated statically (based on method
- * and target class) or need further evaluation dynamically
- * (based on arguments at the time of method invocation).
+ * <p>A MethodMatcher may be evaluated statically (based on method and target
+ * class) or need further evaluation dynamically (based on arguments at the
+ * time of method invocation).
 *
 * @author Rod Johnson
 * @author Rob Harrop
@@ -88,7 +87,7 @@ public abstract class MethodMatchers {
 	 * asking is the subject on one or more introductions; {@code false} otherwise
 	 * @return whether or not this method matches statically
 	 */
-	public static boolean matches(MethodMatcher mm, Method method, Class targetClass, boolean hasIntroductions) {
+	public static boolean matches(MethodMatcher mm, Method method, Class<?> targetClass, boolean hasIntroductions) {
 		Assert.notNull(mm, "MethodMatcher must not be null");
 		return ((mm instanceof IntroductionAwareMethodMatcher &&
 				((IntroductionAwareMethodMatcher) mm).matches(method, targetClass, hasIntroductions)) ||
@@ -102,8 +101,9 @@ public abstract class MethodMatchers {
 	@SuppressWarnings("serial")
 	private static class UnionMethodMatcher implements IntroductionAwareMethodMatcher, Serializable {

-		private MethodMatcher mm1;
-		private MethodMatcher mm2;
+		private final MethodMatcher mm1;
+
+		private final MethodMatcher mm2;

 		public UnionMethodMatcher(MethodMatcher mm1, MethodMatcher mm2) {
 			Assert.notNull(mm1, "First MethodMatcher must not be null");
@@ -112,21 +112,21 @@ public abstract class MethodMatchers {
 			this.mm2 = mm2;
 		}

-		public boolean matches(Method method, Class targetClass, boolean hasIntroductions) {
+		public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
 			return (matchesClass1(targetClass) && MethodMatchers.matches(this.mm1, method, targetClass, hasIntroductions)) ||
 					(matchesClass2(targetClass) && MethodMatchers.matches(this.mm2, method, targetClass, hasIntroductions));
 		}

-		public boolean matches(Method method, Class targetClass) {
+		public boolean matches(Method method, Class<?> targetClass) {
 			return (matchesClass1(targetClass) && this.mm1.matches(method, targetClass)) ||
 					(matchesClass2(targetClass) && this.mm2.matches(method, targetClass));
 		}

-		protected boolean matchesClass1(Class targetClass) {
+		protected boolean matchesClass1(Class<?> targetClass) {
 			return true;
 		}

-		protected boolean matchesClass2(Class targetClass) {
+		protected boolean matchesClass2(Class<?> targetClass) {
 			return true;
 		}

@@ -134,7 +134,7 @@ public abstract class MethodMatchers {
 			return this.mm1.isRuntime() || this.mm2.isRuntime();
 		}

-		public boolean matches(Method method, Class targetClass, Object[] args) {
+		public boolean matches(Method method, Class<?> targetClass, Object[] args) {
 			return this.mm1.matches(method, targetClass, args) || this.mm2.matches(method, targetClass, args);
 		}

@@ -168,6 +168,7 @@ public abstract class MethodMatchers {
 	private static class ClassFilterAwareUnionMethodMatcher extends UnionMethodMatcher {

 		private final ClassFilter cf1;
+
 		private final ClassFilter cf2;

 		public ClassFilterAwareUnionMethodMatcher(MethodMatcher mm1, ClassFilter cf1, MethodMatcher mm2, ClassFilter cf2) {
@@ -177,12 +178,12 @@ public abstract class MethodMatchers {
 		}

 		@Override
-		protected boolean matchesClass1(Class targetClass) {
+		protected boolean matchesClass1(Class<?> targetClass) {
 			return this.cf1.matches(targetClass);
 		}

 		@Override
-		protected boolean matchesClass2(Class targetClass) {
+		protected boolean matchesClass2(Class<?> targetClass) {
 			return this.cf2.matches(targetClass);
 		}

@@ -191,11 +192,17 @@ public abstract class MethodMatchers {
 			if (this == other) {
 				return true;
 			}
-			if (!(other instanceof ClassFilterAwareUnionMethodMatcher)) {
+			if (!super.equals(other)) {
 				return false;
 			}
-			ClassFilterAwareUnionMethodMatcher that = (ClassFilterAwareUnionMethodMatcher) other;
-			return (this.cf1.equals(that.cf1) && this.cf2.equals(that.cf2) && super.equals(other));
+			ClassFilter otherCf1 = ClassFilter.TRUE;
+			ClassFilter otherCf2 = ClassFilter.TRUE;
+			if (other instanceof ClassFilterAwareUnionMethodMatcher) {
+				ClassFilterAwareUnionMethodMatcher cfa = (ClassFilterAwareUnionMethodMatcher) other;
+				otherCf1 = cfa.cf1;
+				otherCf2 = cfa.cf2;
+			}
+			return (this.cf1.equals(otherCf1) && this.cf2.equals(otherCf2));
 		}
 	}

@@ -206,8 +213,9 @@ public abstract class MethodMatchers {
 	@SuppressWarnings("serial")
 	private static class IntersectionMethodMatcher implements IntroductionAwareMethodMatcher, Serializable {

-		private MethodMatcher mm1;
-		private MethodMatcher mm2;
+		private final MethodMatcher mm1;
+
+		private final MethodMatcher mm2;

 		public IntersectionMethodMatcher(MethodMatcher mm1, MethodMatcher mm2) {
 			Assert.notNull(mm1, "First MethodMatcher must not be null");
@@ -216,12 +224,12 @@ public abstract class MethodMatchers {
 			this.mm2 = mm2;
 		}

-		public boolean matches(Method method, Class targetClass, boolean hasIntroductions) {
+		public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
 			return MethodMatchers.matches(this.mm1, method, targetClass, hasIntroductions) &&
 					MethodMatchers.matches(this.mm2, method, targetClass, hasIntroductions);
 		}

-		public boolean matches(Method method, Class targetClass) {
+		public boolean matches(Method method, Class<?> targetClass) {
 			return this.mm1.matches(method, targetClass) && this.mm2.matches(method, targetClass);
 		}

@@ -229,7 +237,7 @@ public abstract class MethodMatchers {
 			return this.mm1.isRuntime() || this.mm2.isRuntime();
 		}

-		public boolean matches(Method method, Class targetClass, Object[] args) {
+		public boolean matches(Method method, Class<?> targetClass, Object[] args) {
 			// Because a dynamic intersection may be composed of a static and dynamic part,
 			// we must avoid calling the 3-arg matches method on a dynamic matcher, as
 			// it will probably be an unsupported operation.
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -47,7 +47,7 @@ public class NameMatchMethodPointcut extends StaticMethodMatcherPointcut impleme
 	 * @see #setMappedNames
 	 */
 	public void setMappedName(String mappedName) {
-		setMappedNames(new String[] {mappedName});
+		setMappedNames(mappedName);
 	}

 	/**
@@ -55,7 +55,7 @@ public class NameMatchMethodPointcut extends StaticMethodMatcherPointcut impleme
 	 * Matching will be the union of all these; if any match,
 	 * the pointcut matches.
 	 */
-	public void setMappedNames(String[] mappedNames) {
+	public void setMappedNames(String... mappedNames) {
 		this.mappedNames = new LinkedList<String>();
 		if (mappedNames != null) {
 			this.mappedNames.addAll(Arrays.asList(mappedNames));
@@ -77,7 +77,8 @@ public class NameMatchMethodPointcut extends StaticMethodMatcherPointcut impleme
 	}


-	public boolean matches(Method method, Class targetClass) {
+	@Override
+	public boolean matches(Method method, Class<?> targetClass) {
 		for (String mappedName : this.mappedNames) {
 			if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {
 				return true;
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -68,7 +68,7 @@ public class NameMatchMethodPointcutAdvisor extends AbstractGenericPointcutAdvis
 	 * the pointcut matches.
 	 * @see NameMatchMethodPointcut#setMappedNames
 	 */
-	public void setMappedNames(String[] mappedNames) {
+	public void setMappedNames(String... mappedNames) {
 		this.pointcut.setMappedNames(mappedNames);
 	}

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -98,7 +98,7 @@ public class RegexpMethodPointcutAdvisor extends AbstractGenericPointcutAdvisor
 	 * @see #setPatterns
 	 */
 	public void setPattern(String pattern) {
-		setPatterns(new String[] {pattern});
+		setPatterns(pattern);
 	}

 	/**
@@ -108,7 +108,7 @@ public class RegexpMethodPointcutAdvisor extends AbstractGenericPointcutAdvisor
 	 * patterns matches, the pointcut matches.
 	 * @see AbstractRegexpMethodPointcut#setPatterns
 	 */
-	public void setPatterns(String[] patterns) {
+	public void setPatterns(String... patterns) {
 		this.patterns = patterns;
 	}

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -59,10 +59,32 @@ public class AnnotationClassFilter implements ClassFilter {
 	}


-	public boolean matches(Class clazz) {
+	public boolean matches(Class<?> clazz) {
 		return (this.checkInherited ?
 				(AnnotationUtils.findAnnotation(clazz, this.annotationType) != null) :
 				clazz.isAnnotationPresent(this.annotationType));
 	}

+	@Override
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AnnotationClassFilter)) {
+			return false;
+		}
+		AnnotationClassFilter otherCf = (AnnotationClassFilter) other;
+		return (this.annotationType.equals(otherCf.annotationType) && this.checkInherited == otherCf.checkInherited);
+	}
+
+	@Override
+	public int hashCode() {
+		return this.annotationType.hashCode();
+	}
+
+	@Override
+	public String toString() {
+		return getClass().getName() + ": " + this.annotationType;
+	}
+
 }
@@ -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.
@@ -22,6 +22,7 @@ import org.springframework.aop.ClassFilter;
 import org.springframework.aop.MethodMatcher;
 import org.springframework.aop.Pointcut;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;

 /**
 * Simple Pointcut that looks for a specific Java 5 annotation
@@ -98,6 +99,36 @@ public class AnnotationMatchingPointcut implements Pointcut {
 		return this.methodMatcher;
 	}

+	@Override
+	public boolean equals(Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AnnotationMatchingPointcut)) {
+			return false;
+		}
+		AnnotationMatchingPointcut that = (AnnotationMatchingPointcut) other;
+		return ObjectUtils.nullSafeEquals(that.classFilter, this.classFilter) &&
+				ObjectUtils.nullSafeEquals(that.methodMatcher, this.methodMatcher);
+	}
+
+	@Override
+	public int hashCode() {
+		int code = 17;
+		if (this.classFilter != null) {
+			code = 37 * code + this.classFilter.hashCode();
+		}
+		if (this.methodMatcher != null) {
+			code = 37 * code + this.methodMatcher.hashCode();
+		}
+		return code;
+	}
+
+	@Override
+	public String toString() {
+		return "AnnotationMatchingPointcut: " + this.classFilter + ", " +this.methodMatcher;
+	}
+

 	/**
 	 * Factory method for an AnnotationMatchingPointcut that matches
@@ -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.
@@ -73,4 +73,9 @@ public class AnnotationMethodMatcher extends StaticMethodMatcher {
 		return this.annotationType.hashCode();
 	}

+	@Override
+	public String toString() {
+		return getClass().getName() + ": " + this.annotationType;
+	}
+
 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -24,7 +24,6 @@ import org.apache.commons.logging.LogFactory;
 import org.springframework.aop.TargetSource;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
-import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;

 /**
@@ -48,8 +47,7 @@ import org.springframework.util.ObjectUtils;
 * @see ThreadLocalTargetSource
 * @see CommonsPoolTargetSource
 */
-public abstract class AbstractBeanFactoryBasedTargetSource
-		implements TargetSource, BeanFactoryAware, Serializable {
+public abstract class AbstractBeanFactoryBasedTargetSource implements TargetSource, BeanFactoryAware, Serializable {

 	/** use serialVersionUID from Spring 1.2.7 for interoperability */
 	private static final long serialVersionUID = -4721607536018568393L;
@@ -97,7 +95,7 @@ public abstract class AbstractBeanFactoryBasedTargetSource
 	 * <p>Default is to detect the type automatically, through a {@code getType}
 	 * call on the BeanFactory (or even a full {@code getBean} call as fallback).
 	 */
-	public void setTargetClass(Class targetClass) {
+	public void setTargetClass(Class<?> targetClass) {
 		this.targetClass = targetClass;
 	}

@@ -107,7 +105,7 @@ public abstract class AbstractBeanFactoryBasedTargetSource
 	 */
 	public void setBeanFactory(BeanFactory beanFactory) {
 		if (this.targetBeanName == null) {
-			throw new IllegalStateException("Property'targetBeanName' is required");
+			throw new IllegalStateException("Property 'targetBeanName' is required");
 		}
 		this.beanFactory = beanFactory;
 	}
@@ -181,8 +179,7 @@ public abstract class AbstractBeanFactoryBasedTargetSource

 	@Override
 	public String toString() {
-		StringBuilder sb = new StringBuilder();
-		sb.append(ClassUtils.getShortName(getClass()));
+		StringBuilder sb = new StringBuilder(getClass().getSimpleName());
 		sb.append(" for target bean '").append(this.targetBeanName).append("'");
 		if (this.targetClass != null) {
 			sb.append(" of type [").append(this.targetClass.getName()).append("]");
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -50,6 +50,7 @@ import org.springframework.beans.factory.DisposableBean;
 * @see #releaseTarget
 * @see #destroy
 */
+@SuppressWarnings("serial")
 public abstract class AbstractPoolingTargetSource extends AbstractPrototypeBasedTargetSource
 		implements PoolingConfig, DisposableBean {

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -43,6 +43,7 @@ import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 * @see ThreadLocalTargetSource
 * @see CommonsPoolTargetSource
 */
+@SuppressWarnings("serial")
 public abstract class AbstractPrototypeBasedTargetSource extends AbstractBeanFactoryBasedTargetSource {

 	@Override
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -24,8 +24,8 @@ import org.springframework.beans.BeansException;
 import org.springframework.core.Constants;

 /**
- * TargetSource implementation that holds objects in a configurable
- * Jakarta Commons Pool.
+ * {@link org.springframework.aop.TargetSource} implementation that holds
+ * objects in a configurable Apache Commons Pool.
 *
 * <p>By default, an instance of {@code GenericObjectPool} is created.
 * Subclasses may change the type of {@code ObjectPool} used by
@@ -38,10 +38,12 @@ import org.springframework.core.Constants;
 * of configuration properties that are relevant to your chosen implementation.
 *
 * <p>The {@code testOnBorrow}, {@code testOnReturn} and {@code testWhileIdle}
- * properties are explictly not mirrored because the implementation of
+ * properties are explicitly not mirrored because the implementation of
 * {@code PoolableObjectFactory} used by this class does not implement
- * meaningful validation. All exposed Commons Pool properties use the corresponding
- * Commons Pool defaults: for example,
+ * meaningful validation. All exposed Commons Pool properties use the
+ * corresponding Commons Pool defaults.
+ *
+ * <p>Compatible with Apache Commons Pool 1.5.x and 1.6.
 *
 * @author Rod Johnson
 * @author Rob Harrop
@@ -55,10 +57,8 @@ import org.springframework.core.Constants;
 * @see #setTimeBetweenEvictionRunsMillis
 * @see #setMinEvictableIdleTimeMillis
 */
-public class CommonsPoolTargetSource extends AbstractPoolingTargetSource
-		implements PoolableObjectFactory {
-
-	private static final long serialVersionUID = 1L;
+@SuppressWarnings("serial")
+public class CommonsPoolTargetSource extends AbstractPoolingTargetSource implements PoolableObjectFactory {

 	private static final Constants constants = new Constants(GenericObjectPool.class);

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -19,9 +19,11 @@ package org.springframework.aop.target;
 import org.springframework.beans.BeansException;

 /**
- * TargetSource that creates a new instance of the target bean for each
- * request, destroying each instance on release (after each request).
- * Obtains bean instances from its containing
+ * {@link org.springframework.aop.TargetSource} implementation that
+ * creates a new instance of the target bean for each request,
+ * destroying each instance on release (after each request).
+ *
+ * <p>Obtains bean instances from its containing
 * {@link org.springframework.beans.factory.BeanFactory}.
 *
 * @author Rod Johnson
@@ -29,10 +31,9 @@ import org.springframework.beans.BeansException;
 * @see #setBeanFactory
 * @see #setTargetBeanName
 */
+@SuppressWarnings("serial")
 public class PrototypeTargetSource extends AbstractPrototypeBasedTargetSource {

-	private static final long serialVersionUID = 1L;
-
 	/**
 	 * Obtain a new prototype instance for every call.
 	 * @see #newPrototypeInstance()
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -27,9 +27,10 @@ import org.springframework.beans.factory.DisposableBean;
 import org.springframework.core.NamedThreadLocal;

 /**
- * Alternative to an object pool. This TargetSource uses a threading model in which
- * every thread has its own copy of the target. There's no contention for targets.
- * Target object creation is kept to a minimum on the running server.
+ * Alternative to an object pool. This {@link org.springframework.aop.TargetSource}
+ * uses a threading model in which every thread has its own copy of the target.
+ * There's no contention for targets. Target object creation is kept to a minimum
+ * on the running server.
 *
 * <p>Application code is written as to a normal pool; callers can't assume they
 * will be dealing with the same instance in invocations in different threads.
@@ -47,11 +48,10 @@ import org.springframework.core.NamedThreadLocal;
 * @see ThreadLocalTargetSourceStats
 * @see org.springframework.beans.factory.DisposableBean#destroy()
 */
+@SuppressWarnings("serial")
 public class ThreadLocalTargetSource extends AbstractPrototypeBasedTargetSource
 		implements ThreadLocalTargetSourceStats, DisposableBean {

-	private static final long serialVersionUID = 1L;
-
 	/**
 	 * ThreadLocal holding the target associated with the current
 	 * thread. Unlike most ThreadLocals, which are static, this variable
@@ -80,10 +80,8 @@ public class ThreadLocalTargetSource extends AbstractPrototypeBasedTargetSource
 		Object target = this.targetInThread.get();
 		if (target == null) {
 			if (logger.isDebugEnabled()) {
-				logger.debug("No target for prototype '" + getTargetBeanName() +
-						"' bound to thread: " +
-						"creating one and binding it to thread '" +
-						Thread.currentThread().getName() + "'");
+				logger.debug("No target for prototype '" + getTargetBeanName() + "' bound to thread: " +
+						"creating one and binding it to thread '" + Thread.currentThread().getName() + "'");
 			}
 			// Associate target with ThreadLocal.
 			target = newPrototypeInstance();
@@ -43,6 +43,7 @@ public final class MethodMatchersTests {

 	private final Method IOTHER_ABSQUATULATE;

+
 	public MethodMatchersTests() throws Exception {
 		EXCEPTION_GETMESSAGE = Exception.class.getMethod("getMessage", (Class[]) null);
 		ITESTBEAN_GETAGE = ITestBean.class.getMethod("getAge", (Class[]) null);
@@ -50,6 +51,7 @@ public final class MethodMatchersTests {
 		IOTHER_ABSQUATULATE = IOther.class.getMethod("absquatulate", (Class[]) null);
 	}

+
 	@Test
 	public void testDefaultMatchesAll() throws Exception {
 		MethodMatcher defaultMm = MethodMatcher.TRUE;
@@ -99,23 +101,33 @@ public final class MethodMatchersTests {
 		assertTrue("Matched setAge method", union.matches(ITESTBEAN_SETAGE, TestBean.class));
 		assertTrue("Matched getAge method", union.matches(ITESTBEAN_GETAGE, TestBean.class));
 		assertFalse("Didn't matched absquatulate method", union.matches(IOTHER_ABSQUATULATE, TestBean.class));
+	}

+	@Test
+	public void testUnionEquals() {
+		MethodMatcher first = MethodMatchers.union(MethodMatcher.TRUE, MethodMatcher.TRUE);
+		MethodMatcher second = new ComposablePointcut(MethodMatcher.TRUE).union(new ComposablePointcut(MethodMatcher.TRUE)).getMethodMatcher();
+		assertTrue(first.equals(second));
+		assertTrue(second.equals(first));
 	}


 	public static class StartsWithMatcher extends StaticMethodMatcher {
-		private String prefix;
+
+		private final String prefix;
+
 		public StartsWithMatcher(String s) {
 			this.prefix = s;
 		}
+
 		@Override
 		public boolean matches(Method m, Class<?> targetClass) {
 			return m.getName().startsWith(prefix);
 		}
 	}

-
 	private static class TestDynamicMethodMatcherWhichMatches extends DynamicMethodMatcher {
+
 		@Override
 		public boolean matches(Method m, Class<?> targetClass, Object[] args) {
 			return true;
@@ -123,6 +135,7 @@ public final class MethodMatchersTests {
 	}

 	private static class TestDynamicMethodMatcherWhichDoesNotMatch extends DynamicMethodMatcher {
+
 		@Override
 		public boolean matches(Method m, Class<?> targetClass, Object[] args) {
 			return false;
@@ -12,8 +12,8 @@ configurations {
 tasks.getByName("idea").onlyIf { false }
 tasks.getByName("ideaModule").onlyIf { false }

-task compileJava(overwrite: true)  {
-	dependsOn JavaPlugin.PROCESS_RESOURCES_TASK_NAME
+compileJava  {
+	actions = []
 	dependsOn configurations.ajc.getTaskDependencyFromProjectDependency(true, "compileJava")

 	def outputDir = project.sourceSets.main.output.classesDir
@@ -44,8 +44,8 @@ task compileJava(overwrite: true)  {
 	}
 }

-task compileTestJava(overwrite: true)  {
-	dependsOn JavaPlugin.PROCESS_TEST_RESOURCES_TASK_NAME
+compileTestJava  {
+	actions = []
 	dependsOn configurations.ajc.getTaskDependencyFromProjectDependency(true, "compileTestJava")
 	dependsOn jar

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -27,26 +27,18 @@ import org.aspectj.lang.annotation.control.CodeGenerationHint;
 * @since 2.5.2
 */
 public abstract aspect AbstractDependencyInjectionAspect {
-	/**
-	 * Select construction join points for objects to inject dependencies
-	 */
-	public abstract pointcut beanConstruction(Object bean);
+
+	private pointcut preConstructionCondition() :
+			leastSpecificSuperTypeConstruction() && preConstructionConfiguration();
+
+	private pointcut postConstructionCondition() :
+			mostSpecificSubTypeConstruction() && !preConstructionConfiguration();

 	/**
-	 * Select deserialization join points for objects to inject dependencies
+	 * Select least specific super type that is marked for DI
+	 * (so that injection occurs only once with pre-construction injection).
 	 */
-	public abstract pointcut beanDeserialization(Object bean);
-
-	/**
-	 * Select join points in a configurable bean
-	 */
-	public abstract pointcut inConfigurableBean();
-
-	/**
-	 * Select join points in beans to be configured prior to construction?
-	 * By default, use post-construction injection matching the default in the Configurable annotation.
-	 */
-	public pointcut preConstructionConfiguration() : if(false);
+	public abstract pointcut leastSpecificSuperTypeConstruction();

 	/**
 	 * Select the most-specific initialization join point
@@ -54,31 +46,36 @@ public abstract aspect AbstractDependencyInjectionAspect {
 	 */
 	@CodeGenerationHint(ifNameSuffix="6f1")
 	public pointcut mostSpecificSubTypeConstruction() :
-		if(thisJoinPoint.getSignature().getDeclaringType() == thisJoinPoint.getThis().getClass());
+			if (thisJoinPoint.getSignature().getDeclaringType() == thisJoinPoint.getThis().getClass());

 	/**
-	 * Select least specific super type that is marked for DI (so that injection occurs only once with pre-construction inejection
+	 * Select join points in beans to be configured prior to construction?
+	 * By default, use post-construction injection matching the default in the Configurable annotation.
 	 */
-	public abstract pointcut leastSpecificSuperTypeConstruction();
+	public pointcut preConstructionConfiguration() : if (false);

 	/**
-	 * Configure the bean
+	 * Select construction join points for objects to inject dependencies.
 	 */
-	public abstract void configureBean(Object bean);
+	public abstract pointcut beanConstruction(Object bean);

+	/**
+	 * Select deserialization join points for objects to inject dependencies.
+	 */
+	public abstract pointcut beanDeserialization(Object bean);

-	private pointcut preConstructionCondition() :
-		leastSpecificSuperTypeConstruction() && preConstructionConfiguration();
+	/**
+	 * Select join points in a configurable bean.
+	 */
+	public abstract pointcut inConfigurableBean();

-	private pointcut postConstructionCondition() :
-		mostSpecificSubTypeConstruction() && !preConstructionConfiguration();

 	/**
 	 * Pre-construction configuration.
 	 */
 	@SuppressAjWarnings("adviceDidNotMatch")
 	before(Object bean) :
-		beanConstruction(bean) && preConstructionCondition() && inConfigurableBean()  {
+			beanConstruction(bean) && preConstructionCondition() && inConfigurableBean()  {
 		configureBean(bean);
 	}

@@ -87,7 +84,7 @@ public abstract aspect AbstractDependencyInjectionAspect {
 	 */
 	@SuppressAjWarnings("adviceDidNotMatch")
 	after(Object bean) returning :
-		beanConstruction(bean) && postConstructionCondition() && inConfigurableBean() {
+			beanConstruction(bean) && postConstructionCondition() && inConfigurableBean() {
 		configureBean(bean);
 	}

@@ -96,8 +93,14 @@ public abstract aspect AbstractDependencyInjectionAspect {
 	 */
 	@SuppressAjWarnings("adviceDidNotMatch")
 	after(Object bean) returning :
-		beanDeserialization(bean) && inConfigurableBean() {
+			beanDeserialization(bean) && inConfigurableBean() {
 		configureBean(bean);
 	}

+
+	/**
+	 * Configure the given bean.
+	 */
+	public abstract void configureBean(Object bean);
+
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -20,49 +20,48 @@ import java.io.ObjectStreamException;
 import java.io.Serializable;

 /**
- * An aspect that injects dependency into any object whose type implements the {@link ConfigurableObject} interface.
- * <p>
- * This aspect supports injecting into domain objects when they are created for the first time as well as
- * upon deserialization. Subaspects need to simply provide definition for the configureBean() method. This
- * method may be implemented without relying on Spring container if so desired.
- * </p>
- * <p>
- * There are two cases that needs to be handled:
+ * An aspect that injects dependency into any object whose type implements the
+ * {@link ConfigurableObject} interface.
+ *
+ * <p>This aspect supports injecting into domain objects when they are created
+ * for the first time as well as upon deserialization. Subaspects need to simply
+ * provide definition for the configureBean() method. This method may be
+ * implemented without relying on Spring container if so desired.
+ *
+ * <p>There are two cases that needs to be handled:
 * <ol>
- *   <li>Normal object creation via the '{@code new}' operator: this is
- *       taken care of by advising {@code initialization()} join points.</li>
- *   <li>Object creation through deserialization: since no constructor is
- *       invoked during deserialization, the aspect needs to advise a method that a
- *       deserialization mechanism is going to invoke. Ideally, we should not
- *       require user classes to implement any specific method. This implies that
- *       we need to <i>introduce</i> the chosen method. We should also handle the cases
- *       where the chosen method is already implemented in classes (in which case,
- *       the user's implementation for that method should take precedence over the
- *       introduced implementation). There are a few choices for the chosen method:
- *       <ul>
- *       <li>readObject(ObjectOutputStream): Java requires that the method must be
- *           {@code private}</p>. Since aspects cannot introduce a private member,
- *           while preserving its name, this option is ruled out.</li>
- * 		 <li>readResolve(): Java doesn't pose any restriction on an access specifier.
- *           Problem solved! There is one (minor) limitation of this approach in
- *           that if a user class already has this method, that method must be
- *           {@code public}. However, this shouldn't be a big burden, since
- *           use cases that need classes to implement readResolve() (custom enums,
- *           for example) are unlikely to be marked as &#64;Configurable, and
- *           in any case asking to make that method {@code public} should not
- *           pose any undue burden.</li>
- *       </ul>
- *       The minor collaboration needed by user classes (i.e., that the
- *       implementation of {@code readResolve()}, if any, must be
- *       {@code public}) can be lifted as well if we were to use an
- *       experimental feature in AspectJ - the {@code hasmethod()} PCD.</li>
+ * <li>Normal object creation via the '{@code new}' operator: this is
+ * taken care of by advising {@code initialization()} join points.</li>
+ * <li>Object creation through deserialization: since no constructor is
+ * invoked during deserialization, the aspect needs to advise a method that a
+ * deserialization mechanism is going to invoke. Ideally, we should not
+ * require user classes to implement any specific method. This implies that
+ * we need to <i>introduce</i> the chosen method. We should also handle the cases
+ * where the chosen method is already implemented in classes (in which case,
+ * the user's implementation for that method should take precedence over the
+ * introduced implementation). There are a few choices for the chosen method:
+ * <ul>
+ * <li>readObject(ObjectOutputStream): Java requires that the method must be
+ * {@code private}</p>. Since aspects cannot introduce a private member,
+ * while preserving its name, this option is ruled out.</li>
+ * <li>readResolve(): Java doesn't pose any restriction on an access specifier.
+ * Problem solved! There is one (minor) limitation of this approach in
+ * that if a user class already has this method, that method must be
+ * {@code public}. However, this shouldn't be a big burden, since
+ * use cases that need classes to implement readResolve() (custom enums,
+ * for example) are unlikely to be marked as &#64;Configurable, and
+ * in any case asking to make that method {@code public} should not
+ * pose any undue burden.</li>
+ * </ul>
+ * The minor collaboration needed by user classes (i.e., that the implementation of
+ * {@code readResolve()}, if any, must be {@code public}) can be lifted as well if we
+ * were to use an experimental feature in AspectJ - the {@code hasmethod()} PCD.</li>
 * </ol>
-
- * <p>
- * While having type implement the {@link ConfigurableObject} interface is certainly a valid choice, an alternative
- * is to use a 'declare parents' statement another aspect (a subaspect of this aspect would be a logical choice)
- * that declares the classes that need to be configured by supplying the {@link ConfigurableObject} interface.
- * </p>
+ *
+ * <p>While having type implement the {@link ConfigurableObject} interface is certainly
+ * a valid choice, an alternative is to use a 'declare parents' statement another aspect
+ * (a subaspect of this aspect would be a logical choice) that declares the classes that
+ * need to be configured by supplying the {@link ConfigurableObject} interface.
 *
 * @author Ramnivas Laddad
 * @since 2.5.2
@@ -72,35 +71,33 @@ public abstract aspect AbstractInterfaceDrivenDependencyInjectionAspect extends
 	 * Select initialization join point as object construction
 	 */
 	public pointcut beanConstruction(Object bean) :
-		initialization(ConfigurableObject+.new(..)) && this(bean);
+			initialization(ConfigurableObject+.new(..)) && this(bean);

 	/**
 	 * Select deserialization join point made available through ITDs for ConfigurableDeserializationSupport
 	 */
 	public pointcut beanDeserialization(Object bean) :
-		execution(Object ConfigurableDeserializationSupport+.readResolve()) &&
-		this(bean);
+			execution(Object ConfigurableDeserializationSupport+.readResolve()) && this(bean);

 	public pointcut leastSpecificSuperTypeConstruction() : initialization(ConfigurableObject.new(..));



 	// Implementation to support re-injecting dependencies once an object is deserialized
+
 	/**
 	 * Declare any class implementing Serializable and ConfigurableObject as also implementing
-	 * ConfigurableDeserializationSupport. This allows us to introduce the readResolve()
+	 * ConfigurableDeserializationSupport. This allows us to introduce the {@code readResolve()}
 	 * method and select it with the beanDeserialization() pointcut.
-	 *
 	 * <p>Here is an improved version that uses the hasmethod() pointcut and lifts
 	 * even the minor requirement on user classes:
-	 *
-	 * <pre class="code">declare parents: ConfigurableObject+ Serializable+
-	 *		            && !hasmethod(Object readResolve() throws ObjectStreamException)
-	 *		            implements ConfigurableDeserializationSupport;
+	 * <pre class="code">
+	 * declare parents: ConfigurableObject+ Serializable+
+	 * && !hasmethod(Object readResolve() throws ObjectStreamException)
+	 * implements ConfigurableDeserializationSupport;
 	 * </pre>
 	 */
-	declare parents:
-		ConfigurableObject+ && Serializable+	implements ConfigurableDeserializationSupport;
+	declare parents: ConfigurableObject+ && Serializable+ implements ConfigurableDeserializationSupport;

 	/**
 	 * A marker interface to which the {@code readResolve()} is introduced.
@@ -111,7 +108,6 @@ public abstract aspect AbstractInterfaceDrivenDependencyInjectionAspect extends
 	/**
 	 * Introduce the {@code readResolve()} method so that we can advise its
 	 * execution to configure the object.
-	 *
 	 * <p>Note if a method with the same signature already exists in a
 	 * {@code Serializable} class of ConfigurableObject type,
 	 * that implementation will take precedence (a good thing, since we are
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -19,7 +19,7 @@ package org.springframework.beans.factory.aspectj;
 import java.io.Serializable;

 import org.aspectj.lang.annotation.control.CodeGenerationHint;
-import org.springframework.beans.BeansException;
+
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.DisposableBean;
@@ -44,48 +44,47 @@ import org.springframework.beans.factory.wiring.BeanConfigurerSupport;
 * @see org.springframework.beans.factory.annotation.Configurable
 * @see org.springframework.beans.factory.annotation.AnnotationBeanWiringInfoResolver
 */
-public aspect AnnotationBeanConfigurerAspect
-		extends AbstractInterfaceDrivenDependencyInjectionAspect
+public aspect AnnotationBeanConfigurerAspect extends AbstractInterfaceDrivenDependencyInjectionAspect
 		implements BeanFactoryAware, InitializingBean, DisposableBean {

 	private BeanConfigurerSupport beanConfigurerSupport = new BeanConfigurerSupport();

+
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanConfigurerSupport.setBeanFactory(beanFactory);
+		this.beanConfigurerSupport.setBeanWiringInfoResolver(new AnnotationBeanWiringInfoResolver());
+	}
+
+	public void afterPropertiesSet() throws Exception {
+		this.beanConfigurerSupport.afterPropertiesSet();
+	}
+
+	public void configureBean(Object bean) {
+		this.beanConfigurerSupport.configureBean(bean);
+	}
+
+	public void destroy() throws Exception {
+		this.beanConfigurerSupport.destroy();
+	}
+
+
 	public pointcut inConfigurableBean() : @this(Configurable);

 	public pointcut preConstructionConfiguration() : preConstructionConfigurationSupport(*);

-	declare parents: @Configurable * implements ConfigurableObject;
-
-	public void configureBean(Object bean) {
-		beanConfigurerSupport.configureBean(bean);
-	}
-
-
-	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
-		beanConfigurerSupport.setBeanFactory(beanFactory);
-		beanConfigurerSupport.setBeanWiringInfoResolver(new AnnotationBeanWiringInfoResolver());
-	}
-
-	public void afterPropertiesSet() throws Exception {
-		beanConfigurerSupport.afterPropertiesSet();
-	}
-
-	public void destroy() throws Exception {
-		beanConfigurerSupport.destroy();
-	}
-
-
 	/*
 	 * An intermediary to match preConstructionConfiguration signature (that doesn't expose the annotation object)
 	 */
 	@CodeGenerationHint(ifNameSuffix="bb0")
-	private pointcut preConstructionConfigurationSupport(Configurable c) : @this(c) && if(c.preConstruction());
+	private pointcut preConstructionConfigurationSupport(Configurable c) : @this(c) && if (c.preConstruction());
+
+
+	declare parents: @Configurable * implements ConfigurableObject;

 	/*
 	 * This declaration shouldn't be needed,
 	 * except for an AspectJ bug (https://bugs.eclipse.org/bugs/show_bug.cgi?id=214559)
 	 */
-	declare parents: @Configurable Serializable+
-		implements ConfigurableDeserializationSupport;
+	declare parents: @Configurable Serializable+ implements ConfigurableDeserializationSupport;

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -35,7 +35,7 @@ import org.springframework.context.annotation.Role;
@Configuration
 public class AspectJCachingConfiguration extends AbstractCachingConfiguration {

-	@Bean(name=AnnotationConfigUtils.CACHE_ASPECT_BEAN_NAME)
+	@Bean(name = AnnotationConfigUtils.CACHE_ASPECT_BEAN_NAME)
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	public AnnotationCacheAspect cacheAspect() {
 		AnnotationCacheAspect cacheAspect = AnnotationCacheAspect.aspectOf();
@@ -47,4 +47,5 @@ public class AspectJCachingConfiguration extends AbstractCachingConfiguration {
 		}
 		return cacheAspect;
 	}
+
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -28,9 +28,9 @@ import org.springframework.context.annotation.Role;
 * annotated with @{@link org.springframework.beans.factory.annotation.Configurable
 * Configurable}.
 *
- * <p>This configuration class is automatically imported when using the @{@link
- * EnableSpringConfigured} annotation. See {@code @EnableSpringConfigured} Javadoc for
- * complete usage details.
+ * <p>This configuration class is automatically imported when using the
+ * @{@link EnableSpringConfigured} annotation. See {@code @EnableSpringConfigured}'s
+ * javadoc for complete usage details.
 *
 * @author Chris Beams
 * @since 3.1
@@ -42,9 +42,10 @@ public class SpringConfiguredConfiguration {
 	public static final String BEAN_CONFIGURER_ASPECT_BEAN_NAME =
 			"org.springframework.context.config.internalBeanConfigurerAspect";

-	@Bean(name=BEAN_CONFIGURER_ASPECT_BEAN_NAME)
+	@Bean(name = BEAN_CONFIGURER_ASPECT_BEAN_NAME)
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	public AnnotationBeanConfigurerAspect beanConfigurerAspect() {
 		return AnnotationBeanConfigurerAspect.aspectOf();
 	}
+
 }
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -18,16 +18,22 @@ package org.springframework.mock.staticmock;

 import java.util.Arrays;
 import java.util.LinkedList;
-import java.util.List;
+
+import org.springframework.util.ObjectUtils;

 /**
 * Abstract aspect to enable mocking of methods picked out by a pointcut.
- * Sub-aspects must define the mockStaticsTestMethod() pointcut to
- * indicate call stacks when mocking should be triggered, and the
- * methodToMock() pointcut to pick out a method invocations to mock.
+ *
+ * <p>Sub-aspects must define:
+ * <ul>
+ * <li>the {@link #mockStaticsTestMethod()} pointcut to indicate call stacks
+ * when mocking should be triggered
+ * <li>the {@link #methodToMock()} pointcut to pick out method invocations to mock
+ * </ul>
 *
 * @author Rod Johnson
 * @author Ramnivas Laddad
+ * @author Sam Brannen
 */
 public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMethod()) {

@@ -35,24 +41,34 @@ public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMeth

 	protected abstract pointcut methodToMock();

+
 	private boolean recording = true;

-	static enum CallResponse { nothing, return_, throw_ };

-	// Represents a list of expected calls to static entity methods
+	static enum CallResponse {
+		nothing, return_, throw_
+	};
+
+	/**
+	 * Represents a list of expected calls to methods.
+	 */
 	// Public to allow inserted code to access: is this normal??
 	public class Expectations {

-		// Represents an expected call to a static entity method
+		/**
+		 * Represents an expected call to a method.
+		 */
 		private class Call {
+
 			private final String signature;
 			private final Object[] args;

 			private Object responseObject; // return value or throwable
 			private CallResponse responseType = CallResponse.nothing;

-			public Call(String name, Object[] args) {
-				this.signature = name;
+
+			public Call(String signature, Object[] args) {
+				this.signature = signature;
 				this.args = args;
 			}

@@ -77,7 +93,7 @@ public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMeth

 			public Object throwException(String lastSig, Object[] args) {
 				checkSignature(lastSig, args);
-				throw (RuntimeException)responseObject;
+				throw (RuntimeException) responseObject;
 			}

 			private void checkSignature(String lastSig, Object[] args) {
@@ -88,50 +104,62 @@ public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMeth
 					throw new IllegalArgumentException("Arguments don't match");
 				}
 			}
+
+			@Override
+			public String toString() {
+				return String.format("Call with signature [%s] and arguments %s", this.signature,
+					ObjectUtils.nullSafeToString(args));
+			}
 		}

-		private List<Call> calls = new LinkedList<Call>();

-		// Calls already verified
+		/**
+		 * The list of recorded calls.
+		 */
+		private final LinkedList<Call> calls = new LinkedList<Call>();
+
+		/**
+		 * The number of calls already verified.
+		 */
 		private int verified;

+
 		public void verify() {
 			if (verified != calls.size()) {
-				throw new IllegalStateException("Expected " + calls.size()
-						+ " calls, received " + verified);
+				throw new IllegalStateException("Expected " + calls.size() + " calls, but received " + verified);
 			}
 		}

 		/**
-		 * Validate the call and provide the expected return value
-		 * @param lastSig
-		 * @param args
-		 * @return
+		 * Validate the call and provide the expected return value.
 		 */
 		public Object respond(String lastSig, Object[] args) {
-			Call call = nextCall();
-			CallResponse responseType = call.responseType;
-			if (responseType == CallResponse.return_) {
-				return call.returnValue(lastSig, args);
-			} else if(responseType == CallResponse.throw_) {
-				return (RuntimeException)call.throwException(lastSig, args);
-			} else if(responseType == CallResponse.nothing) {
-				// do nothing
+			Call c = nextCall();
+
+			switch (c.responseType) {
+				case return_: {
+					return c.returnValue(lastSig, args);
+				}
+				case throw_: {
+					return c.throwException(lastSig, args);
+				}
+				default: {
+					throw new IllegalStateException("Behavior of " + c + " not specified");
+				}
 			}
-			throw new IllegalStateException("Behavior of " + call + " not specified");
 		}

 		private Call nextCall() {
-			if (verified > calls.size() - 1) {
-				throw new IllegalStateException("Expected " + calls.size()
-						+ " calls, received " + verified);
+			verified++;
+			if (verified > calls.size()) {
+				throw new IllegalStateException("Expected " + calls.size() + " calls, but received " + verified);
 			}
-			return calls.get(verified++);
+			// The 'verified' count is 1-based; whereas, 'calls' is 0-based.
+			return calls.get(verified - 1);
 		}

-		public void expectCall(String lastSig, Object lastArgs[]) {
-			Call call = new Call(lastSig, lastArgs);
-			calls.add(call);
+		public void expectCall(String lastSig, Object[] lastArgs) {
+			calls.add(new Call(lastSig, lastArgs));
 		}

 		public boolean hasCalls() {
@@ -139,29 +167,31 @@ public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMeth
 		}

 		public void expectReturn(Object retVal) {
-			Call call = calls.get(calls.size() - 1);
-			if (call.hasResponseSpecified()) {
-				throw new IllegalStateException("No static method invoked before setting return value");
+			Call c = calls.getLast();
+			if (c.hasResponseSpecified()) {
+				throw new IllegalStateException("No method invoked before setting return value");
 			}
-			call.setReturnVal(retVal);
+			c.setReturnVal(retVal);
 		}

 		public void expectThrow(Throwable throwable) {
-			Call call = calls.get(calls.size() - 1);
-			if (call.hasResponseSpecified()) {
-				throw new IllegalStateException("No static method invoked before setting throwable");
+			Call c = calls.getLast();
+			if (c.hasResponseSpecified()) {
+				throw new IllegalStateException("No method invoked before setting throwable");
 			}
-			call.setThrow(throwable);
+			c.setThrow(throwable);
 		}
 	}

-	private Expectations expectations = new Expectations();
+
+	private final Expectations expectations = new Expectations();
+

 	after() returning : mockStaticsTestMethod() {
 		if (recording && (expectations.hasCalls())) {
 			throw new IllegalStateException(
-					"Calls recorded, yet playback state never reached: Create expectations then call "
-							+ this.getClass().getSimpleName() + ".playback()");
+				"Calls recorded, yet playback state never reached: Create expectations then call "
+						+ this.getClass().getSimpleName() + ".playback()");
 		}
 		expectations.verify();
 	}
@@ -171,7 +201,8 @@ public abstract aspect AbstractMethodMockingControl percflow(mockStaticsTestMeth
 			expectations.expectCall(thisJoinPointStaticPart.toLongString(), thisJoinPoint.getArgs());
 			// Return value doesn't matter
 			return null;
-		} else {
+		}
+		else {
 			return expectations.respond(thisJoinPointStaticPart.toLongString(), thisJoinPoint.getArgs());
 		}
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -17,50 +17,69 @@
 package org.springframework.mock.staticmock;

 /**
- * Annotation-based aspect to use in test build to enable mocking static methods
- * on JPA-annotated {@code @Entity} classes, as used by Roo for finders.
+ * Annotation-based aspect to use in test builds to enable mocking of static methods
+ * on JPA-annotated {@code @Entity} classes, as used by Spring Roo for so-called
+ * <em>finder methods</em>.
 *
- * <p>Mocking will occur in the call stack of any method in a class (typically a test class)
- * that is annotated with the @MockStaticEntityMethods annotation.
+ * <p>Mocking will occur within the call stack of any method in a class (typically a
+ * test class) that is annotated with {@code @MockStaticEntityMethods}.
 *
- * <p>Also provides static methods to simplify the programming model for
- * entering playback mode and setting expected return values.
+ * <p>This aspect also provides static methods to simplify the programming model for
+ * setting expectations and entering playback mode.
 *
 * <p>Usage:
 * <ol>
- * <li>Annotate a test class with @MockStaticEntityMethods.
- * <li>In each test method, AnnotationDrivenStaticEntityMockingControl will begin in recording mode.
- * Invoke static methods on Entity classes, with each recording-mode invocation
- * being followed by an invocation to the static expectReturn() or expectThrow()
- * method on AnnotationDrivenStaticEntityMockingControl.
- * <li>Invoke the static AnnotationDrivenStaticEntityMockingControl() method.
- * <li>Call the code you wish to test that uses the static methods. Verification will
- * occur automatically.
+ * <li>Annotate a test class with {@code @MockStaticEntityMethods}.
+ * <li>In each test method, {@code AnnotationDrivenStaticEntityMockingControl}
+ * will begin in <em>recording</em> mode.
+ * <li>Invoke static methods on JPA-annotated {@code @Entity} classes, with each
+ * recording-mode invocation being followed by an invocation of either the static
+ * {@link #expectReturn(Object)} method or the static {@link #expectThrow(Throwable)}
+ * method on {@code AnnotationDrivenStaticEntityMockingControl}.
+ * <li>Invoke the static {@link #playback()} method.
+ * <li>Call the code you wish to test that uses the static methods.
+ * <li>Verification will occur automatically.
 * </ol>
 *
 * @author Rod Johnson
 * @author Ramnivas Laddad
+ * @author Sam Brannen
 * @see MockStaticEntityMethods
 */
 public aspect AnnotationDrivenStaticEntityMockingControl extends AbstractMethodMockingControl {

 	/**
-	 * Stop recording mock calls and enter playback state
+	 * Expect the supplied {@link Object} to be returned by the previous static
+	 * method invocation.
+	 * @see #playback()
 	 */
-	public static void playback() {
-		AnnotationDrivenStaticEntityMockingControl.aspectOf().playbackInternal();
-	}
-
 	public static void expectReturn(Object retVal) {
 		AnnotationDrivenStaticEntityMockingControl.aspectOf().expectReturnInternal(retVal);
 	}

+	/**
+	 * Expect the supplied {@link Throwable} to be thrown by the previous static
+	 * method invocation.
+	 * @see #playback()
+	 */
 	public static void expectThrow(Throwable throwable) {
 		AnnotationDrivenStaticEntityMockingControl.aspectOf().expectThrowInternal(throwable);
 	}

-	// Only matches directly annotated @Test methods, to allow methods in
-	// @MockStatics classes to invoke each other without resetting the mocking environment
+	/**
+	 * Stop recording mock expectations and enter <em>playback</em> mode.
+	 * @see #expectReturn(Object)
+	 * @see #expectThrow(Throwable)
+	 */
+	public static void playback() {
+		AnnotationDrivenStaticEntityMockingControl.aspectOf().playbackInternal();
+	}
+	
+	// Apparently, the following pointcut was originally defined to only match
+	// methods directly annotated with @Test (in order to allow methods in
+	// @MockStaticEntityMethods classes to invoke each other without resetting
+	// the mocking environment); however, this is no longer the case. The current
+	// pointcut applies to all public methods in @MockStaticEntityMethods classes.
 	protected pointcut mockStaticsTestMethod() : execution(public * (@MockStaticEntityMethods *).*(..));

 	protected pointcut methodToMock() : execution(public static * (@javax.persistence.Entity *).*(..));
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -22,11 +22,13 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;

 /**
- * Annotation to indicate a test class for whose @Test methods
- * static methods on Entity classes should be mocked. See
- * {@code AbstractMethodMockingControl}.
+ * Annotation to indicate a test class for whose {@code @Test} methods
+ * static methods on JPA-annotated {@code @Entity} classes should be mocked.
+ *
+ * <p>See {@link AnnotationDrivenStaticEntityMockingControl} for details.
 *
 * @author Rod Johnson
+ * @author Sam Brannen
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -32,12 +32,12 @@ import org.springframework.scheduling.annotation.EnableAsync;
 * @since 3.1
 * @see EnableAsync
 * @see org.springframework.scheduling.annotation.AsyncConfigurationSelector
+ * @see org.springframework.scheduling.annotation.ProxyAsyncConfiguration
 */
@Configuration
 public class AspectJAsyncConfiguration extends AbstractAsyncConfiguration {

-	@Override
-	@Bean(name=AnnotationConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME)
+	@Bean(name = AnnotationConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME)
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	public AnnotationAsyncExecutionAspect asyncAdvisor() {
 		AnnotationAsyncExecutionAspect asyncAspect = AnnotationAsyncExecutionAspect.aspectOf();
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -37,7 +37,7 @@ import org.springframework.transaction.config.TransactionManagementConfigUtils;
@Configuration
 public class AspectJTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {

-	@Bean(name=TransactionManagementConfigUtils.TRANSACTION_ASPECT_BEAN_NAME)
+	@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ASPECT_BEAN_NAME)
 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 	public AnnotationTransactionAspect transactionAspect() {
 		AnnotationTransactionAspect txAspect = AnnotationTransactionAspect.aspectOf();
@@ -46,4 +46,5 @@ public class AspectJTransactionManagementConfiguration extends AbstractTransacti
 		}
 		return txAspect;
 	}
+
 }
@@ -1,148 +0,0 @@
-/*
- * 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
- *
- * 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.mock.staticmock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.expectReturn;
-import static org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.expectThrow;
-import static org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.playback;
-
-import javax.persistence.PersistenceException;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-
-/**
- * Test for static entity mocking framework.
- * @author Rod Johnson
- * @author Ramnivas Laddad
- *
- */
-@MockStaticEntityMethods
-@RunWith(JUnit4.class)
-public class AnnotationDrivenStaticEntityMockingControlTest {
-
-	@Test
-	public void testNoArgIntReturn() {
-		int expectedCount = 13;
-		Person.countPeople();
-		expectReturn(expectedCount);
-		playback();
-		assertEquals(expectedCount, Person.countPeople());
-	}
-
-	@Test(expected=PersistenceException.class)
-	public void testNoArgThrows() {
-		Person.countPeople();
-		expectThrow(new PersistenceException());
-		playback();
-		Person.countPeople();
-	}
-
-	@Test
-	public void testArgMethodMatches() {
-		long id = 13;
-		Person found = new Person();
-		Person.findPerson(id);
-		expectReturn(found);
-		playback();
-		assertEquals(found, Person.findPerson(id));
-	}
-
-
-	@Test
-	public void testLongSeriesOfCalls() {
-		long id1 = 13;
-		long id2 = 24;
-		Person found1 = new Person();
-		Person.findPerson(id1);
-		expectReturn(found1);
-		Person found2 = new Person();
-		Person.findPerson(id2);
-		expectReturn(found2);
-		Person.findPerson(id1);
-		expectReturn(found1);
-		Person.countPeople();
-		expectReturn(0);
-		playback();
-
-		assertEquals(found1, Person.findPerson(id1));
-		assertEquals(found2, Person.findPerson(id2));
-		assertEquals(found1, Person.findPerson(id1));
-		assertEquals(0, Person.countPeople());
-	}
-
-	// Note delegation is used when tests are invalid and should fail, as otherwise
-	// the failure will occur on the verify() method in the aspect after
-	// this method returns, failing the test case
-	@Test
-	public void testArgMethodNoMatchExpectReturn() {
-		try {
-			new Delegate().testArgMethodNoMatchExpectReturn();
-			fail();
-		} catch (IllegalArgumentException expected) {
-		}
-	}
-
-	@Test(expected=IllegalArgumentException.class)
-	public void testArgMethodNoMatchExpectThrow() {
-		new Delegate().testArgMethodNoMatchExpectThrow();
-	}
-
-	private void called(Person found, long id) {
-		assertEquals(found, Person.findPerson(id));
-	}
-
-	@Test
-	public void testReentrant() {
-		long id = 13;
-		Person found = new Person();
-		Person.findPerson(id);
-		expectReturn(found);
-		playback();
-		called(found, id);
-	}
-
-	@Test(expected=IllegalStateException.class)
-	public void testRejectUnexpectedCall() {
-		new Delegate().rejectUnexpectedCall();
-	}
-
-	@Test(expected=IllegalStateException.class)
-	public void testFailTooFewCalls() {
-		new Delegate().failTooFewCalls();
-	}
-
-	@Test
-	public void testEmpty() {
-		// Test that verification check doesn't blow up if no replay() call happened
-	}
-
-	@Test(expected=IllegalStateException.class)
-	public void testDoesntEverReplay() {
-		new Delegate().doesntEverReplay();
-	}
-
-	@Test(expected=IllegalStateException.class)
-	public void testDoesntEverSetReturn() {
-		new Delegate().doesntEverSetReturn();
-	}
-}
-
@@ -0,0 +1,170 @@
+/*
+ * 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.mock.staticmock;
+
+import java.rmi.RemoteException;
+
+import javax.persistence.PersistenceException;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+import static org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl.*;
+
+/**
+ * Tests for Spring's static entity mocking framework (i.e., @{@link MockStaticEntityMethods}
+ * and {@link AnnotationDrivenStaticEntityMockingControl}).
+ * 
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @author Sam Brannen
+ */
+@MockStaticEntityMethods
+public class AnnotationDrivenStaticEntityMockingControlTests {
+
+	@Test
+	public void noArgumentMethodInvocationReturnsInt() {
+		int expectedCount = 13;
+		Person.countPeople();
+		expectReturn(expectedCount);
+		playback();
+		assertEquals(expectedCount, Person.countPeople());
+	}
+
+	@Test(expected = PersistenceException.class)
+	public void noArgumentMethodInvocationThrowsException() {
+		Person.countPeople();
+		expectThrow(new PersistenceException());
+		playback();
+		Person.countPeople();
+	}
+
+	@Test
+	public void methodArgumentsMatch() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		expectReturn(found);
+		playback();
+		assertEquals(found, Person.findPerson(id));
+	}
+
+	@Test
+	public void longSeriesOfCalls() {
+		long id1 = 13;
+		long id2 = 24;
+		Person found1 = new Person();
+		Person.findPerson(id1);
+		expectReturn(found1);
+		Person found2 = new Person();
+		Person.findPerson(id2);
+		expectReturn(found2);
+		Person.findPerson(id1);
+		expectReturn(found1);
+		Person.countPeople();
+		expectReturn(0);
+		playback();
+
+		assertEquals(found1, Person.findPerson(id1));
+		assertEquals(found2, Person.findPerson(id2));
+		assertEquals(found1, Person.findPerson(id1));
+		assertEquals(0, Person.countPeople());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void methodArgumentsDoNotMatchAndReturnsObject() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		assertEquals(found, Person.findPerson(id + 1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void methodArgumentsDoNotMatchAndThrowsException() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectThrow(new PersistenceException());
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		assertEquals(found, Person.findPerson(id + 1));
+	}
+
+	@Test
+	public void reentrant() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		expectReturn(found);
+		playback();
+		called(found, id);
+	}
+
+	private void called(Person found, long id) {
+		assertEquals(found, Person.findPerson(id));
+	}
+
+	@Test(expected = IllegalStateException.class)
+	public void rejectUnexpectedCall() {
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		Person.countPeople();
+	}
+
+	@Test(expected = IllegalStateException.class)
+	public void tooFewCalls() {
+		long id = 13;
+		Person found = new Person();
+		Person.findPerson(id);
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.expectReturn(25);
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		assertEquals(found, Person.findPerson(id));
+	}
+
+	@Test
+	public void empty() {
+		// Test that verification check doesn't blow up if no replay() call happened.
+	}
+
+	@Test(expected = IllegalStateException.class)
+	public void doesNotEnterPlaybackMode() {
+		Person.countPeople();
+	}
+
+	@Test(expected = IllegalStateException.class)
+	public void doesNotSetExpectedReturnValue() {
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.playback();
+	}
+
+	/**
+	 * Note: this test method currently does NOT actually verify that the mock
+	 * verification fails.
+	 */
+	// TODO Determine if it's possible for a mock verification failure to fail a test in
+	// JUnit 4+ if the test method itself throws an expected exception.
+	@Test(expected = RemoteException.class)
+	public void verificationFailsEvenWhenTestFailsInExpectedManner() throws Exception {
+		Person.countPeople();
+		AnnotationDrivenStaticEntityMockingControl.playback();
+		// No calls in order to allow verification failure
+		throw new RemoteException();
+	}
+
+}
@@ -1,92 +0,0 @@
-/*
- * 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
- *
- * 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.mock.staticmock;
-
-import static org.junit.Assert.assertEquals;
-
-import java.rmi.RemoteException;
-
-import javax.persistence.PersistenceException;
-
-import org.junit.Ignore;
-import org.junit.Test;
-import org.springframework.mock.staticmock.AnnotationDrivenStaticEntityMockingControl;
-import org.springframework.mock.staticmock.MockStaticEntityMethods;
-
-//Used because verification failures occur after method returns,
-//so we can't test for them in the test case itself
-@MockStaticEntityMethods
-@Ignore // This isn't meant for direct testing; rather it is driven from AnnotationDrivenStaticEntityMockingControl
-public class Delegate {
-
-	@Test
-	public void testArgMethodNoMatchExpectReturn() {
-		long id = 13;
-		Person found = new Person();
-		Person.findPerson(id);
-		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
-		AnnotationDrivenStaticEntityMockingControl.playback();
-		assertEquals(found, Person.findPerson(id + 1));
-	}
-
-	@Test
-	public void testArgMethodNoMatchExpectThrow() {
-		long id = 13;
-		Person found = new Person();
-		Person.findPerson(id);
-		AnnotationDrivenStaticEntityMockingControl.expectThrow(new PersistenceException());
-		AnnotationDrivenStaticEntityMockingControl.playback();
-		assertEquals(found, Person.findPerson(id + 1));
-	}
-
-	@Test
-	public void failTooFewCalls() {
-		long id = 13;
-		Person found = new Person();
-		Person.findPerson(id);
-		AnnotationDrivenStaticEntityMockingControl.expectReturn(found);
-		Person.countPeople();
-		AnnotationDrivenStaticEntityMockingControl.expectReturn(25);
-		AnnotationDrivenStaticEntityMockingControl.playback();
-		assertEquals(found, Person.findPerson(id));
-	}
-
-	@Test
-	public void doesntEverReplay() {
-		Person.countPeople();
-	}
-
-	@Test
-	public void doesntEverSetReturn() {
-		Person.countPeople();
-		AnnotationDrivenStaticEntityMockingControl.playback();
-	}
-
-	@Test
-	public void rejectUnexpectedCall() {
-		AnnotationDrivenStaticEntityMockingControl.playback();
-		Person.countPeople();
-	}
-
-	@Test(expected=RemoteException.class)
-	public void testVerificationFailsEvenWhenTestFailsInExpectedManner() throws RemoteException {
-		Person.countPeople();
-		AnnotationDrivenStaticEntityMockingControl.playback();
-		// No calls to allow verification failure
-		throw new RemoteException();
-	}
-}
@@ -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.
@@ -20,33 +20,36 @@ import java.beans.BeanInfo;
 import java.beans.IntrospectionException;

 /**
- * Strategy for creating {@link BeanInfo} instances.
+ * Strategy interface for creating {@link BeanInfo} instances for Spring beans.
+ * Can be used to plug in custom bean property resolution strategies (e.g. for other
+ * languages on the JVM) or more efficient {@link BeanInfo} retrieval algorithms.
 *
 * <p>BeanInfoFactories are are instantiated by the {@link CachedIntrospectionResults},
- * by using the {@link org.springframework.core.io.support.SpringFactoriesLoader} utility
- * class.
+ * by using the {@link org.springframework.core.io.support.SpringFactoriesLoader}
+ * utility class.
 *
 * When a {@link BeanInfo} is to be created, the {@code CachedIntrospectionResults}
- * will iterate through the discovered factories, calling {@link
- * #getBeanInfo(Class)} on each one. If {@code null} is returned, the next factory will
- * be queried. If none of the factories support the class, an standard {@link BeanInfo}
- * is created as a default.
+ * will iterate through the discovered factories, calling {@link #getBeanInfo(Class)}
+ * on each one. If {@code null} is returned, the next factory will be queried.
+ * If none of the factories support the class, a standard {@link BeanInfo} will be
+ * created as a default.
 *
 * <p>Note that the {@link org.springframework.core.io.support.SpringFactoriesLoader}
 * sorts the {@code BeanInfoFactory} instances by
- * {@link org.springframework.core.annotation.Order @Order}, so that ones with
- * a higher precedence come first.
+ * {@link org.springframework.core.annotation.Order @Order}, so that ones with a
+ * higher precedence come first.
 *
 * @author Arjen Poutsma
 * @since 3.2
+ * @see CachedIntrospectionResults
+ * @see org.springframework.core.io.support.SpringFactoriesLoader
 */
 public interface BeanInfoFactory {

 	/**
-	 * Returns the bean info for the given class, if supported.
-	 *
+	 * Return the bean info for the given class, if supported.
 	 * @param beanClass the bean class
-	 * @return the bean info, or {@code null} if not the given class is not supported
+	 * @return the BeanInfo, or {@code null} if the given class is not supported
 	 * @throws IntrospectionException in case of exceptions
 	 */
 	BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException;
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -57,7 +57,7 @@ public abstract class BeanUtils {

 	private static final Log logger = LogFactory.getLog(BeanUtils.class);

-	// using WeakHashMap as a Set
+	// Effectively using a WeakHashMap as a Set
 	private static final Map<Class<?>, Boolean> unknownEditorTypes =
 			Collections.synchronizedMap(new WeakHashMap<Class<?>, Boolean>());

@@ -127,7 +127,7 @@ public abstract class BeanUtils {
 	@SuppressWarnings("unchecked")
 	public static <T> T instantiateClass(Class<?> clazz, Class<T> assignableTo) throws BeanInstantiationException {
 		Assert.isAssignable(assignableTo, clazz);
-		return (T)instantiateClass(clazz);
+		return (T) instantiateClass(clazz);
 	}

 	/**
@@ -199,7 +199,7 @@ public abstract class BeanUtils {
 	 * @return the Method object, or {@code null} if not found
 	 * @see Class#getDeclaredMethod
 	 */
-	public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>[] paramTypes) {
+	public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
 		try {
 			return clazz.getDeclaredMethod(methodName, paramTypes);
 		}
@@ -281,7 +281,7 @@ public abstract class BeanUtils {
 				}
 				else {
 					if (targetMethod.getParameterTypes().length == numParams) {
-						// Additional candidate with same length.
+						// Additional candidate with same length
 						numMethodsFoundWithCurrentMinimumArgs++;
 					}
 				}
@@ -317,10 +317,8 @@ public abstract class BeanUtils {
 	public static Method resolveSignature(String signature, Class<?> clazz) {
 		Assert.hasText(signature, "'signature' must not be empty");
 		Assert.notNull(clazz, "Class must not be null");
-
 		int firstParen = signature.indexOf("(");
 		int lastParen = signature.indexOf(")");
-
 		if (firstParen > -1 && lastParen == -1) {
 			throw new IllegalArgumentException("Invalid method signature '" + signature +
 					"': expected closing ')' for args list");
@@ -336,7 +334,7 @@ public abstract class BeanUtils {
 			String methodName = signature.substring(0, firstParen);
 			String[] parameterTypeNames =
 					StringUtils.commaDelimitedListToStringArray(signature.substring(firstParen + 1, lastParen));
-			Class<?>[] parameterTypes = new Class[parameterTypeNames.length];
+			Class<?>[] parameterTypes = new Class<?>[parameterTypeNames.length];
 			for (int i = 0; i < parameterTypeNames.length; i++) {
 				String parameterTypeName = parameterTypeNames[i].trim();
 				try {
@@ -381,13 +379,28 @@ public abstract class BeanUtils {
 	 * Find a JavaBeans {@code PropertyDescriptor} for the given method,
 	 * with the method either being the read method or the write method for
 	 * that bean property.
-	 * @param method the method to find a corresponding PropertyDescriptor for
+	 * @param method the method to find a corresponding PropertyDescriptor for,
+	 * introspecting its declaring class
 	 * @return the corresponding PropertyDescriptor, or {@code null} if none
 	 * @throws BeansException if PropertyDescriptor lookup fails
 	 */
 	public static PropertyDescriptor findPropertyForMethod(Method method) throws BeansException {
+		return findPropertyForMethod(method, method.getDeclaringClass());
+	}
+
+	/**
+	 * Find a JavaBeans {@code PropertyDescriptor} for the given method,
+	 * with the method either being the read method or the write method for
+	 * that bean property.
+	 * @param method the method to find a corresponding PropertyDescriptor for
+	 * @param clazz the (most specific) class to introspect for descriptors
+	 * @return the corresponding PropertyDescriptor, or {@code null} if none
+	 * @throws BeansException if PropertyDescriptor lookup fails
+	 * @since 3.2.13
+	 */
+	public static PropertyDescriptor findPropertyForMethod(Method method, Class<?> clazz) throws BeansException {
 		Assert.notNull(method, "Method must not be null");
-		PropertyDescriptor[] pds = getPropertyDescriptors(method.getDeclaringClass());
+		PropertyDescriptor[] pds = getPropertyDescriptors(clazz);
 		for (PropertyDescriptor pd : pds) {
 			if (method.equals(pd.getReadMethod()) || method.equals(pd.getWriteMethod())) {
 				return pd;
@@ -455,7 +468,7 @@ public abstract class BeanUtils {
 	 * @param beanClasses the classes to check against
 	 * @return the property type, or {@code Object.class} as fallback
 	 */
-	public static Class<?> findPropertyType(String propertyName, Class<?>[] beanClasses) {
+	public static Class<?> findPropertyType(String propertyName, Class<?>... beanClasses) {
 		if (beanClasses != null) {
 			for (Class<?> beanClass : beanClasses) {
 				PropertyDescriptor pd = getPropertyDescriptor(beanClass, propertyName);
@@ -475,8 +488,7 @@ public abstract class BeanUtils {
 	 */
 	public static MethodParameter getWriteMethodParameter(PropertyDescriptor pd) {
 		if (pd instanceof GenericTypeAwarePropertyDescriptor) {
-			return new MethodParameter(
-					((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodParameter());
+			return new MethodParameter(((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodParameter());
 		}
 		else {
 			return new MethodParameter(pd.getWriteMethod(), 0);
@@ -528,7 +540,7 @@ public abstract class BeanUtils {
 	 * @see BeanWrapper
 	 */
 	public static void copyProperties(Object source, Object target) throws BeansException {
-		copyProperties(source, target, null, null);
+		copyProperties(source, target, null, (String[]) null);
 	}

 	/**
@@ -545,10 +557,8 @@ public abstract class BeanUtils {
 	 * @throws BeansException if the copying failed
 	 * @see BeanWrapper
 	 */
-	public static void copyProperties(Object source, Object target, Class<?> editable)
-			throws BeansException {
-
-		copyProperties(source, target, editable, null);
+	public static void copyProperties(Object source, Object target, Class<?> editable) throws BeansException {
+		copyProperties(source, target, editable, (String[]) null);
 	}

 	/**
@@ -565,9 +575,7 @@ public abstract class BeanUtils {
 	 * @throws BeansException if the copying failed
 	 * @see BeanWrapper
 	 */
-	public static void copyProperties(Object source, Object target, String[] ignoreProperties)
-			throws BeansException {
-
+	public static void copyProperties(Object source, Object target, String... ignoreProperties) throws BeansException {
 		copyProperties(source, target, null, ignoreProperties);
 	}

@@ -583,7 +591,7 @@ public abstract class BeanUtils {
 	 * @throws BeansException if the copying failed
 	 * @see BeanWrapper
 	 */
-	private static void copyProperties(Object source, Object target, Class<?> editable, String[] ignoreProperties)
+	private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties)
 			throws BeansException {

 		Assert.notNull(source, "Source must not be null");
@@ -598,27 +606,30 @@ public abstract class BeanUtils {
 			actualEditable = editable;
 		}
 		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
-		List<String> ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;
+		List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);

 		for (PropertyDescriptor targetPd : targetPds) {
-			if (targetPd.getWriteMethod() != null &&
-					(ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {
+			Method writeMethod = targetPd.getWriteMethod();
+			if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
 				PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
-				if (sourcePd != null && sourcePd.getReadMethod() != null) {
-					try {
-						Method readMethod = sourcePd.getReadMethod();
-						if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
-							readMethod.setAccessible(true);
+				if (sourcePd != null) {
+					Method readMethod = sourcePd.getReadMethod();
+					if (readMethod != null &&
+							ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
+						try {
+							if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
+								readMethod.setAccessible(true);
+							}
+							Object value = readMethod.invoke(source);
+							if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
+								writeMethod.setAccessible(true);
+							}
+							writeMethod.invoke(target, value);
 						}
-						Object value = readMethod.invoke(source);
-						Method writeMethod = targetPd.getWriteMethod();
-						if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
-							writeMethod.setAccessible(true);
+						catch (Throwable ex) {
+							throw new FatalBeanException(
+									"Could not copy property '" + targetPd.getName() + "' from source to target", ex);
 						}
-						writeMethod.invoke(target, value);
-					}
-					catch (Throwable ex) {
-						throw new FatalBeanException("Could not copy properties from source to target", ex);
 					}
 				}
 			}
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -59,7 +59,7 @@ public interface BeanWrapper extends ConfigurablePropertyAccessor {
 	 * @return the type of the wrapped bean instance,
 	 * or {@code null} if no wrapped object has been set
 	 */
-	Class getWrappedClass();
+	Class<?> getWrappedClass();

 	/**
 	 * Obtain the PropertyDescriptors for the wrapped object
@@ -79,11 +79,13 @@ public interface BeanWrapper extends ConfigurablePropertyAccessor {
 	PropertyDescriptor getPropertyDescriptor(String propertyName) throws InvalidPropertyException;

 	/**
-	 * Set whether this BeanWrapper should attempt to "auto-grow" a nested path that contains a null value.
-	 * <p>If "true", a null path location will be populated with a default object value and traversed
-	 * instead of resulting in a {@link NullValueInNestedPathException}. Turning this flag on also
-	 * enables auto-growth of collection elements when accessing an out-of-bounds index.
-	 * <p>Default is "false" on a plain BeanWrapper.
+	 * Set whether this BeanWrapper should attempt to "auto-grow" a
+	 * nested path that contains a {@code null} value.
+	 * <p>If {@code true}, a {@code null} path location will be populated
+	 * with a default object value and traversed instead of resulting in a
+	 * {@link NullValueInNestedPathException}. Turning this flag on also enables
+	 * auto-growth of collection elements when accessing an out-of-bounds index.
+	 * <p>Default is {@code false} on a plain BeanWrapper.
 	 */
 	void setAutoGrowNestedPaths(boolean autoGrowNestedPaths);

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -223,7 +223,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 		return this.object;
 	}

-	public final Class getWrappedClass() {
+	public final Class<?> getWrappedClass() {
 		return (this.object != null ? this.object.getClass() : null);
 	}

@@ -246,7 +246,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 	 * Return the class of the root object at the top of the path of this BeanWrapper.
 	 * @see #getNestedPath
 	 */
-	public final Class getRootClass() {
+	public final Class<?> getRootClass() {
 		return (this.rootObject != null ? this.rootObject.getClass() : null);
 	}

@@ -304,7 +304,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 	 * Needs to be called when the target object changes.
 	 * @param clazz the class to introspect
 	 */
-	protected void setIntrospectionClass(Class clazz) {
+	protected void setIntrospectionClass(Class<?> clazz) {
 		if (this.cachedIntrospectionResults != null &&
 				!clazz.equals(this.cachedIntrospectionResults.getBeanClass())) {
 			this.cachedIntrospectionResults = null;
@@ -352,7 +352,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 	}

 	@Override
-	public Class getPropertyType(String propertyName) throws BeansException {
+	public Class<?> getPropertyType(String propertyName) throws BeansException {
 		try {
 			PropertyDescriptor pd = getPropertyDescriptorInternal(propertyName);
 			if (pd != null) {
@@ -366,7 +366,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 				}
 				// Check to see if there is a custom editor,
 				// which might give an indication on the desired target type.
-				Class editorType = guessPropertyTypeFromEditors(propertyName);
+				Class<?> editorType = guessPropertyTypeFromEditors(propertyName);
 				if (editorType != null) {
 					return editorType;
 				}
@@ -389,7 +389,8 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 					if (pd.getReadMethod() != null || pd.getWriteMethod() != null) {
 						return TypeDescriptor.nested(property(pd), tokens.keys.length);
 					}
-				} else {
+				}
+				else {
 					if (pd.getReadMethod() != null || pd.getWriteMethod() != null) {
 						return new TypeDescriptor(property(pd));
 					}
@@ -485,13 +486,13 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 			throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
 					"No property '" + propertyName + "' found");
 		}
-		return convertForProperty(propertyName, null, value, pd);
+		return convertForProperty(propertyName, null, value, new TypeDescriptor(property(pd)));
 	}

-	private Object convertForProperty(String propertyName, Object oldValue, Object newValue, PropertyDescriptor pd)
+	private Object convertForProperty(String propertyName, Object oldValue, Object newValue, TypeDescriptor td)
 			throws TypeMismatchException {

-		return convertIfNecessary(propertyName, oldValue, newValue, pd.getPropertyType(), new TypeDescriptor(property(pd)));
+		return convertIfNecessary(propertyName, oldValue, newValue, td.getType(), td);
 	}

 	private Property property(PropertyDescriptor pd) {
@@ -699,7 +700,8 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 		return nestedBw.getPropertyValue(tokens);
 	}

-    private Object getPropertyValue(PropertyTokenHolder tokens) throws BeansException {
+    @SuppressWarnings("unchecked")
+	private Object getPropertyValue(PropertyTokenHolder tokens) throws BeansException {
 		String propertyName = tokens.canonicalName;
 		String actualName = tokens.actualName;
 		PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
@@ -766,20 +768,20 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 					}
 					else if (value instanceof List) {
 						int index = Integer.parseInt(key);
-						List list = (List) value;
+						List<Object> list = (List<Object>) value;
 						growCollectionIfNecessary(list, index, indexedPropertyName, pd, i + 1);
 						value = list.get(index);
 					}
 					else if (value instanceof Set) {
 						// Apply index to Iterator in case of a Set.
-						Set set = (Set) value;
+						Set<Object> set = (Set<Object>) value;
 						int index = Integer.parseInt(key);
 						if (index < 0 || index >= set.size()) {
 							throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
 									"Cannot get element with index " + index + " from Set of size " +
 									set.size() + ", accessed using property path '" + propertyName + "'");
 						}
-						Iterator it = set.iterator();
+						Iterator<Object> it = set.iterator();
 						for (int j = 0; it.hasNext(); j++) {
 							Object elem = it.next();
 							if (j == index) {
@@ -789,11 +791,12 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 						}
 					}
 					else if (value instanceof Map) {
-						Map map = (Map) value;
+						Map<Object, Object> map = (Map<Object, Object>) value;
 						Class<?> mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(pd.getReadMethod(), i + 1);
 						// IMPORTANT: Do not pass full property name in here - property editors
 						// must not kick in for map keys but rather only for map values.
-						TypeDescriptor typeDescriptor = mapKeyType != null ? TypeDescriptor.valueOf(mapKeyType) : TypeDescriptor.valueOf(Object.class);
+						TypeDescriptor typeDescriptor = (mapKeyType != null ?
+								TypeDescriptor.valueOf(mapKeyType) : TypeDescriptor.valueOf(Object.class));
 						Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType, typeDescriptor);
 						value = map.get(convertedMapKey);
 					}
@@ -850,16 +853,15 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 		}
 	}

-	@SuppressWarnings("unchecked")
-	private void growCollectionIfNecessary(
-			Collection collection, int index, String name, PropertyDescriptor pd, int nestingLevel) {
+	private void growCollectionIfNecessary(Collection<Object> collection, int index, String name,
+			PropertyDescriptor pd, int nestingLevel) {

 		if (!this.autoGrowNestedPaths) {
 			return;
 		}
 		int size = collection.size();
 		if (index >= size && index < this.autoGrowCollectionLimit) {
-			Class elementType = GenericCollectionTypeResolver.getCollectionReturnType(pd.getReadMethod(), nestingLevel);
+			Class<?> elementType = GenericCollectionTypeResolver.getCollectionReturnType(pd.getReadMethod(), nestingLevel);
 			if (elementType != null) {
 				for (int i = collection.size(); i < index + 1; i++) {
 					collection.add(newValue(elementType, name));
@@ -945,7 +947,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 			}
 			if (propValue.getClass().isArray()) {
 				PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
-				Class requiredType = propValue.getClass().getComponentType();
+				Class<?> requiredType = propValue.getClass().getComponentType();
 				int arrayIndex = Integer.parseInt(key);
 				Object oldValue = null;
 				try {
@@ -963,9 +965,9 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 			}
 			else if (propValue instanceof List) {
 				PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
-				Class requiredType = GenericCollectionTypeResolver.getCollectionReturnType(
+				Class<?> requiredType = GenericCollectionTypeResolver.getCollectionReturnType(
 						pd.getReadMethod(), tokens.keys.length);
-				List list = (List) propValue;
+				List<Object> list = (List<Object>) propValue;
 				int index = Integer.parseInt(key);
 				Object oldValue = null;
 				if (isExtractOldValueForEditor() && index < list.size()) {
@@ -1000,11 +1002,11 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 			}
 			else if (propValue instanceof Map) {
 				PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
-				Class mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(
+				Class<?> mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(
 						pd.getReadMethod(), tokens.keys.length);
-				Class mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(
+				Class<?> mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(
 						pd.getReadMethod(), tokens.keys.length);
-				Map map = (Map) propValue;
+				Map<Object, Object> map = (Map<Object, Object>) propValue;
 				// IMPORTANT: Do not pass full property name in here - property editors
 				// must not kick in for map keys but rather only for map values.
 				TypeDescriptor typeDescriptor = (mapKeyType != null ?
@@ -1023,7 +1025,7 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 			else {
 				throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
 						"Property referenced in indexed property path '" + propertyName +
-						"' is neither an array nor a List nor a Map; returned value was [" + pv.getValue() + "]");
+						"' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
 			}
 		}

@@ -1094,7 +1096,8 @@ public class BeanWrapperImpl extends AbstractPropertyAccessor implements BeanWra
 								}
 							}
 						}
-						valueToApply = convertForProperty(propertyName, oldValue, originalValue, pd);
+						valueToApply = convertForProperty(
+								propertyName, oldValue, originalValue, new TypeDescriptor(property(pd)));
 					}
 					pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
 				}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
+import java.lang.ref.SoftReference;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
@@ -33,6 +33,7 @@ import java.util.WeakHashMap;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

+import org.springframework.core.SpringProperties;
 import org.springframework.core.io.support.SpringFactoriesLoader;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
@@ -50,6 +51,18 @@ import org.springframework.util.StringUtils;
 * implements the factory design pattern, using a private constructor and
 * a static {@link #forClass(Class)} factory method to obtain instances.
 *
+ * <p>Note that for caching to work effectively, some preconditions need to be met:
+ * Prefer an arrangement where the Spring jars live in the same ClassLoader as the
+ * application classes, which allows for clean caching along with the application's
+ * lifecycle in any case. For a web application, consider declaring a local
+ * {@link org.springframework.web.util.IntrospectorCleanupListener} in {@code web.xml}
+ * in case of a multi-ClassLoader layout, which will allow for effective caching as well.
+ *
+ * <p>In case of a non-clean ClassLoader arrangement without a cleanup listener having
+ * been set up, this class will fall back to a weak-reference-based caching model that
+ * recreates much-requested entries every time the garbage collector removed them. In
+ * such a scenario, consider the {@link #IGNORE_BEANINFO_PROPERTY_NAME} system property.
+ *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 05 May 2001
@@ -59,11 +72,34 @@ import org.springframework.util.StringUtils;
 */
 public class CachedIntrospectionResults {

-	private static final Log logger = LogFactory.getLog(CachedIntrospectionResults.class);
+	/**
+	 * System property that instructs Spring to use the {@link Introspector#IGNORE_ALL_BEANINFO}
+	 * mode when calling the JavaBeans {@link Introspector}: "spring.beaninfo.ignore", with a
+	 * value of "true" skipping the search for {@code BeanInfo} classes (typically for scenarios
+	 * where no such classes are being defined for beans in the application in the first place).
+	 * <p>The default is "false", considering all {@code BeanInfo} metadata classes, like for
+	 * standard {@link Introspector#getBeanInfo(Class)} calls. Consider switching this flag to
+	 * "true" if you experience repeated ClassLoader access for non-existing {@code BeanInfo}
+	 * classes, in case such access is expensive on startup or on lazy loading.
+	 * <p>Note that such an effect may also indicate a scenario where caching doesn't work
+	 * effectively: Prefer an arrangement where the Spring jars live in the same ClassLoader
+	 * as the application classes, which allows for clean caching along with the application's
+	 * lifecycle in any case. For a web application, consider declaring a local
+	 * {@link org.springframework.web.util.IntrospectorCleanupListener} in {@code web.xml}
+	 * in case of a multi-ClassLoader layout, which will allow for effective caching as well.
+	 * @see Introspector#getBeanInfo(Class, int)
+	 */
+	public static final String IGNORE_BEANINFO_PROPERTY_NAME = "spring.beaninfo.ignore";
+
+
+	private static final boolean shouldIntrospectorIgnoreBeaninfoClasses =
+			SpringProperties.getFlag(IGNORE_BEANINFO_PROPERTY_NAME);

 	/** Stores the BeanInfoFactory instances */
-	private static List<BeanInfoFactory> beanInfoFactories =
-			SpringFactoriesLoader.loadFactories(BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
+	private static List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
+			BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());
+
+	private static final Log logger = LogFactory.getLog(CachedIntrospectionResults.class);

 	/**
 	 * Set of ClassLoaders that this CachedIntrospectionResults class will always
@@ -76,7 +112,7 @@ public class CachedIntrospectionResults {
 	 * Needs to be a WeakHashMap with WeakReferences as values to allow
 	 * for proper garbage collection in case of multiple class loaders.
 	 */
-	static final Map<Class, Object> classCache = new WeakHashMap<Class, Object>();
+	static final Map<Class<?>, Object> classCache = new WeakHashMap<Class<?>, Object>();


 	/**
@@ -101,15 +137,14 @@ public class CachedIntrospectionResults {

 	/**
 	 * Clear the introspection cache for the given ClassLoader, removing the
-	 * introspection results for all classes underneath that ClassLoader,
-	 * and deregistering the ClassLoader (and any of its children) from the
-	 * acceptance list.
+	 * introspection results for all classes underneath that ClassLoader, and
+	 * removing the ClassLoader (and its children) from the acceptance list.
 	 * @param classLoader the ClassLoader to clear the cache for
 	 */
 	public static void clearClassLoader(ClassLoader classLoader) {
 		synchronized (classCache) {
-			for (Iterator<Class> it = classCache.keySet().iterator(); it.hasNext();) {
-				Class beanClass = it.next();
+			for (Iterator<Class<?>> it = classCache.keySet().iterator(); it.hasNext();) {
+				Class<?> beanClass = it.next();
 				if (isUnderneathClassLoader(beanClass.getClassLoader(), classLoader)) {
 					it.remove();
 				}
@@ -127,21 +162,20 @@ public class CachedIntrospectionResults {

 	/**
 	 * Create CachedIntrospectionResults for the given bean class.
-	 * <P>We don't want to use synchronization here. Object references are atomic,
-	 * so we can live with doing the occasional unnecessary lookup at startup only.
 	 * @param beanClass the bean class to analyze
 	 * @return the corresponding CachedIntrospectionResults
 	 * @throws BeansException in case of introspection failure
 	 */
-	static CachedIntrospectionResults forClass(Class beanClass) throws BeansException {
+	@SuppressWarnings("unchecked")
+	static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException {
 		CachedIntrospectionResults results;
 		Object value;
 		synchronized (classCache) {
 			value = classCache.get(beanClass);
 		}
 		if (value instanceof Reference) {
-			Reference ref = (Reference) value;
-			results = (CachedIntrospectionResults) ref.get();
+			Reference<CachedIntrospectionResults> ref = (Reference<CachedIntrospectionResults>) value;
+			results = ref.get();
 		}
 		else {
 			results = (CachedIntrospectionResults) value;
@@ -160,7 +194,7 @@ public class CachedIntrospectionResults {
 				}
 				results = new CachedIntrospectionResults(beanClass);
 				synchronized (classCache) {
-					classCache.put(beanClass, new WeakReference<CachedIntrospectionResults>(results));
+					classCache.put(beanClass, new SoftReference<CachedIntrospectionResults>(results));
 				}
 			}
 		}
@@ -181,8 +215,8 @@ public class CachedIntrospectionResults {
 		synchronized (acceptedClassLoaders) {
 			acceptedLoaderArray = acceptedClassLoaders.toArray(new ClassLoader[acceptedClassLoaders.size()]);
 		}
-		for (ClassLoader registeredLoader : acceptedLoaderArray) {
-			if (isUnderneathClassLoader(classLoader, registeredLoader)) {
+		for (ClassLoader acceptedLoader : acceptedLoaderArray) {
+			if (isUnderneathClassLoader(classLoader, acceptedLoader)) {
 				return true;
 			}
 		}
@@ -225,7 +259,7 @@ public class CachedIntrospectionResults {
 	 * @param beanClass the bean class to analyze
 	 * @throws BeansException in case of introspection failure
 	 */
-	private CachedIntrospectionResults(Class beanClass) throws BeansException {
+	private CachedIntrospectionResults(Class<?> beanClass) throws BeansException {
 		try {
 			if (logger.isTraceEnabled()) {
 				logger.trace("Getting BeanInfo for class [" + beanClass.getName() + "]");
@@ -240,20 +274,25 @@ public class CachedIntrospectionResults {
 			}
 			if (beanInfo == null) {
 				// If none of the factories supported the class, fall back to the default
-				beanInfo = Introspector.getBeanInfo(beanClass);
+				beanInfo = (shouldIntrospectorIgnoreBeaninfoClasses ?
+						Introspector.getBeanInfo(beanClass, Introspector.IGNORE_ALL_BEANINFO) :
+						Introspector.getBeanInfo(beanClass));
 			}
 			this.beanInfo = beanInfo;

-			// Immediately remove class from Introspector cache, to allow for proper
-			// garbage collection on class loader shutdown - we cache it here anyway,
-			// in a GC-friendly manner. In contrast to CachedIntrospectionResults,
-			// Introspector does not use WeakReferences as values of its WeakHashMap!
-			Class classToFlush = beanClass;
-			do {
-				Introspector.flushFromCaches(classToFlush);
-				classToFlush = classToFlush.getSuperclass();
+			// Only bother with flushFromCaches if the Introspector actually cached...
+			if (!shouldIntrospectorIgnoreBeaninfoClasses) {
+				// Immediately remove class from Introspector cache, to allow for proper
+				// garbage collection on class loader shutdown - we cache it here anyway,
+				// in a GC-friendly manner. In contrast to CachedIntrospectionResults,
+				// Introspector does not use WeakReferences as values of its WeakHashMap!
+				Class<?> classToFlush = beanClass;
+				do {
+					Introspector.flushFromCaches(classToFlush);
+					classToFlush = classToFlush.getSuperclass();
+				}
+				while (classToFlush != null && classToFlush != Object.class);
 			}
-			while (classToFlush != null);

 			if (logger.isTraceEnabled()) {
 				logger.trace("Caching PropertyDescriptors for class [" + beanClass.getName() + "]");
@@ -263,8 +302,9 @@ public class CachedIntrospectionResults {
 			// This call is slow so we do it once.
 			PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();
 			for (PropertyDescriptor pd : pds) {
-				if (Class.class.equals(beanClass) && "classLoader".equals(pd.getName())) {
-					// Ignore Class.getClassLoader() method - nobody needs to bind to that
+				if (Class.class.equals(beanClass) &&
+						("classLoader".equals(pd.getName()) ||  "protectionDomain".equals(pd.getName()))) {
+					// Ignore Class.getClassLoader() and getProtectionDomain() methods - nobody needs to bind to those
 					continue;
 				}
 				if (logger.isTraceEnabled()) {
@@ -286,7 +326,7 @@ public class CachedIntrospectionResults {
 		return this.beanInfo;
 	}

-	Class getBeanClass() {
+	Class<?> getBeanClass() {
 		return this.beanInfo.getBeanDescriptor().getBeanClass();
 	}

@@ -314,7 +354,7 @@ public class CachedIntrospectionResults {
 		return pds;
 	}

-	private PropertyDescriptor buildGenericTypeAwarePropertyDescriptor(Class beanClass, PropertyDescriptor pd) {
+	private PropertyDescriptor buildGenericTypeAwarePropertyDescriptor(Class<?> beanClass, PropertyDescriptor pd) {
 		try {
 			return new GenericTypeAwarePropertyDescriptor(beanClass, pd.getName(), pd.getReadMethod(),
 					pd.getWriteMethod(), pd.getPropertyEditorClass());
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -17,7 +17,6 @@
 package org.springframework.beans;

 import java.awt.Image;
-
 import java.beans.BeanDescriptor;
 import java.beans.BeanInfo;
 import java.beans.EventSetDescriptor;
@@ -26,10 +25,8 @@ import java.beans.IntrospectionException;
 import java.beans.Introspector;
 import java.beans.MethodDescriptor;
 import java.beans.PropertyDescriptor;
-
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -38,13 +35,16 @@ import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;

+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
 import static org.springframework.beans.PropertyDescriptorUtils.*;

 /**
 * Decorator for a standard {@link BeanInfo} object, e.g. as created by
 * {@link Introspector#getBeanInfo(Class)}, designed to discover and register static
 * and/or non-void returning setter methods. For example:
- * <pre>{@code
+ * <pre class="code">
 * public class Bean {
 *     private Foo foo;
 *
@@ -56,7 +56,7 @@ import static org.springframework.beans.PropertyDescriptorUtils.*;
 *         this.foo = foo;
 *         return this;
 *     }
- * }}</pre>
+ * }</pre>
 * The standard JavaBeans {@code Introspector} will discover the {@code getFoo} read
 * method, but will bypass the {@code #setFoo(Foo)} write method, because its non-void
 * returning signature does not comply with the JavaBeans specification.
@@ -76,6 +76,8 @@ import static org.springframework.beans.PropertyDescriptorUtils.*;
 */
 class ExtendedBeanInfo implements BeanInfo {

+	private static final Log logger = LogFactory.getLog(ExtendedBeanInfo.class);
+
 	private final BeanInfo delegate;

 	private final Set<PropertyDescriptor> propertyDescriptors =
@@ -84,8 +86,8 @@ class ExtendedBeanInfo implements BeanInfo {

 	/**
 	 * Wrap the given {@link BeanInfo} instance; copy all its existing property descriptors
-	 * locally, wrapping each in a custom {@link SimpleIndexedPropertyDescriptor indexed} or
-	 * {@link SimpleNonIndexedPropertyDescriptor non-indexed} {@code PropertyDescriptor}
+	 * locally, wrapping each in a custom {@link SimpleIndexedPropertyDescriptor indexed}
+	 * or {@link SimplePropertyDescriptor non-indexed} {@code PropertyDescriptor}
 	 * variant that bypasses default JDK weak/soft reference management; then search
 	 * through its method descriptors to find any non-void returning write methods and
 	 * update or create the corresponding {@link PropertyDescriptor} for each one found.
@@ -96,15 +98,32 @@ class ExtendedBeanInfo implements BeanInfo {
 	 */
 	public ExtendedBeanInfo(BeanInfo delegate) throws IntrospectionException {
 		this.delegate = delegate;
-
 		for (PropertyDescriptor pd : delegate.getPropertyDescriptors()) {
-			this.propertyDescriptors.add(pd instanceof IndexedPropertyDescriptor ?
-					new SimpleIndexedPropertyDescriptor((IndexedPropertyDescriptor) pd) :
-					new SimpleNonIndexedPropertyDescriptor(pd));
+			try {
+				this.propertyDescriptors.add(pd instanceof IndexedPropertyDescriptor ?
+						new SimpleIndexedPropertyDescriptor((IndexedPropertyDescriptor) pd) :
+						new SimplePropertyDescriptor(pd));
+			}
+			catch (IntrospectionException ex) {
+				// Probably simply a method that wasn't meant to follow the JavaBeans pattern...
+				if (logger.isDebugEnabled()) {
+					logger.debug("Ignoring invalid bean property '" + pd.getName() + "': " + ex.getMessage());
+				}
+			}
 		}
-
-		for (Method method : findCandidateWriteMethods(delegate.getMethodDescriptors())) {
-			handleCandidateWriteMethod(method);
+		MethodDescriptor[] methodDescriptors = delegate.getMethodDescriptors();
+		if (methodDescriptors != null) {
+			for (Method method : findCandidateWriteMethods(methodDescriptors)) {
+				try {
+					handleCandidateWriteMethod(method);
+				}
+				catch (IntrospectionException ex) {
+					// We're only trying to find candidates, can easily ignore extra ones here...
+					if (logger.isDebugEnabled()) {
+						logger.debug("Ignoring candidate write method [" + method + "]: " + ex.getMessage());
+					}
+				}
+			}
 		}
 	}

@@ -117,7 +136,7 @@ class ExtendedBeanInfo implements BeanInfo {
 				matches.add(method);
 			}
 		}
-		// sort non-void returning write methods to guard against the ill effects of
+		// Sort non-void returning write methods to guard against the ill effects of
 		// non-deterministic sorting of methods returned from Class#getDeclaredMethods
 		// under JDK 7. See http://bugs.sun.com/view_bug.do?bug_id=7023180
 		Collections.sort(matches, new Comparator<Method>() {
@@ -132,58 +151,44 @@ class ExtendedBeanInfo implements BeanInfo {
 		String methodName = method.getName();
 		Class<?>[] parameterTypes = method.getParameterTypes();
 		int nParams = parameterTypes.length;
-		if (methodName.length() > 3 && methodName.startsWith("set") &&
-				Modifier.isPublic(method.getModifiers()) &&
-				(
-						!void.class.isAssignableFrom(method.getReturnType()) ||
-						Modifier.isStatic(method.getModifiers())
-				) &&
-				(nParams == 1 || (nParams == 2 && parameterTypes[0].equals(int.class)))) {
-			return true;
-		}
-		return false;
+		return (methodName.length() > 3 && methodName.startsWith("set") && Modifier.isPublic(method.getModifiers()) &&
+				(!void.class.isAssignableFrom(method.getReturnType()) || Modifier.isStatic(method.getModifiers())) &&
+				(nParams == 1 || (nParams == 2 && parameterTypes[0].equals(int.class))));
 	}

 	private void handleCandidateWriteMethod(Method method) throws IntrospectionException {
 		int nParams = method.getParameterTypes().length;
 		String propertyName = propertyNameFor(method);
-		Class<?> propertyType = method.getParameterTypes()[nParams-1];
-		PropertyDescriptor existingPD = findExistingPropertyDescriptor(propertyName, propertyType);
+		Class<?> propertyType = method.getParameterTypes()[nParams - 1];
+		PropertyDescriptor existingPd = findExistingPropertyDescriptor(propertyName, propertyType);
 		if (nParams == 1) {
-			if (existingPD == null) {
-				this.propertyDescriptors.add(
-						new SimpleNonIndexedPropertyDescriptor(propertyName, null, method));
+			if (existingPd == null) {
+				this.propertyDescriptors.add(new SimplePropertyDescriptor(propertyName, null, method));
 			}
 			else {
-				existingPD.setWriteMethod(method);
+				existingPd.setWriteMethod(method);
 			}
 		}
 		else if (nParams == 2) {
-			if (existingPD == null) {
+			if (existingPd == null) {
 				this.propertyDescriptors.add(
-						new SimpleIndexedPropertyDescriptor(
-								propertyName, null, null, null, method));
+						new SimpleIndexedPropertyDescriptor(propertyName, null, null, null, method));
 			}
-			else if (existingPD instanceof IndexedPropertyDescriptor) {
-				((IndexedPropertyDescriptor)existingPD).setIndexedWriteMethod(method);
+			else if (existingPd instanceof IndexedPropertyDescriptor) {
+				((IndexedPropertyDescriptor) existingPd).setIndexedWriteMethod(method);
 			}
 			else {
-				this.propertyDescriptors.remove(existingPD);
-				this.propertyDescriptors.add(
-						new SimpleIndexedPropertyDescriptor(
-								propertyName, existingPD.getReadMethod(),
-								existingPD.getWriteMethod(), null, method));
+				this.propertyDescriptors.remove(existingPd);
+				this.propertyDescriptors.add(new SimpleIndexedPropertyDescriptor(
+						propertyName, existingPd.getReadMethod(), existingPd.getWriteMethod(), null, method));
 			}
 		}
 		else {
-			throw new IllegalArgumentException(
-					"write method must have exactly 1 or 2 parameters: " + method);
+			throw new IllegalArgumentException("Write method must have exactly 1 or 2 parameters: " + method);
 		}
 	}

-	private PropertyDescriptor findExistingPropertyDescriptor(
-			String propertyName, Class<?> propertyType) {
-
+	private PropertyDescriptor findExistingPropertyDescriptor(String propertyName, Class<?> propertyType) {
 		for (PropertyDescriptor pd : this.propertyDescriptors) {
 			final Class<?> candidateType;
 			final String candidateName = pd.getName();
@@ -191,16 +196,14 @@ class ExtendedBeanInfo implements BeanInfo {
 				IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor) pd;
 				candidateType = ipd.getIndexedPropertyType();
 				if (candidateName.equals(propertyName) &&
-						(candidateType.equals(propertyType) ||
-								candidateType.equals(propertyType.getComponentType()))) {
+						(candidateType.equals(propertyType) || candidateType.equals(propertyType.getComponentType()))) {
 					return pd;
 				}
 			}
 			else {
 				candidateType = pd.getPropertyType();
 				if (candidateName.equals(propertyName) &&
-						(candidateType.equals(propertyType) ||
-								propertyType.equals(candidateType.getComponentType()))) {
+						(candidateType.equals(propertyType) || propertyType.equals(candidateType.getComponentType()))) {
 					return pd;
 				}
 			}
@@ -209,8 +212,7 @@ class ExtendedBeanInfo implements BeanInfo {
 	}

 	private String propertyNameFor(Method method) {
-		return Introspector.decapitalize(
-				method.getName().substring(3, method.getName().length()));
+		return Introspector.decapitalize(method.getName().substring(3, method.getName().length()));
 	}


@@ -221,65 +223,61 @@ class ExtendedBeanInfo implements BeanInfo {
 	 * @see #ExtendedBeanInfo(BeanInfo)
 	 */
 	public PropertyDescriptor[] getPropertyDescriptors() {
-		return this.propertyDescriptors.toArray(
-				new PropertyDescriptor[this.propertyDescriptors.size()]);
+		return this.propertyDescriptors.toArray(new PropertyDescriptor[this.propertyDescriptors.size()]);
 	}

 	public BeanInfo[] getAdditionalBeanInfo() {
-		return delegate.getAdditionalBeanInfo();
+		return this.delegate.getAdditionalBeanInfo();
 	}

 	public BeanDescriptor getBeanDescriptor() {
-		return delegate.getBeanDescriptor();
+		return this.delegate.getBeanDescriptor();
 	}

 	public int getDefaultEventIndex() {
-		return delegate.getDefaultEventIndex();
+		return this.delegate.getDefaultEventIndex();
 	}

 	public int getDefaultPropertyIndex() {
-		return delegate.getDefaultPropertyIndex();
+		return this.delegate.getDefaultPropertyIndex();
 	}

 	public EventSetDescriptor[] getEventSetDescriptors() {
-		return delegate.getEventSetDescriptors();
+		return this.delegate.getEventSetDescriptors();
 	}

 	public Image getIcon(int iconKind) {
-		return delegate.getIcon(iconKind);
+		return this.delegate.getIcon(iconKind);
 	}

 	public MethodDescriptor[] getMethodDescriptors() {
-		return delegate.getMethodDescriptors();
+		return this.delegate.getMethodDescriptors();
 	}
 }


-class SimpleNonIndexedPropertyDescriptor extends PropertyDescriptor {
+class SimplePropertyDescriptor extends PropertyDescriptor {

 	private Method readMethod;
+
 	private Method writeMethod;
+
 	private Class<?> propertyType;
+
 	private Class<?> propertyEditorClass;

-
-	public SimpleNonIndexedPropertyDescriptor(PropertyDescriptor original)
-			throws IntrospectionException {
-
+	public SimplePropertyDescriptor(PropertyDescriptor original) throws IntrospectionException {
 		this(original.getName(), original.getReadMethod(), original.getWriteMethod());
 		copyNonMethodProperties(original, this);
 	}

-	public SimpleNonIndexedPropertyDescriptor(String propertyName,
-			Method readMethod, Method writeMethod) throws IntrospectionException {
-
+	public SimplePropertyDescriptor(String propertyName, Method readMethod, Method writeMethod) throws IntrospectionException {
 		super(propertyName, null, null);
-		this.setReadMethod(readMethod);
-		this.setWriteMethod(writeMethod);
+		this.readMethod = readMethod;
+		this.writeMethod = writeMethod;
 		this.propertyType = findPropertyType(readMethod, writeMethod);
 	}

-
 	@Override
 	public Method getReadMethod() {
 		return this.readMethod;
@@ -305,8 +303,9 @@ class SimpleNonIndexedPropertyDescriptor extends PropertyDescriptor {
 		if (this.propertyType == null) {
 			try {
 				this.propertyType = findPropertyType(this.readMethod, this.writeMethod);
-			} catch (IntrospectionException ex) {
-				// ignore, as does PropertyDescriptor#getPropertyType
+			}
+			catch (IntrospectionException ex) {
+				// Ignore, as does PropertyDescriptor#getPropertyType
 			}
 		}
 		return this.propertyType;
@@ -322,7 +321,6 @@ class SimpleNonIndexedPropertyDescriptor extends PropertyDescriptor {
 		this.propertyEditorClass = propertyEditorClass;
 	}

-
 	@Override
 	public boolean equals(Object obj) {
 		return PropertyDescriptorUtils.equals(this, obj);
@@ -331,8 +329,7 @@ class SimpleNonIndexedPropertyDescriptor extends PropertyDescriptor {
 	@Override
 	public String toString() {
 		return String.format("%s[name=%s, propertyType=%s, readMethod=%s, writeMethod=%s]",
-				this.getClass().getSimpleName(), this.getName(), this.getPropertyType(),
-				this.readMethod, this.writeMethod);
+				getClass().getSimpleName(), getName(), getPropertyType(), this.readMethod, this.writeMethod);
 	}
 }

@@ -340,40 +337,37 @@ class SimpleNonIndexedPropertyDescriptor extends PropertyDescriptor {
 class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {

 	private Method readMethod;
+
 	private Method writeMethod;
+
 	private Class<?> propertyType;
-	private Class<?> propertyEditorClass;

 	private Method indexedReadMethod;
+
 	private Method indexedWriteMethod;
+
 	private Class<?> indexedPropertyType;

+	private Class<?> propertyEditorClass;

-	public SimpleIndexedPropertyDescriptor(IndexedPropertyDescriptor original)
-			throws IntrospectionException {
-
+	public SimpleIndexedPropertyDescriptor(IndexedPropertyDescriptor original) throws IntrospectionException {
 		this(original.getName(), original.getReadMethod(), original.getWriteMethod(),
 				original.getIndexedReadMethod(), original.getIndexedWriteMethod());
 		copyNonMethodProperties(original, this);
 	}

-	public SimpleIndexedPropertyDescriptor(String propertyName,
-				Method readMethod, Method writeMethod,
-				Method indexedReadMethod, Method indexedWriteMethod)
-			throws IntrospectionException {
+	public SimpleIndexedPropertyDescriptor(String propertyName, Method readMethod, Method writeMethod,
+				Method indexedReadMethod, Method indexedWriteMethod) throws IntrospectionException {

 		super(propertyName, null, null, null, null);
-		this.setReadMethod(readMethod);
-		this.setWriteMethod(writeMethod);
+		this.readMethod = readMethod;
+		this.writeMethod = writeMethod;
 		this.propertyType = findPropertyType(readMethod, writeMethod);
-
-		this.setIndexedReadMethod(indexedReadMethod);
-		this.setIndexedWriteMethod(indexedWriteMethod);
-		this.indexedPropertyType = findIndexedPropertyType(
-				this.getName(), this.propertyType, indexedReadMethod, indexedWriteMethod);
+		this.indexedReadMethod = indexedReadMethod;
+		this.indexedWriteMethod = indexedWriteMethod;
+		this.indexedPropertyType = findIndexedPropertyType(propertyName, this.propertyType, indexedReadMethod, indexedWriteMethod);
 	}

-
 	@Override
 	public Method getReadMethod() {
 		return this.readMethod;
@@ -399,8 +393,9 @@ class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {
 		if (this.propertyType == null) {
 			try {
 				this.propertyType = findPropertyType(this.readMethod, this.writeMethod);
-			} catch (IntrospectionException ex) {
-				// ignore, as does IndexedPropertyDescriptor#getPropertyType
+			}
+			catch (IntrospectionException ex) {
+				// Ignore, as does IndexedPropertyDescriptor#getPropertyType
 			}
 		}
 		return this.propertyType;
@@ -431,10 +426,10 @@ class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {
 		if (this.indexedPropertyType == null) {
 			try {
 				this.indexedPropertyType = findIndexedPropertyType(
-						this.getName(), this.getPropertyType(),
-						this.indexedReadMethod, this.indexedWriteMethod);
-			} catch (IntrospectionException ex) {
-				// ignore, as does IndexedPropertyDescriptor#getIndexedPropertyType
+						getName(), getPropertyType(), this.indexedReadMethod, this.indexedWriteMethod);
+			}
+			catch (IntrospectionException ex) {
+				// Ignore, as does IndexedPropertyDescriptor#getIndexedPropertyType
 			}
 		}
 		return this.indexedPropertyType;
@@ -450,41 +445,36 @@ class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {
 		this.propertyEditorClass = propertyEditorClass;
 	}

-
 	/*
-	 * @see java.beans.IndexedPropertyDescriptor#equals(java.lang.Object)
+	 * See java.beans.IndexedPropertyDescriptor#equals(java.lang.Object)
 	 */
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
+	public boolean equals(Object other) {
+		if (this == other) {
 			return true;
 		}
-
-		if (obj != null && obj instanceof IndexedPropertyDescriptor) {
-			IndexedPropertyDescriptor other = (IndexedPropertyDescriptor) obj;
-			if (!compareMethods(getIndexedReadMethod(), other.getIndexedReadMethod())) {
-				return false;
-			}
-
-			if (!compareMethods(getIndexedWriteMethod(), other.getIndexedWriteMethod())) {
-				return false;
-			}
-
-			if (getIndexedPropertyType() != other.getIndexedPropertyType()) {
-				return false;
-			}
-			return PropertyDescriptorUtils.equals(this, obj);
+		if (!(other instanceof IndexedPropertyDescriptor)) {
+			return false;
 		}
-		return false;
+		IndexedPropertyDescriptor otherPd = (IndexedPropertyDescriptor) other;
+		if (!compareMethods(getIndexedReadMethod(), otherPd.getIndexedReadMethod())) {
+			return false;
+		}
+		if (!compareMethods(getIndexedWriteMethod(), otherPd.getIndexedWriteMethod())) {
+			return false;
+		}
+		if (getIndexedPropertyType() != otherPd.getIndexedPropertyType()) {
+			return false;
+		}
+		return PropertyDescriptorUtils.equals(this, other);
 	}

 	@Override
 	public String toString() {
 		return String.format("%s[name=%s, propertyType=%s, indexedPropertyType=%s, " +
 				"readMethod=%s, writeMethod=%s, indexedReadMethod=%s, indexedWriteMethod=%s]",
-				this.getClass().getSimpleName(), this.getName(), this.getPropertyType(),
-				this.getIndexedPropertyType(), this.readMethod, this.writeMethod,
-				this.indexedReadMethod, this.indexedWriteMethod);
+				getClass().getSimpleName(), getName(), getPropertyType(), getIndexedPropertyType(),
+				this.readMethod, this.writeMethod, this.indexedReadMethod, this.indexedWriteMethod);
 	}
 }

@@ -492,7 +482,7 @@ class SimpleIndexedPropertyDescriptor extends IndexedPropertyDescriptor {
 class PropertyDescriptorUtils {

 	/*
-	 * see java.beans.FeatureDescriptor#FeatureDescriptor(FeatureDescriptor)
+	 * See java.beans.FeatureDescriptor#FeatureDescriptor(FeatureDescriptor)
 	 */
 	public static void copyNonMethodProperties(PropertyDescriptor source, PropertyDescriptor target)
 			throws IntrospectionException {
@@ -504,14 +494,14 @@ class PropertyDescriptorUtils {
 		target.setShortDescription(source.getShortDescription());
 		target.setDisplayName(source.getDisplayName());

-		// copy all attributes (emulating behavior of private FeatureDescriptor#addTable)
+		// Copy all attributes (emulating behavior of private FeatureDescriptor#addTable)
 		Enumeration<String> keys = source.attributeNames();
 		while (keys.hasMoreElements()) {
 			String key = keys.nextElement();
 			target.setValue(key, source.getValue(key));
 		}

-		// see java.beans.PropertyDescriptor#PropertyDescriptor(PropertyDescriptor)
+		// See java.beans.PropertyDescriptor#PropertyDescriptor(PropertyDescriptor)
 		target.setPropertyEditorClass(source.getPropertyEditorClass());
 		target.setBound(source.isBound());
 		target.setConstrained(source.isConstrained());
@@ -520,32 +510,39 @@ class PropertyDescriptorUtils {
 	/*
 	 * See PropertyDescriptor#findPropertyType
 	 */
-	public static Class<?> findPropertyType(Method readMethod, Method writeMethod)
-			throws IntrospectionException {
-
+	public static Class<?> findPropertyType(Method readMethod, Method writeMethod) throws IntrospectionException {
 		Class<?> propertyType = null;
-
 		if (readMethod != null) {
 			Class<?>[] params = readMethod.getParameterTypes();
 			if (params.length != 0) {
-				throw new IntrospectionException("bad read method arg count: " + readMethod);
+				throw new IntrospectionException("Bad read method arg count: " + readMethod);
 			}
 			propertyType = readMethod.getReturnType();
 			if (propertyType == Void.TYPE) {
-				throw new IntrospectionException("read method "
-						+ readMethod.getName() + " returns void");
+				throw new IntrospectionException("Read method returns void: " + readMethod);
 			}
 		}
 		if (writeMethod != null) {
 			Class<?> params[] = writeMethod.getParameterTypes();
 			if (params.length != 1) {
-				throw new IntrospectionException("bad write method arg count: " + writeMethod);
+				throw new IntrospectionException("Bad write method arg count: " + writeMethod);
 			}
-			if (propertyType != null
-					&& !params[0].isAssignableFrom(propertyType)) {
-				throw new IntrospectionException("type mismatch between read and write methods");
+			if (propertyType != null) {
+				if (propertyType.isAssignableFrom(params[0])) {
+					// Write method's property type potentially more specific
+					propertyType = params[0];
+				}
+				else if (params[0].isAssignableFrom(propertyType)) {
+					// Proceed with read method's property type
+				}
+				else {
+					throw new IntrospectionException(
+							"Type mismatch between read and write methods: " + readMethod + " - " + writeMethod);
+				}
+			}
+			else {
+				propertyType = params[0];
 			}
-			propertyType = params[0];
 		}
 		return propertyType;
 	}
@@ -554,48 +551,51 @@ class PropertyDescriptorUtils {
 	 * See IndexedPropertyDescriptor#findIndexedPropertyType
 	 */
 	public static Class<?> findIndexedPropertyType(String name, Class<?> propertyType,
-				Method indexedReadMethod, Method indexedWriteMethod)
-			throws IntrospectionException {
+			Method indexedReadMethod, Method indexedWriteMethod) throws IntrospectionException {

 		Class<?> indexedPropertyType = null;
-
 		if (indexedReadMethod != null) {
 			Class<?> params[] = indexedReadMethod.getParameterTypes();
 			if (params.length != 1) {
-				throw new IntrospectionException(
-						"bad indexed read method arg count");
+				throw new IntrospectionException("Bad indexed read method arg count: " + indexedReadMethod);
 			}
 			if (params[0] != Integer.TYPE) {
-				throw new IntrospectionException(
-						"non int index to indexed read method");
+				throw new IntrospectionException("Non int index to indexed read method: " + indexedReadMethod);
 			}
 			indexedPropertyType = indexedReadMethod.getReturnType();
 			if (indexedPropertyType == Void.TYPE) {
-				throw new IntrospectionException(
-						"indexed read method returns void");
+				throw new IntrospectionException("Indexed read method returns void: " + indexedReadMethod);
 			}
 		}
 		if (indexedWriteMethod != null) {
 			Class<?> params[] = indexedWriteMethod.getParameterTypes();
 			if (params.length != 2) {
-				throw new IntrospectionException(
-						"bad indexed write method arg count");
+				throw new IntrospectionException("Bad indexed write method arg count: " + indexedWriteMethod);
 			}
 			if (params[0] != Integer.TYPE) {
-				throw new IntrospectionException(
-						"non int index to indexed write method");
+				throw new IntrospectionException("Non int index to indexed write method: " + indexedWriteMethod);
 			}
-			if (indexedPropertyType != null && indexedPropertyType != params[1]) {
-				throw new IntrospectionException(
-						"type mismatch between indexed read and indexed write methods: " + name);
+			if (indexedPropertyType != null) {
+				if (indexedPropertyType.isAssignableFrom(params[1])) {
+					// Write method's property type potentially more specific
+					indexedPropertyType = params[1];
+				}
+				else if (params[1].isAssignableFrom(indexedPropertyType)) {
+					// Proceed with read method's property type
+				}
+				else {
+					throw new IntrospectionException("Type mismatch between indexed read and write methods: " +
+							indexedReadMethod + " - " + indexedWriteMethod);
+				}
+			}
+			else {
+				indexedPropertyType = params[1];
 			}
-			indexedPropertyType = params[1];
 		}
-		if (propertyType != null
-				&& (!propertyType.isArray() ||
-						propertyType.getComponentType() != indexedPropertyType)) {
-			throw new IntrospectionException(
-					"type mismatch between indexed and non-indexed methods: " + name);
+		if (propertyType != null && (!propertyType.isArray() ||
+				propertyType.getComponentType() != indexedPropertyType)) {
+			throw new IntrospectionException("Type mismatch between indexed and non-indexed methods: " +
+					indexedReadMethod + " - " + indexedWriteMethod);
 		}
 		return indexedPropertyType;
 	}
@@ -605,42 +605,35 @@ class PropertyDescriptorUtils {
 	 * return {@code true} if they are objects are equivalent, i.e. both are {@code
 	 * PropertyDescriptor}s whose read method, write method, property types, property
 	 * editor and flags are equivalent.
-	 *
 	 * @see PropertyDescriptor#equals(Object)
 	 */
-	public static boolean equals(PropertyDescriptor pd1, Object obj) {
-		if (pd1 == obj) {
+	public static boolean equals(PropertyDescriptor pd, Object other) {
+		if (pd == other) {
 			return true;
 		}
-		if (obj != null && obj instanceof PropertyDescriptor) {
-			PropertyDescriptor pd2 = (PropertyDescriptor) obj;
-			if (!compareMethods(pd1.getReadMethod(), pd2.getReadMethod())) {
-				return false;
-			}
-
-			if (!compareMethods(pd1.getWriteMethod(), pd2.getWriteMethod())) {
-				return false;
-			}
-
-			if (pd1.getPropertyType() == pd2.getPropertyType()
-					&& pd1.getPropertyEditorClass() == pd2.getPropertyEditorClass()
-					&& pd1.isBound() == pd2.isBound()
-					&& pd1.isConstrained() == pd2.isConstrained()) {
-				return true;
-			}
+		if (!(other instanceof PropertyDescriptor)) {
+			return false;
 		}
-		return false;
+		PropertyDescriptor otherPd = (PropertyDescriptor) other;
+		if (!compareMethods(pd.getReadMethod(), otherPd.getReadMethod())) {
+			return false;
+		}
+		if (!compareMethods(pd.getWriteMethod(), otherPd.getWriteMethod())) {
+			return false;
+		}
+		return (pd.getPropertyType() == otherPd.getPropertyType() &&
+				pd.getPropertyEditorClass() == otherPd.getPropertyEditorClass() &&
+				pd.isBound() == otherPd.isBound() && pd.isConstrained() == otherPd.isConstrained());
 	}

 	/*
-	 * see PropertyDescriptor#compareMethods
+	 * See PropertyDescriptor#compareMethods
 	 */
 	public static boolean compareMethods(Method a, Method b) {
 		if ((a == null) != (b == null)) {
 			return false;
 		}
-
-		if (a != null && b != null) {
+		if (a != null) {
 			if (!a.equals(b)) {
 				return false;
 			}
@@ -653,7 +646,6 @@ class PropertyDescriptorUtils {
 /**
 * Sorts PropertyDescriptor instances alpha-numerically to emulate the behavior of
 * {@link java.beans.BeanInfo#getPropertyDescriptors()}.
- *
 * @see ExtendedBeanInfo#propertyDescriptors
 */
 class PropertyDescriptorComparator implements Comparator<PropertyDescriptor> {
@@ -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.
@@ -25,8 +25,8 @@ import org.springframework.core.Ordered;

 /**
 * {@link BeanInfoFactory} implementation that evaluates whether bean classes have
- * "non-standard" JavaBeans setter methods and are thus candidates for introspection by
- * Spring's {@link ExtendedBeanInfo}.
+ * "non-standard" JavaBeans setter methods and are thus candidates for introspection
+ * by Spring's (package-visible) {@code ExtendedBeanInfo} implementation.
 *
 * <p>Ordered at {@link Ordered#LOWEST_PRECEDENCE} to allow other user-defined
 * {@link BeanInfoFactory} types to take precedence.
@@ -34,20 +34,20 @@ import org.springframework.core.Ordered;
 * @author Chris Beams
 * @since 3.2
 * @see BeanInfoFactory
+ * @see CachedIntrospectionResults
 */
-public class ExtendedBeanInfoFactory implements Ordered, BeanInfoFactory {
+public class ExtendedBeanInfoFactory implements BeanInfoFactory, Ordered {

 	/**
-	 * Return a new {@link ExtendedBeanInfo} for the given bean class.
+	 * Return an {@link ExtendedBeanInfo} for the given bean class, if applicable.
 	 */
 	public BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException {
-		return supports(beanClass) ?
-				new ExtendedBeanInfo(Introspector.getBeanInfo(beanClass)) : null;
+		return (supports(beanClass) ? new ExtendedBeanInfo(Introspector.getBeanInfo(beanClass)) : null);
 	}

 	/**
-	 * Return whether the given bean class declares or inherits any non-void returning
-	 * JavaBeans or <em>indexed property</em> setter methods.
+	 * Return whether the given bean class declares or inherits any non-void
+	 * returning bean property or indexed property setter methods.
 	 */
 	private boolean supports(Class<?> beanClass) {
 		for (Method method : beanClass.getMethods()) {
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -31,37 +31,40 @@ import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;

 /**
- * Extension of the standard JavaBeans PropertyDescriptor class,
- * overriding {@code getPropertyType()} such that a generically
- * declared type will be resolved against the containing bean class.
+ * Extension of the standard JavaBeans {@link PropertyDescriptor} class,
+ * overriding {@code getPropertyType()} such that a generically declared
+ * type variable will be resolved against the containing bean class.
 *
 * @author Juergen Hoeller
 * @since 2.5.2
 */
 class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {

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

 	private final Method readMethod;

 	private final Method writeMethod;

-	private final Class propertyEditorClass;
-
 	private volatile Set<Method> ambiguousWriteMethods;

-	private Class propertyType;
-
 	private MethodParameter writeMethodParameter;

+	private Class<?> propertyType;

-	public GenericTypeAwarePropertyDescriptor(Class beanClass, String propertyName,
-			Method readMethod, Method writeMethod, Class propertyEditorClass)
+	private final Class<?> propertyEditorClass;
+
+
+	public GenericTypeAwarePropertyDescriptor(Class<?> beanClass, String propertyName,
+			Method readMethod, Method writeMethod, Class<?> propertyEditorClass)
 			throws IntrospectionException {

 		super(propertyName, null, null);
+
+		if (beanClass == null)  {
+			throw new IntrospectionException("Bean class must not be null");
+		}
 		this.beanClass = beanClass;
-		this.propertyEditorClass = propertyEditorClass;

 		Method readMethodToUse = BridgeMethodResolver.findBridgedMethod(readMethod);
 		Method writeMethodToUse = BridgeMethodResolver.findBridgedMethod(writeMethod);
@@ -69,8 +72,11 @@ class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {
 			// Fallback: Original JavaBeans introspection might not have found matching setter
 			// method due to lack of bridge method resolution, in case of the getter using a
 			// covariant return type whereas the setter is defined for the concrete property type.
-			writeMethodToUse = ClassUtils.getMethodIfAvailable(this.beanClass,
-					"set" + StringUtils.capitalize(getName()), readMethodToUse.getReturnType());
+			Method candidate = ClassUtils.getMethodIfAvailable(
+					this.beanClass, "set" + StringUtils.capitalize(getName()), (Class<?>[]) null);
+			if (candidate != null && candidate.getParameterTypes().length == 1) {
+				writeMethodToUse = candidate;
+			}
 		}
 		this.readMethod = readMethodToUse;
 		this.writeMethod = writeMethodToUse;
@@ -82,7 +88,8 @@ class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {
 			Set<Method> ambiguousCandidates = new HashSet<Method>();
 			for (Method method : beanClass.getMethods()) {
 				if (method.getName().equals(writeMethodToUse.getName()) &&
-						!method.equals(writeMethodToUse) && !method.isBridge()) {
+						!method.equals(writeMethodToUse) && !method.isBridge() &&
+						method.getParameterTypes().length == writeMethodToUse.getParameterTypes().length) {
 					ambiguousCandidates.add(method);
 				}
 			}
@@ -90,8 +97,11 @@ class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {
 				this.ambiguousWriteMethods = ambiguousCandidates;
 			}
 		}
+
+		this.propertyEditorClass = propertyEditorClass;
 	}

+
 	public Class<?> getBeanClass() {
 		return this.beanClass;
 	}
@@ -117,13 +127,19 @@ class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {
 		return this.writeMethod;
 	}

-	@Override
-	public Class getPropertyEditorClass() {
-		return this.propertyEditorClass;
+	public synchronized MethodParameter getWriteMethodParameter() {
+		if (this.writeMethod == null) {
+			return null;
+		}
+		if (this.writeMethodParameter == null) {
+			this.writeMethodParameter = new MethodParameter(this.writeMethod, 0);
+			GenericTypeResolver.resolveParameterType(this.writeMethodParameter, this.beanClass);
+		}
+		return this.writeMethodParameter;
 	}

 	@Override
-	public synchronized Class getPropertyType() {
+	public synchronized Class<?> getPropertyType() {
 		if (this.propertyType == null) {
 			if (this.readMethod != null) {
 				this.propertyType = GenericTypeResolver.resolveReturnType(this.readMethod, this.beanClass);
@@ -141,15 +157,9 @@ class GenericTypeAwarePropertyDescriptor extends PropertyDescriptor {
 		return this.propertyType;
 	}

-	public synchronized MethodParameter getWriteMethodParameter() {
-		if (this.writeMethod == null) {
-			return null;
-		}
-		if (this.writeMethodParameter == null) {
-			this.writeMethodParameter = new MethodParameter(this.writeMethod, 0);
-			GenericTypeResolver.resolveParameterType(this.writeMethodParameter, this.beanClass);
-		}
-		return this.writeMethodParameter;
+	@Override
+	public Class<?> getPropertyEditorClass() {
+		return this.propertyEditorClass;
 	}

 }
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -86,7 +86,7 @@ public class MutablePropertyValues implements PropertyValues, Serializable {
 		// There is no replacement of existing property values.
 		if (original != null) {
 			this.propertyValueList = new ArrayList<PropertyValue>(original.size());
-			for (Map.Entry entry : original.entrySet()) {
+			for (Map.Entry<?, ?> entry : original.entrySet()) {
 				this.propertyValueList.add(new PropertyValue(entry.getKey().toString(), entry.getValue()));
 			}
 		}
@@ -303,6 +303,16 @@ public class MutablePropertyValues implements PropertyValues, Serializable {
 		this.processedProperties.add(propertyName);
 	}

+	/**
+	 * Clear the "processed" registration of the given property, if any.
+	 * @since 3.2.13
+	 */
+	public void clearProcessedProperty(String propertyName) {
+		if (this.processedProperties != null) {
+			this.processedProperties.remove(propertyName);
+		}
+	}
+
 	/**
 	 * Mark this holder as containing converted values only
 	 * (i.e. no runtime resolution needed anymore).
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -49,7 +49,7 @@ final class PropertyMatches {
 	 * @param propertyName the name of the property to find possible matches for
 	 * @param beanClass the bean class to search for matches
 	 */
-	public static PropertyMatches forProperty(String propertyName, Class beanClass) {
+	public static PropertyMatches forProperty(String propertyName, Class<?> beanClass) {
 		return forProperty(propertyName, beanClass, DEFAULT_MAX_DISTANCE);
 	}

@@ -59,7 +59,7 @@ final class PropertyMatches {
 	 * @param beanClass the bean class to search for matches
 	 * @param maxDistance the maximum property distance allowed for matches
 	 */
-	public static PropertyMatches forProperty(String propertyName, Class beanClass, int maxDistance) {
+	public static PropertyMatches forProperty(String propertyName, Class<?> beanClass, int maxDistance) {
 		return new PropertyMatches(propertyName, beanClass, maxDistance);
 	}

@@ -76,7 +76,7 @@ final class PropertyMatches {
 	/**
 	 * Create a new PropertyMatches instance for the given property.
 	 */
-	private PropertyMatches(String propertyName, Class beanClass, int maxDistance) {
+	private PropertyMatches(String propertyName, Class<?> beanClass, int maxDistance) {
 		this.propertyName = propertyName;
 		this.possibleMatches = calculateMatches(BeanUtils.getPropertyDescriptors(beanClass), maxDistance);
 	}
@@ -172,7 +172,8 @@ final class PropertyMatches {
 				char t_j = s2.charAt(j - 1);
 				if (s_i == t_j) {
 					cost = 0;
-				} else {
+				}
+				else {
 					cost = 1;
 				}
 				d[i][j] = Math.min(Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1),
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -187,6 +187,9 @@ class TypeConverterDelegate {
 			// Try to apply some standard type conversion rules if appropriate.

 			if (convertedValue != null) {
+				if (Object.class.equals(requiredType)) {
+					return (T) convertedValue;
+				}
 				if (requiredType.isArray()) {
 					// Array required -> apply appropriate conversion of elements.
 					if (convertedValue instanceof String && Enum.class.isAssignableFrom(requiredType.getComponentType())) {
@@ -197,13 +200,13 @@ class TypeConverterDelegate {
 				else if (convertedValue instanceof Collection) {
 					// Convert elements to target type, if determined.
 					convertedValue = convertToTypedCollection(
-							(Collection) convertedValue, propertyName, requiredType, typeDescriptor);
+							(Collection<?>) convertedValue, propertyName, requiredType, typeDescriptor);
 					standardConversion = true;
 				}
 				else if (convertedValue instanceof Map) {
 					// Convert keys and values to respective target type, if determined.
 					convertedValue = convertToTypedMap(
-							(Map) convertedValue, propertyName, requiredType, typeDescriptor);
+							(Map<?, ?>) convertedValue, propertyName, requiredType, typeDescriptor);
 					standardConversion = true;
 				}
 				if (convertedValue.getClass().isArray() && Array.getLength(convertedValue) == 1) {
@@ -217,8 +220,8 @@ class TypeConverterDelegate {
 				else if (convertedValue instanceof String && !requiredType.isInstance(convertedValue)) {
 					if (firstAttemptEx == null && !requiredType.isInterface() && !requiredType.isEnum()) {
 						try {
-							Constructor strCtor = requiredType.getConstructor(String.class);
-							return (T) BeanUtils.instantiateClass(strCtor, convertedValue);
+							Constructor<T> strCtor = requiredType.getConstructor(String.class);
+							return BeanUtils.instantiateClass(strCtor, convertedValue);
 						}
 						catch (NoSuchMethodException ex) {
 							// proceed with field lookup
@@ -286,19 +289,19 @@ class TypeConverterDelegate {
 			if (index > - 1) {
 				String enumType = trimmedValue.substring(0, index);
 				String fieldName = trimmedValue.substring(index + 1);
-				ClassLoader loader = this.targetObject.getClass().getClassLoader();
+				ClassLoader cl = this.targetObject.getClass().getClassLoader();
 				try {
-					Class<?> enumValueType = loader.loadClass(enumType);
+					Class<?> enumValueType = ClassUtils.forName(enumType, cl);
 					Field enumField = enumValueType.getField(fieldName);
 					convertedValue = enumField.get(null);
 				}
 				catch (ClassNotFoundException ex) {
-					if(logger.isTraceEnabled()) {
-						logger.trace("Enum class [" + enumType + "] cannot be loaded from [" + loader + "]", ex);
+					if (logger.isTraceEnabled()) {
+						logger.trace("Enum class [" + enumType + "] cannot be loaded", ex);
 					}
 				}
 				catch (Throwable ex) {
-					if(logger.isTraceEnabled()) {
+					if (logger.isTraceEnabled()) {
 						logger.trace("Field [" + fieldName + "] isn't an enum value for type [" + enumType + "]", ex);
 					}
 				}
@@ -328,7 +331,7 @@ class TypeConverterDelegate {
 	 * @param requiredType the type to find an editor for
 	 * @return the corresponding editor, or {@code null} if none
 	 */
-	private PropertyEditor findDefaultEditor(Class requiredType) {
+	private PropertyEditor findDefaultEditor(Class<?> requiredType) {
 		PropertyEditor editor = null;
 		if (requiredType != null) {
 			// No custom editor -> check BeanWrapperImpl's default editors.
@@ -456,10 +459,10 @@ class TypeConverterDelegate {
 	private Object convertToTypedArray(Object input, String propertyName, Class<?> componentType) {
 		if (input instanceof Collection) {
 			// Convert Collection elements to array elements.
-			Collection coll = (Collection) input;
+			Collection<?> coll = (Collection<?>) input;
 			Object result = Array.newInstance(componentType, coll.size());
 			int i = 0;
-			for (Iterator it = coll.iterator(); it.hasNext(); i++) {
+			for (Iterator<?> it = coll.iterator(); it.hasNext(); i++) {
 				Object value = convertIfNecessary(
 						buildIndexedPropertyName(propertyName, i), null, it.next(), componentType);
 				Array.set(result, i, value);
@@ -492,8 +495,8 @@ class TypeConverterDelegate {
 	}

 	@SuppressWarnings("unchecked")
-	private Collection convertToTypedCollection(
-			Collection original, String propertyName, Class requiredType, TypeDescriptor typeDescriptor) {
+	private Collection<?> convertToTypedCollection(
+			Collection<?> original, String propertyName, Class<?> requiredType, TypeDescriptor typeDescriptor) {

 		if (!Collection.class.isAssignableFrom(requiredType)) {
 			return original;
@@ -516,7 +519,7 @@ class TypeConverterDelegate {
 			return original;
 		}

-		Iterator it;
+		Iterator<?> it;
 		try {
 			it = original.iterator();
 			if (it == null) {
@@ -535,13 +538,13 @@ class TypeConverterDelegate {
 			return original;
 		}

-		Collection convertedCopy;
+		Collection<Object> convertedCopy;
 		try {
 			if (approximable) {
 				convertedCopy = CollectionFactory.createApproximateCollection(original, original.size());
 			}
 			else {
-				convertedCopy = (Collection) requiredType.newInstance();
+				convertedCopy = (Collection<Object>) requiredType.newInstance();
 			}
 		}
 		catch (Throwable ex) {
@@ -574,8 +577,8 @@ class TypeConverterDelegate {
 	}

 	@SuppressWarnings("unchecked")
-	private Map convertToTypedMap(
-			Map original, String propertyName, Class requiredType, TypeDescriptor typeDescriptor) {
+	private Map<?, ?> convertToTypedMap(
+			Map<?, ?> original, String propertyName, Class<?> requiredType, TypeDescriptor typeDescriptor) {

 		if (!Map.class.isAssignableFrom(requiredType)) {
 			return original;
@@ -599,7 +602,7 @@ class TypeConverterDelegate {
 			return original;
 		}

-		Iterator it;
+		Iterator<?> it;
 		try {
 			it = original.entrySet().iterator();
 			if (it == null) {
@@ -618,13 +621,13 @@ class TypeConverterDelegate {
 			return original;
 		}

-		Map convertedCopy;
+		Map<Object, Object> convertedCopy;
 		try {
 			if (approximable) {
 				convertedCopy = CollectionFactory.createApproximateMap(original, original.size());
 			}
 			else {
-				convertedCopy = (Map) requiredType.newInstance();
+				convertedCopy = (Map<Object, Object>) requiredType.newInstance();
 			}
 		}
 		catch (Throwable ex) {
@@ -636,7 +639,7 @@ class TypeConverterDelegate {
 		}

 		while (it.hasNext()) {
-			Map.Entry entry = (Map.Entry) it.next();
+			Map.Entry<?, ?> entry = (Map.Entry<?, ?>) it.next();
 			Object key = entry.getKey();
 			Object value = entry.getValue();
 			String keyedPropertyName = buildKeyedPropertyName(propertyName, key);
@@ -671,7 +674,7 @@ class TypeConverterDelegate {
 				null);
 	}

-	private boolean canCreateCopy(Class requiredType) {
+	private boolean canCreateCopy(Class<?> requiredType) {
 		return (!requiredType.isInterface() && !Modifier.isAbstract(requiredType.getModifiers()) &&
 				Modifier.isPublic(requiredType.getModifiers()) && ClassUtils.hasConstructor(requiredType));
 	}
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -170,8 +170,7 @@ public interface BeanFactory {
 	 * <p>Allows for specifying explicit constructor arguments / factory method arguments,
 	 * overriding the specified default arguments (if any) in the bean definition.
 	 * @param name the name of the bean to retrieve
-	 * @param args arguments to use if creating a prototype using explicit arguments to a
-	 * static factory method. It is invalid to use a non-null args value in any other case.
+	 * @param args arguments to use if creating a prototype using explicit arguments
 	 * @return an instance of the bean
 	 * @throws NoSuchBeanDefinitionException if there is no such bean definition
 	 * @throws BeanDefinitionStoreException if arguments have been given but
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2015 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@

 package org.springframework.beans.factory;

-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
@@ -139,7 +138,7 @@ public abstract class BeanFactoryUtils {
 	 * @param type the type that beans must match
 	 * @return the array of matching bean names, or an empty array if none
 	 */
-	public static String[] beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, Class type) {
+	public static String[] beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, Class<?> type) {
 		Assert.notNull(lbf, "ListableBeanFactory must not be null");
 		String[] result = lbf.getBeanNamesForType(type);
 		if (lbf instanceof HierarchicalBeanFactory) {
@@ -181,7 +180,7 @@ public abstract class BeanFactoryUtils {
 	 * @return the array of matching bean names, or an empty array if none
 	 */
 	public static String[] beanNamesForTypeIncludingAncestors(
-			ListableBeanFactory lbf, Class type, boolean includeNonSingletons, boolean allowEagerInit) {
+			ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {

 		Assert.notNull(lbf, "ListableBeanFactory must not be null");
 		String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 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.
@@ -20,21 +20,23 @@ import org.springframework.beans.BeansException;
 import org.springframework.util.StringUtils;

 /**
- * Exception thrown when a {@code BeanFactory} is asked for a bean instance
- * for which it cannot find a definition.
+ * Exception thrown when a {@code BeanFactory} is asked for a bean instance for which it
+ * cannot find a definition. This may point to a non-existing bean, a non-unique bean,
+ * or a manually registered singleton instance without an associated bean definition.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @see BeanFactory#getBean(String)
 * @see BeanFactory#getBean(Class)
+ * @see NoUniqueBeanDefinitionException
 */
@SuppressWarnings("serial")
 public class NoSuchBeanDefinitionException extends BeansException {

-	/** Name of the missing bean. */
+	/** Name of the missing bean */
 	private String beanName;

-	/** Required type of the missing bean. */
+	/** Required type of the missing bean */
 	private Class<?> beanType;


@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -18,7 +18,6 @@ package org.springframework.beans.factory.access.el;

 import java.beans.FeatureDescriptor;
 import java.util.Iterator;
-
 import javax.el.ELContext;
 import javax.el.ELException;
 import javax.el.ELResolver;
@@ -78,8 +77,14 @@ public abstract class SpringBeanELResolver extends ELResolver {
 			String beanName = property.toString();
 			BeanFactory bf = getBeanFactory(elContext);
 			if (bf.containsBean(beanName)) {
-				throw new PropertyNotWritableException(
-						"Variable '" + beanName + "' refers to a Spring bean which by definition is not writable");
+				if (value == bf.getBean(beanName)) {
+					// Setting the bean reference to the same value is alright - can simply be ignored...
+					elContext.setPropertyResolved(true);
+				}
+				else {
+					throw new PropertyNotWritableException(
+							"Variable '" + beanName + "' refers to a Spring bean which by definition is not writable");
+				}
 			}
 		}
 	}
@@ -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.
@@ -58,15 +58,19 @@ public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implem
 	 * allowing for ASM-based processing and avoidance of early loading of the bean class.
 	 * Note that this constructor is functionally equivalent to
 	 * {@link org.springframework.context.annotation.ScannedGenericBeanDefinition
-	 * ScannedGenericBeanDefinition}, however the semantics of the latter indicate that
-	 * a bean was discovered specifically via component-scanning as opposed to other
-	 * means.
+	 * ScannedGenericBeanDefinition}, however the semantics of the latter indicate that a
+	 * bean was discovered specifically via component-scanning as opposed to other means.
 	 * @param metadata the annotation metadata for the bean class in question
 	 * @since 3.1.1
 	 */
 	public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata) {
 		Assert.notNull(metadata, "AnnotationMetadata must not be null");
-		setBeanClassName(metadata.getClassName());
+		if (metadata instanceof StandardAnnotationMetadata) {
+			setBeanClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
+		}
+		else {
+			setBeanClassName(metadata.getClassName());
+		}
 		this.metadata = metadata;
 	}

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -59,6 +59,7 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
+import org.springframework.util.StringUtils;

 /**
 * {@link org.springframework.beans.factory.config.BeanPostProcessor} implementation
@@ -121,8 +122,8 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	private final Map<Class<?>, Constructor<?>[]> candidateConstructorsCache =
 			new ConcurrentHashMap<Class<?>, Constructor<?>[]>(64);

-	private final Map<Class<?>, InjectionMetadata> injectionMetadataCache =
-			new ConcurrentHashMap<Class<?>, InjectionMetadata>(64);
+	private final Map<String, InjectionMetadata> injectionMetadataCache =
+			new ConcurrentHashMap<String, InjectionMetadata>(64);


 	/**
@@ -134,9 +135,9 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	public AutowiredAnnotationBeanPostProcessor() {
 		this.autowiredAnnotationTypes.add(Autowired.class);
 		this.autowiredAnnotationTypes.add(Value.class);
-		ClassLoader cl = AutowiredAnnotationBeanPostProcessor.class.getClassLoader();
 		try {
-			this.autowiredAnnotationTypes.add((Class<? extends Annotation>) cl.loadClass("javax.inject.Inject"));
+			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
+					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
 			logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
 		}
 		catch (ClassNotFoundException ex) {
@@ -214,7 +215,7 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean

 	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
 		if (beanType != null) {
-			InjectionMetadata metadata = findAutowiringMetadata(beanType);
+			InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
 			metadata.checkConfigMembers(beanDefinition);
 		}
 	}
@@ -232,24 +233,25 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 					Constructor<?> requiredConstructor = null;
 					Constructor<?> defaultConstructor = null;
 					for (Constructor<?> candidate : rawCandidates) {
-						Annotation annotation = findAutowiredAnnotation(candidate);
-						if (annotation != null) {
+						Annotation ann = findAutowiredAnnotation(candidate);
+						if (ann != null) {
 							if (requiredConstructor != null) {
-								throw new BeanCreationException("Invalid autowire-marked constructor: " + candidate +
-										". Found another constructor with 'required' Autowired annotation: " +
+								throw new BeanCreationException(beanName,
+										"Invalid autowire-marked constructor: " + candidate +
+										". Found constructor with 'required' Autowired annotation already: " +
 										requiredConstructor);
 							}
 							if (candidate.getParameterTypes().length == 0) {
 								throw new IllegalStateException(
 										"Autowired annotation requires at least one argument: " + candidate);
 							}
-							boolean required = determineRequiredStatus(annotation);
+							boolean required = determineRequiredStatus(ann);
 							if (required) {
 								if (!candidates.isEmpty()) {
-									throw new BeanCreationException(
+									throw new BeanCreationException(beanName,
 											"Invalid autowire-marked constructors: " + candidates +
-											". Found another constructor with 'required' Autowired annotation: " +
-											requiredConstructor);
+											". Found constructor with 'required' Autowired annotation: " +
+											candidate);
 								}
 								requiredConstructor = candidate;
 							}
@@ -261,13 +263,21 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 					}
 					if (!candidates.isEmpty()) {
 						// Add default constructor to list of optional constructors, as fallback.
-						if (requiredConstructor == null && defaultConstructor != null) {
-							candidates.add(defaultConstructor);
+						if (requiredConstructor == null) {
+							if (defaultConstructor != null) {
+								candidates.add(defaultConstructor);
+							}
+							else if (candidates.size() == 1 && logger.isWarnEnabled()) {
+								logger.warn("Inconsistent constructor declaration on bean with name '" + beanName +
+										"': single autowire-marked constructor flagged as optional - this constructor " +
+										"is effectively required since there is no default constructor to fall back to: " +
+										candidates.get(0));
+							}
 						}
-						candidateConstructors = candidates.toArray(new Constructor[candidates.size()]);
+						candidateConstructors = candidates.toArray(new Constructor<?>[candidates.size()]);
 					}
 					else {
-						candidateConstructors = new Constructor[0];
+						candidateConstructors = new Constructor<?>[0];
 					}
 					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
 				}
@@ -280,7 +290,7 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	public PropertyValues postProcessPropertyValues(
 			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

-		InjectionMetadata metadata = findAutowiringMetadata(bean.getClass());
+		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
 		try {
 			metadata.inject(bean, beanName, pvs);
 		}
@@ -298,7 +308,7 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	 */
 	public void processInjection(Object bean) throws BeansException {
 		Class<?> clazz = bean.getClass();
-		InjectionMetadata metadata = findAutowiringMetadata(clazz);
+		InjectionMetadata metadata = findAutowiringMetadata(clazz.getName(), clazz, null);
 		try {
 			metadata.inject(bean, null, null);
 		}
@@ -308,15 +318,20 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	}


-	private InjectionMetadata findAutowiringMetadata(Class<?> clazz) {
+	private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
+		// Fall back to class name as cache key, for backwards compatibility with custom callers.
+		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
 		// Quick check on the concurrent map first, with minimal locking.
-		InjectionMetadata metadata = this.injectionMetadataCache.get(clazz);
-		if (metadata == null) {
+		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
+		if (InjectionMetadata.needsRefresh(metadata, clazz)) {
 			synchronized (this.injectionMetadataCache) {
-				metadata = this.injectionMetadataCache.get(clazz);
-				if (metadata == null) {
+				metadata = this.injectionMetadataCache.get(cacheKey);
+				if (InjectionMetadata.needsRefresh(metadata, clazz)) {
+					if (metadata != null) {
+						metadata.clear(pvs);
+					}
 					metadata = buildAutowiringMetadata(clazz);
-					this.injectionMetadataCache.put(clazz, metadata);
+					this.injectionMetadataCache.put(cacheKey, metadata);
 				}
 			}
 		}
@@ -330,23 +345,25 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 		do {
 			LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<InjectionMetadata.InjectedElement>();
 			for (Field field : targetClass.getDeclaredFields()) {
-				Annotation annotation = findAutowiredAnnotation(field);
-				if (annotation != null) {
+				Annotation ann = findAutowiredAnnotation(field);
+				if (ann != null) {
 					if (Modifier.isStatic(field.getModifiers())) {
 						if (logger.isWarnEnabled()) {
 							logger.warn("Autowired annotation is not supported on static fields: " + field);
 						}
 						continue;
 					}
-					boolean required = determineRequiredStatus(annotation);
+					boolean required = determineRequiredStatus(ann);
 					currElements.add(new AutowiredFieldElement(field, required));
 				}
 			}
 			for (Method method : targetClass.getDeclaredMethods()) {
+				Annotation ann = null;
 				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
-				Annotation annotation = BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod) ?
-						findAutowiredAnnotation(bridgedMethod) : findAutowiredAnnotation(method);
-				if (annotation != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
+				if (BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
+					ann = findAutowiredAnnotation(bridgedMethod);
+				}
+				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
 					if (Modifier.isStatic(method.getModifiers())) {
 						if (logger.isWarnEnabled()) {
 							logger.warn("Autowired annotation is not supported on static methods: " + method);
@@ -358,8 +375,8 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 							logger.warn("Autowired annotation should be used on methods with actual parameters: " + method);
 						}
 					}
-					boolean required = determineRequiredStatus(annotation);
-					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method);
+					boolean required = determineRequiredStatus(ann);
+					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
 					currElements.add(new AutowiredMethodElement(method, required, pd));
 				}
 			}
@@ -373,9 +390,9 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean

 	private Annotation findAutowiredAnnotation(AccessibleObject ao) {
 		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
-			Annotation annotation = AnnotationUtils.getAnnotation(ao, type);
-			if (annotation != null) {
-				return annotation;
+			Annotation ann = AnnotationUtils.getAnnotation(ao, type);
+			if (ann != null) {
+				return ann;
 			}
 		}
 		return null;
@@ -400,21 +417,21 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 	 * <p>A 'required' dependency means that autowiring should fail when no beans
 	 * are found. Otherwise, the autowiring process will simply bypass the field
 	 * or method when no beans are found.
-	 * @param annotation the Autowired annotation
+	 * @param ann the Autowired annotation
 	 * @return whether the annotation indicates that a dependency is required
 	 */
-	protected boolean determineRequiredStatus(Annotation annotation) {
+	protected boolean determineRequiredStatus(Annotation ann) {
 		try {
-			Method method = ReflectionUtils.findMethod(annotation.annotationType(), this.requiredParameterName);
+			Method method = ReflectionUtils.findMethod(ann.annotationType(), this.requiredParameterName);
 			if (method == null) {
-				// annotations like @Inject and @Value don't have a method (attribute) named "required"
+				// Annotations like @Inject and @Value don't have a method (attribute) named "required"
 				// -> default to required status
 				return true;
 			}
-			return (this.requiredParameterValue == (Boolean) ReflectionUtils.invokeMethod(method, annotation));
+			return (this.requiredParameterValue == (Boolean) ReflectionUtils.invokeMethod(method, ann));
 		}
 		catch (Exception ex) {
-			// an exception was thrown during reflective invocation of the required attribute
+			// An exception was thrown during reflective invocation of the required attribute
 			// -> default to required status
 			return true;
 		}
@@ -480,14 +497,14 @@ public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBean
 					value = resolvedCachedArgument(beanName, this.cachedFieldValue);
 				}
 				else {
-					DependencyDescriptor descriptor = new DependencyDescriptor(field, this.required);
+					DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
 					Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
 					TypeConverter typeConverter = beanFactory.getTypeConverter();
-					value = beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter);
+					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
 					synchronized (this) {
 						if (!this.cached) {
 							if (value != null || this.required) {
-								this.cachedFieldValue = descriptor;
+								this.cachedFieldValue = desc;
 								registerDependentBeans(beanName, autowiredBeanNames);
 								if (autowiredBeanNames.size() == 1) {
 									String autowiredBeanName = autowiredBeanNames.iterator().next();
@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 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.
@@ -17,7 +17,6 @@
 package org.springframework.beans.factory.annotation;

 import java.lang.reflect.Method;
-import java.util.Map;

 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryUtils;
@@ -34,6 +33,7 @@ import org.springframework.util.ObjectUtils;
 * Spring's {@link Qualifier @Qualifier} annotation.
 *
 * @author Chris Beams
+ * @author Juergen Hoeller
 * @since 3.1.2
 * @see BeanFactoryUtils
 */
@@ -76,23 +76,27 @@ public class BeanFactoryAnnotationUtils {
 	 * @throws NoSuchBeanDefinitionException if no matching bean of type {@code T} found
 	 */
 	private static <T> T qualifiedBeanOfType(ConfigurableListableBeanFactory bf, Class<T> beanType, String qualifier) {
-		Map<String, T> candidateBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(bf, beanType);
-		T matchingBean = null;
-		for (String beanName : candidateBeans.keySet()) {
+		String[] candidateBeans = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(bf, beanType);
+		String matchingBean = null;
+		for (String beanName : candidateBeans) {
 			if (isQualifierMatch(qualifier, beanName, bf)) {
 				if (matchingBean != null) {
 					throw new NoSuchBeanDefinitionException(qualifier, "No unique " + beanType.getSimpleName() +
 							" bean found for qualifier '" + qualifier + "'");
 				}
-				matchingBean = candidateBeans.get(beanName);
+				matchingBean = beanName;
 			}
 		}
 		if (matchingBean != null) {
-			return matchingBean;
+			return bf.getBean(matchingBean, beanType);
+		}
+		else if (bf.containsBean(qualifier)) {
+			// Fallback: target bean at least found by bean name - probably a manually registered singleton.
+			return bf.getBean(qualifier, beanType);
 		}
 		else {
 			throw new NoSuchBeanDefinitionException(qualifier, "No matching " + beanType.getSimpleName() +
-					" bean found for qualifier '" + qualifier + "' - neither qualifier " + "match nor bean name match!");
+					" bean found for qualifier '" + qualifier + "' - neither qualifier match nor bean name match!");
 		}
 	}

@@ -128,7 +132,7 @@ public class BeanFactoryAnnotationUtils {
 				}
 			}
 			catch (NoSuchBeanDefinitionException ex) {
-				// ignore - can't compare qualifiers for a manually registered singleton object
+				// Ignore - can't compare qualifiers for a manually registered singleton object
 			}
 		}
 		return false;
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -46,20 +46,21 @@ import org.springframework.util.ReflectionUtils;
 */
 public class InjectionMetadata {

-	private final Log logger = LogFactory.getLog(InjectionMetadata.class);
+	private static final Log logger = LogFactory.getLog(InjectionMetadata.class);

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

 	private final Collection<InjectedElement> injectedElements;

 	private volatile Set<InjectedElement> checkedElements;


-	public InjectionMetadata(Class targetClass, Collection<InjectedElement> elements) {
+	public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
 		this.targetClass = targetClass;
 		this.injectedElements = elements;
 	}

+
 	public void checkConfigMembers(RootBeanDefinition beanDefinition) {
 		Set<InjectedElement> checkedElements = new LinkedHashSet<InjectedElement>(this.injectedElements.size());
 		for (InjectedElement element : this.injectedElements) {
@@ -82,13 +83,31 @@ public class InjectionMetadata {
 			boolean debug = logger.isDebugEnabled();
 			for (InjectedElement element : elementsToIterate) {
 				if (debug) {
-					logger.debug("Processing injected method of bean '" + beanName + "': " + element);
+					logger.debug("Processing injected element of bean '" + beanName + "': " + element);
 				}
 				element.inject(target, beanName, pvs);
 			}
 		}
 	}

+	/**
+	 * @since 3.2.13
+	 */
+	public void clear(PropertyValues pvs) {
+		Collection<InjectedElement> elementsToIterate =
+				(this.checkedElements != null ? this.checkedElements : this.injectedElements);
+		if (!elementsToIterate.isEmpty()) {
+			for (InjectedElement element : elementsToIterate) {
+				element.clearPropertySkipping(pvs);
+			}
+		}
+	}
+
+
+	public static boolean needsRefresh(InjectionMetadata metadata, Class<?> clazz) {
+		return (metadata == null || !metadata.targetClass.equals(clazz));
+	}
+

 	public static abstract class InjectedElement {

@@ -110,7 +129,7 @@ public class InjectionMetadata {
 			return this.member;
 		}

-		protected final Class getResourceType() {
+		protected final Class<?> getResourceType() {
 			if (this.isField) {
 				return ((Field) this.member).getType();
 			}
@@ -122,16 +141,16 @@ public class InjectionMetadata {
 			}
 		}

-		protected final void checkResourceType(Class resourceType) {
+		protected final void checkResourceType(Class<?> resourceType) {
 			if (this.isField) {
-				Class fieldType = ((Field) this.member).getType();
+				Class<?> fieldType = ((Field) this.member).getType();
 				if (!(resourceType.isAssignableFrom(fieldType) || fieldType.isAssignableFrom(resourceType))) {
 					throw new IllegalStateException("Specified field type [" + fieldType +
 							"] is incompatible with resource type [" + resourceType.getName() + "]");
 				}
 			}
 			else {
-				Class paramType =
+				Class<?> paramType =
 						(this.pd != null ? this.pd.getPropertyType() : ((Method) this.member).getParameterTypes()[0]);
 				if (!(resourceType.isAssignableFrom(paramType) || paramType.isAssignableFrom(resourceType))) {
 					throw new IllegalStateException("Specified parameter type [" + paramType +
@@ -165,7 +184,7 @@ public class InjectionMetadata {
 		}

 		/**
-		 * Checks whether this injector's property needs to be skipped due to
+		 * Check whether this injector's property needs to be skipped due to
 		 * an explicit property value having been specified. Also marks the
 		 * affected property as processed for other processors to ignore it.
 		 */
@@ -196,6 +215,20 @@ public class InjectionMetadata {
 			}
 		}

+		/**
+		 * @since 3.2.13
+		 */
+		protected void clearPropertySkipping(PropertyValues pvs) {
+			if (pvs == null) {
+				return;
+			}
+			synchronized (pvs) {
+				if (Boolean.FALSE.equals(this.skip) && this.pd != null && pvs instanceof MutablePropertyValues) {
+					((MutablePropertyValues) pvs).clearProcessedProperty(this.pd.getName());
+				}
+			}
+		}
+
 		/**
 		 * Either this or {@link #inject} needs to be overridden.
 		 */
@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -26,7 +26,10 @@ import org.springframework.beans.SimpleTypeConverter;
 import org.springframework.beans.TypeConverter;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 import org.springframework.beans.factory.config.DependencyDescriptor;
 import org.springframework.beans.factory.support.AutowireCandidateQualifier;
 import org.springframework.beans.factory.support.AutowireCandidateResolver;
@@ -69,9 +72,9 @@ public class QualifierAnnotationAutowireCandidateResolver implements AutowireCan
 	@SuppressWarnings("unchecked")
 	public QualifierAnnotationAutowireCandidateResolver() {
 		this.qualifierTypes.add(Qualifier.class);
-		ClassLoader cl = QualifierAnnotationAutowireCandidateResolver.class.getClassLoader();
 		try {
-			this.qualifierTypes.add((Class<? extends Annotation>) cl.loadClass("javax.inject.Qualifier"));
+			this.qualifierTypes.add((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Qualifier",
+							QualifierAnnotationAutowireCandidateResolver.class.getClassLoader()));
 		}
 		catch (ClassNotFoundException ex) {
 			// JSR-330 API not available - simply skip.
@@ -227,21 +230,31 @@ public class QualifierAnnotationAutowireCandidateResolver implements AutowireCan

 		Class<? extends Annotation> type = annotation.annotationType();
 		RootBeanDefinition bd = (RootBeanDefinition) bdHolder.getBeanDefinition();
+
 		AutowireCandidateQualifier qualifier = bd.getQualifier(type.getName());
 		if (qualifier == null) {
 			qualifier = bd.getQualifier(ClassUtils.getShortName(type));
 		}
 		if (qualifier == null) {
-			Annotation targetAnnotation = null;
-			if (bd.getResolvedFactoryMethod() != null) {
-				targetAnnotation = AnnotationUtils.getAnnotation(bd.getResolvedFactoryMethod(), type);
+			// First, check annotation on factory method, if applicable
+			Annotation targetAnnotation = getFactoryMethodAnnotation(bd, type);
+			if (targetAnnotation == null) {
+				RootBeanDefinition dbd = getResolvedDecoratedDefinition(bd);
+				if (dbd != null) {
+					targetAnnotation = getFactoryMethodAnnotation(dbd, type);
+				}
 			}
 			if (targetAnnotation == null) {
-				// look for matching annotation on the target class
+				// Look for matching annotation on the target class
 				if (this.beanFactory != null) {
-					Class<?> beanType = this.beanFactory.getType(bdHolder.getBeanName());
-					if (beanType != null) {
-						targetAnnotation = AnnotationUtils.getAnnotation(ClassUtils.getUserClass(beanType), type);
+					try {
+						Class<?> beanType = this.beanFactory.getType(bdHolder.getBeanName());
+						if (beanType != null) {
+							targetAnnotation = AnnotationUtils.getAnnotation(ClassUtils.getUserClass(beanType), type);
+						}
+					}
+					catch (NoSuchBeanDefinitionException ex) {
+						// Not the usual case - simply forget about the type check...
 					}
 				}
 				if (targetAnnotation == null && bd.hasBeanClass()) {
@@ -252,30 +265,31 @@ public class QualifierAnnotationAutowireCandidateResolver implements AutowireCan
 				return true;
 			}
 		}
+
 		Map<String, Object> attributes = AnnotationUtils.getAnnotationAttributes(annotation);
 		if (attributes.isEmpty() && qualifier == null) {
-			// if no attributes, the qualifier must be present
+			// If no attributes, the qualifier must be present
 			return false;
 		}
 		for (Map.Entry<String, Object> entry : attributes.entrySet()) {
 			String attributeName = entry.getKey();
 			Object expectedValue = entry.getValue();
 			Object actualValue = null;
-			// check qualifier first
+			// Check qualifier first
 			if (qualifier != null) {
 				actualValue = qualifier.getAttribute(attributeName);
 			}
 			if (actualValue == null) {
-				// fall back on bean definition attribute
+				// Fall back on bean definition attribute
 				actualValue = bd.getAttribute(attributeName);
 			}
 			if (actualValue == null && attributeName.equals(AutowireCandidateQualifier.VALUE_KEY) &&
 					expectedValue instanceof String && bdHolder.matchesName((String) expectedValue)) {
-				// fall back on bean name (or alias) match
+				// Fall back on bean name (or alias) match
 				continue;
 			}
 			if (actualValue == null && qualifier != null) {
-				// fall back on default, but only if the qualifier is present
+				// Fall back on default, but only if the qualifier is present
 				actualValue = AnnotationUtils.getDefaultValue(annotation, attributeName);
 			}
 			if (actualValue != null) {
@@ -288,6 +302,25 @@ public class QualifierAnnotationAutowireCandidateResolver implements AutowireCan
 		return true;
 	}

+	protected RootBeanDefinition getResolvedDecoratedDefinition(RootBeanDefinition rbd) {
+		BeanDefinitionHolder decDef = rbd.getDecoratedDefinition();
+		if (decDef != null && this.beanFactory instanceof ConfigurableListableBeanFactory) {
+			ConfigurableListableBeanFactory clbf = (ConfigurableListableBeanFactory) this.beanFactory;
+			if (clbf.containsBeanDefinition(decDef.getBeanName())) {
+				BeanDefinition dbd = clbf.getMergedBeanDefinition(decDef.getBeanName());
+				if (dbd instanceof RootBeanDefinition) {
+					return (RootBeanDefinition) dbd;
+				}
+			}
+		}
+		return null;
+	}
+
+	protected Annotation getFactoryMethodAnnotation(RootBeanDefinition bd, Class<? extends Annotation> type) {
+		Method resolvedFactoryMethod = bd.getResolvedFactoryMethod();
+		return (resolvedFactoryMethod != null ? AnnotationUtils.getAnnotation(resolvedFactoryMethod, type) : null);
+	}
+

 	/**
 	 * Determine whether the given dependency carries a value annotation.
@@ -185,7 +185,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	 * @see #AUTOWIRE_BY_TYPE
 	 * @see #AUTOWIRE_CONSTRUCTOR
 	 */
-	Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
+	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

 	/**
 	 * Instantiate a new bean instance of the given class with the specified autowire
@@ -213,7 +213,7 @@ public interface AutowireCapableBeanFactory extends BeanFactory {
 	 * @see #applyBeanPostProcessorsBeforeInitialization
 	 * @see #applyBeanPostProcessorsAfterInitialization
 	 */
-	Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
+	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

 	/**
 	 * Autowire the bean properties of the given bean instance by name or type.
@@ -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.
@@ -146,7 +146,7 @@ public class ConstructorArgumentValues {
 	 * untyped values only)
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getIndexedArgumentValue(int index, Class requiredType) {
+	public ValueHolder getIndexedArgumentValue(int index, Class<?> requiredType) {
 		return getIndexedArgumentValue(index, requiredType, null);
 	}

@@ -159,7 +159,7 @@ public class ConstructorArgumentValues {
 	 * unnamed values only)
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getIndexedArgumentValue(int index, Class requiredType, String requiredName) {
+	public ValueHolder getIndexedArgumentValue(int index, Class<?> requiredType, String requiredName) {
 		Assert.isTrue(index >= 0, "Index must not be negative");
 		ValueHolder valueHolder = this.indexedArgumentValues.get(index);
 		if (valueHolder != null &&
@@ -247,7 +247,7 @@ public class ConstructorArgumentValues {
 	 * @param requiredType the type to match
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getGenericArgumentValue(Class requiredType) {
+	public ValueHolder getGenericArgumentValue(Class<?> requiredType) {
 		return getGenericArgumentValue(requiredType, null, null);
 	}

@@ -257,7 +257,7 @@ public class ConstructorArgumentValues {
 	 * @param requiredName the name to match
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getGenericArgumentValue(Class requiredType, String requiredName) {
+	public ValueHolder getGenericArgumentValue(Class<?> requiredType, String requiredName) {
 		return getGenericArgumentValue(requiredType, requiredName, null);
 	}

@@ -273,7 +273,7 @@ public class ConstructorArgumentValues {
 	 * in the current resolution process and should therefore not be returned again
 	 * @return the ValueHolder for the argument, or {@code null} if none found
 	 */
-	public ValueHolder getGenericArgumentValue(Class requiredType, String requiredName, Set<ValueHolder> usedValueHolders) {
+	public ValueHolder getGenericArgumentValue(Class<?> requiredType, String requiredName, Set<ValueHolder> usedValueHolders) {
 		for (ValueHolder valueHolder : this.genericArgumentValues) {
 			if (usedValueHolders != null && usedValueHolders.contains(valueHolder)) {
 				continue;
@@ -309,10 +309,10 @@ public class ConstructorArgumentValues {
 	 * Look for an argument value that either corresponds to the given index
 	 * in the constructor argument list or generically matches by type.
 	 * @param index the index in the constructor argument list
-	 * @param requiredType the type to match
+	 * @param requiredType the parameter type to match
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getArgumentValue(int index, Class requiredType) {
+	public ValueHolder getArgumentValue(int index, Class<?> requiredType) {
 		return getArgumentValue(index, requiredType, null, null);
 	}

@@ -320,11 +320,11 @@ public class ConstructorArgumentValues {
 	 * Look for an argument value that either corresponds to the given index
 	 * in the constructor argument list or generically matches by type.
 	 * @param index the index in the constructor argument list
-	 * @param requiredType the type to match
-	 * @param requiredName the name to match
+	 * @param requiredType the parameter type to match
+	 * @param requiredName the parameter name to match
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getArgumentValue(int index, Class requiredType, String requiredName) {
+	public ValueHolder getArgumentValue(int index, Class<?> requiredType, String requiredName) {
 		return getArgumentValue(index, requiredType, requiredName, null);
 	}

@@ -332,15 +332,17 @@ public class ConstructorArgumentValues {
 	 * Look for an argument value that either corresponds to the given index
 	 * in the constructor argument list or generically matches by type.
 	 * @param index the index in the constructor argument list
-	 * @param requiredType the type to match (can be {@code null} to find
-	 * an untyped argument value)
+	 * @param requiredType the parameter type to match (can be {@code null}
+	 * to find an untyped argument value)
+	 * @param requiredName the parameter name to match (can be {@code null}
+	 * to find an unnamed argument value)
 	 * @param usedValueHolders a Set of ValueHolder objects that have already
 	 * been used in the current resolution process and should therefore not
 	 * be returned again (allowing to return the next generic argument match
 	 * in case of multiple generic argument values of the same type)
 	 * @return the ValueHolder for the argument, or {@code null} if none set
 	 */
-	public ValueHolder getArgumentValue(int index, Class requiredType, String requiredName, Set<ValueHolder> usedValueHolders) {
+	public ValueHolder getArgumentValue(int index, Class<?> requiredType, String requiredName, Set<ValueHolder> usedValueHolders) {
 		Assert.isTrue(index >= 0, "Index must not be negative");
 		ValueHolder valueHolder = getIndexedArgumentValue(index, requiredType, requiredName);
 		if (valueHolder == null) {
@@ -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.
@@ -44,7 +44,7 @@ public class DependencyDescriptor implements Serializable {

 	private transient Field field;

-	private Class declaringClass;
+	private Class<?> declaringClass;

 	private String methodName;

@@ -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.
@@ -206,7 +206,7 @@ public abstract class PlaceholderConfigurerSupport extends PropertyResourceConfi
 					visitor.visitBeanDefinition(bd);
 				}
 				catch (Exception ex) {
-					throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage());
+					throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage(), ex);
 				}
 			}
 		}
--- a/Show More
+++ b/Show More