spring源码

framework-bom/framework-bom.gradle

@@ -0,0 +1,23 @@
+description = "Spring Framework (Bill of Materials)"
+
+apply plugin: 'java-platform'
+apply from: "$rootDir/gradle/publications.gradle"
+
+group = "org.springframework"
+
+dependencies {
+	constraints {
+		parent.moduleProjects.sort { "$it.name" }.each {
+			api it
+		}
+	}
+}
+
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			artifactId = 'spring-framework-bom'
+			from components.javaPlatform
+		}
+	}
+}

integration-tests/integration-tests.gradle

@@ -0,0 +1,30 @@
+description = "Spring Integration Tests"
+
+dependencies {
+	testCompile(project(":spring-aop"))
+	testCompile(project(":spring-beans"))
+	testCompile(project(":spring-context"))
+	testCompile(project(":spring-core"))
+	testCompile(testFixtures(project(":spring-aop")))
+	testCompile(testFixtures(project(":spring-beans")))
+	testCompile(testFixtures(project(":spring-core")))
+	testCompile(testFixtures(project(":spring-tx")))
+	testCompile(project(":spring-expression"))
+	testCompile(project(":spring-jdbc"))
+	testCompile(project(":spring-orm"))
+	testCompile(project(":spring-test"))
+	testCompile(project(":spring-tx"))
+	testCompile(project(":spring-web"))
+	testCompile("javax.inject:javax.inject")
+	testCompile("javax.resource:javax.resource-api")
+	testCompile("javax.servlet:javax.servlet-api")
+	testCompile("org.aspectj:aspectjweaver")
+	testCompile("org.hsqldb:hsqldb")
+	testCompile("org.hibernate:hibernate-core")
+}
+
+normalization {
+	runtimeClasspath {
+		ignore "META-INF/MANIFEST.MF"
+	}
+}

integration-tests/src/test/java/org/springframework/aop/config/AopNamespaceHandlerAdviceOrderIntegrationTests.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Integration tests for advice invocation order for advice configured via the
+ * AOP namespace.
+ *
+ * @author Sam Brannen
+ * @since 5.2.7
+ * @see org.springframework.aop.framework.autoproxy.AspectJAutoProxyAdviceOrderIntegrationTests
+ */
+class AopNamespaceHandlerAdviceOrderIntegrationTests {
+
+	@Nested
+	@SpringJUnitConfig(locations = "AopNamespaceHandlerAdviceOrderIntegrationTests-afterFirst.xml")
+	@DirtiesContext
+	class AfterAdviceFirstTests {
+
+		@Test
+		void afterAdviceIsInvokedFirst(@Autowired Echo echo, @Autowired InvocationTrackingAspect aspect) throws Exception {
+			assertThat(aspect.invocations).isEmpty();
+			assertThat(echo.echo(42)).isEqualTo(42);
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "around - end", "after", "after returning");
+
+			aspect.invocations.clear();
+			assertThatExceptionOfType(Exception.class).isThrownBy(() -> echo.echo(new Exception()));
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "around - end", "after", "after throwing");
+		}
+	}
+
+	@Nested
+	@SpringJUnitConfig(locations = "AopNamespaceHandlerAdviceOrderIntegrationTests-afterLast.xml")
+	@DirtiesContext
+	class AfterAdviceLastTests {
+
+		@Test
+		void afterAdviceIsInvokedLast(@Autowired Echo echo, @Autowired InvocationTrackingAspect aspect) throws Exception {
+			assertThat(aspect.invocations).isEmpty();
+			assertThat(echo.echo(42)).isEqualTo(42);
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "around - end", "after returning", "after");
+
+			aspect.invocations.clear();
+			assertThatExceptionOfType(Exception.class).isThrownBy(() -> echo.echo(new Exception()));
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "around - end", "after throwing", "after");
+		}
+	}
+
+
+	static class Echo {
+
+		Object echo(Object obj) throws Exception {
+			if (obj instanceof Exception) {
+				throw (Exception) obj;
+			}
+			return obj;
+		}
+	}
+
+	static class InvocationTrackingAspect {
+
+		List<String> invocations = new ArrayList<>();
+
+		Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+			invocations.add("around - start");
+			try {
+				return joinPoint.proceed();
+			}
+			finally {
+				invocations.add("around - end");
+			}
+		}
+
+		void before() {
+			invocations.add("before");
+		}
+
+		void afterReturning() {
+			invocations.add("after returning");
+		}
+
+		void afterThrowing() {
+			invocations.add("after throwing");
+		}
+
+		void after() {
+			invocations.add("after");
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/aop/config/AopNamespaceHandlerScopeIntegrationTests.java

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.config;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.testfixture.beans.ITestBean;
+import org.springframework.beans.testfixture.beans.TestBean;
+import org.springframework.core.testfixture.io.SerializationTestUtils;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.test.context.junit.jupiter.web.SpringJUnitWebConfig;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for scoped proxy use in conjunction with aop: namespace.
+ * Deemed an integration test because .web mocks and application contexts are required.
+ *
+ * @author Rob Harrop
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ * @see org.springframework.aop.config.AopNamespaceHandlerTests
+ */
+@SpringJUnitWebConfig
+class AopNamespaceHandlerScopeIntegrationTests {
+
+	@Autowired
+	ITestBean singletonScoped;
+
+	@Autowired
+	ITestBean requestScoped;
+
+	@Autowired
+	ITestBean sessionScoped;
+
+	@Autowired
+	ITestBean sessionScopedAlias;
+
+	@Autowired
+	ITestBean testBean;
+
+
+	@Test
+	void testSingletonScoping() throws Exception {
+		assertThat(AopUtils.isAopProxy(singletonScoped)).as("Should be AOP proxy").isTrue();
+		boolean condition = singletonScoped instanceof TestBean;
+		assertThat(condition).as("Should be target class proxy").isTrue();
+		String rob = "Rob Harrop";
+		String bram = "Bram Smeets";
+		assertThat(singletonScoped.getName()).isEqualTo(rob);
+		singletonScoped.setName(bram);
+		assertThat(singletonScoped.getName()).isEqualTo(bram);
+		ITestBean deserialized = SerializationTestUtils.serializeAndDeserialize(singletonScoped);
+		assertThat(deserialized.getName()).isEqualTo(bram);
+	}
+
+	@Test
+	void testRequestScoping() throws Exception {
+		MockHttpServletRequest oldRequest = new MockHttpServletRequest();
+		MockHttpServletRequest newRequest = new MockHttpServletRequest();
+
+		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(oldRequest));
+
+		assertThat(AopUtils.isAopProxy(requestScoped)).as("Should be AOP proxy").isTrue();
+		boolean condition = requestScoped instanceof TestBean;
+		assertThat(condition).as("Should be target class proxy").isTrue();
+
+		assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
+		boolean condition1 = testBean instanceof TestBean;
+		assertThat(condition1).as("Regular bean should be JDK proxy").isFalse();
+
+		String rob = "Rob Harrop";
+		String bram = "Bram Smeets";
+
+		assertThat(requestScoped.getName()).isEqualTo(rob);
+		requestScoped.setName(bram);
+		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(newRequest));
+		assertThat(requestScoped.getName()).isEqualTo(rob);
+		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(oldRequest));
+		assertThat(requestScoped.getName()).isEqualTo(bram);
+
+		assertThat(((Advised) requestScoped).getAdvisors().length > 0).as("Should have advisors").isTrue();
+	}
+
+	@Test
+	void testSessionScoping() throws Exception {
+		MockHttpSession oldSession = new MockHttpSession();
+		MockHttpSession newSession = new MockHttpSession();
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setSession(oldSession);
+		RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request));
+
+		assertThat(AopUtils.isAopProxy(sessionScoped)).as("Should be AOP proxy").isTrue();
+		boolean condition1 = sessionScoped instanceof TestBean;
+		assertThat(condition1).as("Should not be target class proxy").isFalse();
+
+		assertThat(sessionScopedAlias).isSameAs(sessionScoped);
+
+		assertThat(AopUtils.isAopProxy(testBean)).as("Should be AOP proxy").isTrue();
+		boolean condition = testBean instanceof TestBean;
+		assertThat(condition).as("Regular bean should be JDK proxy").isFalse();
+
+		String rob = "Rob Harrop";
+		String bram = "Bram Smeets";
+
+		assertThat(sessionScoped.getName()).isEqualTo(rob);
+		sessionScoped.setName(bram);
+		request.setSession(newSession);
+		assertThat(sessionScoped.getName()).isEqualTo(rob);
+		request.setSession(oldSession);
+		assertThat(sessionScoped.getName()).isEqualTo(bram);
+
+		assertThat(((Advised) sessionScoped).getAdvisors().length > 0).as("Should have advisors").isTrue();
+	}
+
+}

integration-tests/src/test/java/org/springframework/aop/framework/autoproxy/AdvisorAutoProxyCreatorIntegrationTests.java

@@ -0,0 +1,318 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.framework.autoproxy;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+import javax.servlet.ServletException;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor;
+import org.springframework.aop.testfixture.advice.CountingBeforeAdvice;
+import org.springframework.aop.testfixture.advice.MethodCounter;
+import org.springframework.aop.testfixture.interceptor.NopInterceptor;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.testfixture.beans.ITestBean;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.lang.Nullable;
+import org.springframework.transaction.NoTransactionException;
+import org.springframework.transaction.interceptor.TransactionInterceptor;
+import org.springframework.transaction.testfixture.CallCountingTransactionManager;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for auto proxy creation by advisor recognition working in
+ * conjunction with transaction management resources.
+ *
+ * @see org.springframework.aop.framework.autoproxy.AdvisorAutoProxyCreatorTests
+ *
+ * @author Rod Johnson
+ * @author Chris Beams
+ */
+class AdvisorAutoProxyCreatorIntegrationTests {
+
+	private static final Class<?> CLASS = AdvisorAutoProxyCreatorIntegrationTests.class;
+	private static final String CLASSNAME = CLASS.getSimpleName();
+
+	private static final String DEFAULT_CONTEXT = CLASSNAME + "-context.xml";
+
+	private static final String ADVISOR_APC_BEAN_NAME = "aapc";
+	private static final String TXMANAGER_BEAN_NAME = "txManager";
+
+	/**
+	 * Return a bean factory with attributes and EnterpriseServices configured.
+	 */
+	protected BeanFactory getBeanFactory() throws IOException {
+		return new ClassPathXmlApplicationContext(DEFAULT_CONTEXT, CLASS);
+	}
+
+	@Test
+	void testDefaultExclusionPrefix() throws Exception {
+		DefaultAdvisorAutoProxyCreator aapc = (DefaultAdvisorAutoProxyCreator) getBeanFactory().getBean(ADVISOR_APC_BEAN_NAME);
+		assertThat(aapc.getAdvisorBeanNamePrefix()).isEqualTo((ADVISOR_APC_BEAN_NAME + DefaultAdvisorAutoProxyCreator.SEPARATOR));
+		assertThat(aapc.isUsePrefix()).isFalse();
+	}
+
+	/**
+	 * If no pointcuts match (no attrs) there should be proxying.
+	 */
+	@Test
+	void testNoProxy() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		Object o = bf.getBean("noSetters");
+		assertThat(AopUtils.isAopProxy(o)).isFalse();
+	}
+
+	@Test
+	void testTxIsProxied() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		ITestBean test = (ITestBean) bf.getBean("test");
+		assertThat(AopUtils.isAopProxy(test)).isTrue();
+	}
+
+	@Test
+	void testRegexpApplied() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		ITestBean test = (ITestBean) bf.getBean("test");
+		MethodCounter counter = (MethodCounter) bf.getBean("countingAdvice");
+		assertThat(counter.getCalls()).isEqualTo(0);
+		test.getName();
+		assertThat(counter.getCalls()).isEqualTo(1);
+	}
+
+	@Test
+	void testTransactionAttributeOnMethod() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		ITestBean test = (ITestBean) bf.getBean("test");
+
+		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
+		OrderedTxCheckAdvisor txc = (OrderedTxCheckAdvisor) bf.getBean("orderedBeforeTransaction");
+		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
+
+		assertThat(txMan.commits).isEqualTo(0);
+		assertThat(test.getAge()).as("Initial value was correct").isEqualTo(4);
+		int newAge = 5;
+		test.setAge(newAge);
+		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(1);
+
+		assertThat(test.getAge()).as("New value set correctly").isEqualTo(newAge);
+		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
+	}
+
+	/**
+	 * Should not roll back on servlet exception.
+	 */
+	@Test
+	void testRollbackRulesOnMethodCauseRollback() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		Rollback rb = (Rollback) bf.getBean("rollback");
+
+		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
+		OrderedTxCheckAdvisor txc = (OrderedTxCheckAdvisor) bf.getBean("orderedBeforeTransaction");
+		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
+
+		assertThat(txMan.commits).isEqualTo(0);
+		rb.echoException(null);
+		// Fires only on setters
+		assertThat(txc.getCountingBeforeAdvice().getCalls()).isEqualTo(0);
+		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
+
+		assertThat(txMan.rollbacks).isEqualTo(0);
+		Exception ex = new Exception();
+		try {
+			rb.echoException(ex);
+		}
+		catch (Exception actual) {
+			assertThat(actual).isEqualTo(ex);
+		}
+		assertThat(txMan.rollbacks).as("Transaction counts match").isEqualTo(1);
+	}
+
+	@Test
+	void testRollbackRulesOnMethodPreventRollback() throws Exception {
+		BeanFactory bf = getBeanFactory();
+		Rollback rb = (Rollback) bf.getBean("rollback");
+
+		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
+
+		assertThat(txMan.commits).isEqualTo(0);
+		// Should NOT roll back on ServletException
+		try {
+			rb.echoException(new ServletException());
+		}
+		catch (ServletException ex) {
+
+		}
+		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
+	}
+
+	@Test
+	void testProgrammaticRollback() throws Exception {
+		BeanFactory bf = getBeanFactory();
+
+		Object bean = bf.getBean(TXMANAGER_BEAN_NAME);
+		boolean condition = bean instanceof CallCountingTransactionManager;
+		assertThat(condition).isTrue();
+		CallCountingTransactionManager txMan = (CallCountingTransactionManager) bf.getBean(TXMANAGER_BEAN_NAME);
+
+		Rollback rb = (Rollback) bf.getBean("rollback");
+		assertThat(txMan.commits).isEqualTo(0);
+		rb.rollbackOnly(false);
+		assertThat(txMan.commits).as("Transaction counts match").isEqualTo(1);
+		assertThat(txMan.rollbacks).isEqualTo(0);
+		// Will cause rollback only
+		rb.rollbackOnly(true);
+		assertThat(txMan.rollbacks).isEqualTo(1);
+	}
+
+}
+
+
+@SuppressWarnings("serial")
+class NeverMatchAdvisor extends StaticMethodMatcherPointcutAdvisor {
+
+	public NeverMatchAdvisor() {
+		super(new NopInterceptor());
+	}
+
+	/**
+	 * This method is solely to allow us to create a mixture of dependencies in
+	 * the bean definitions. The dependencies don't have any meaning, and don't
+	 * <b>do</b> anything.
+	 */
+	public void setDependencies(List<?> l) {
+
+	}
+
+	/**
+	 * @see org.springframework.aop.MethodMatcher#matches(java.lang.reflect.Method, java.lang.Class)
+	 */
+	@Override
+	public boolean matches(Method m, @Nullable Class<?> targetClass) {
+		return false;
+	}
+
+}
+
+
+class NoSetters {
+
+	public void A() {
+
+	}
+
+	public int getB() {
+		return -1;
+	}
+
+}
+
+
+@SuppressWarnings("serial")
+class OrderedTxCheckAdvisor extends StaticMethodMatcherPointcutAdvisor implements InitializingBean {
+
+	/**
+	 * Should we insist on the presence of a transaction attribute or refuse to accept one?
+	 */
+	private boolean requireTransactionContext = false;
+
+
+	public void setRequireTransactionContext(boolean requireTransactionContext) {
+		this.requireTransactionContext = requireTransactionContext;
+	}
+
+	public boolean isRequireTransactionContext() {
+		return requireTransactionContext;
+	}
+
+
+	public CountingBeforeAdvice getCountingBeforeAdvice() {
+		return (CountingBeforeAdvice) getAdvice();
+	}
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		setAdvice(new TxCountingBeforeAdvice());
+	}
+
+	@Override
+	public boolean matches(Method method, @Nullable Class<?> targetClass) {
+		return method.getName().startsWith("setAge");
+	}
+
+
+	private class TxCountingBeforeAdvice extends CountingBeforeAdvice {
+
+		@Override
+		public void before(Method method, Object[] args, Object target) throws Throwable {
+			// do transaction checks
+			if (requireTransactionContext) {
+				TransactionInterceptor.currentTransactionStatus();
+			}
+			else {
+				try {
+					TransactionInterceptor.currentTransactionStatus();
+					throw new RuntimeException("Shouldn't have a transaction");
+				}
+				catch (NoTransactionException ex) {
+					// this is Ok
+				}
+			}
+			super.before(method, args, target);
+		}
+	}
+
+}
+
+
+class Rollback {
+
+	/**
+	 * Inherits transaction attribute.
+	 * Illustrates programmatic rollback.
+	 */
+	public void rollbackOnly(boolean rollbackOnly) {
+		if (rollbackOnly) {
+			setRollbackOnly();
+		}
+	}
+
+	/**
+	 * Extracted in a protected method to facilitate testing
+	 */
+	protected void setRollbackOnly() {
+		TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
+	}
+
+	/**
+	 * @org.springframework.transaction.interceptor.RuleBasedTransaction ( timeout=-1 )
+	 * @org.springframework.transaction.interceptor.RollbackRule ( "java.lang.Exception" )
+	 * @org.springframework.transaction.interceptor.NoRollbackRule ( "ServletException" )
+	 */
+	public void echoException(Exception ex) throws Exception {
+		if (ex != null) {
+			throw ex;
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/aop/framework/autoproxy/AspectJAutoProxyAdviceOrderIntegrationTests.java

@@ -0,0 +1,233 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.framework.autoproxy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.EnableAspectJAutoProxy;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Integration tests for advice invocation order for advice configured via
+ * AspectJ auto-proxy support.
+ *
+ * @author Sam Brannen
+ * @since 5.2.7
+ * @see org.springframework.aop.config.AopNamespaceHandlerAdviceOrderIntegrationTests
+ */
+class AspectJAutoProxyAdviceOrderIntegrationTests {
+
+	/**
+	 * {@link After @After} advice declared as first <em>after</em> method in source code.
+	 */
+	@Nested
+	@SpringJUnitConfig(AfterAdviceFirstConfig.class)
+	@DirtiesContext
+	class AfterAdviceFirstTests {
+
+		@Test
+		void afterAdviceIsInvokedLast(@Autowired Echo echo, @Autowired AfterAdviceFirstAspect aspect) throws Exception {
+			assertThat(aspect.invocations).isEmpty();
+			assertThat(echo.echo(42)).isEqualTo(42);
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "after returning", "after", "around - end");
+
+			aspect.invocations.clear();
+			assertThatExceptionOfType(Exception.class).isThrownBy(
+					() -> echo.echo(new Exception()));
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "after throwing", "after", "around - end");
+		}
+	}
+
+
+	/**
+	 * This test class uses {@link AfterAdviceLastAspect} which declares its
+	 * {@link After @After} advice as the last <em>after advice type</em> method
+	 * in its source code.
+	 *
+	 * <p>On Java versions prior to JDK 7, we would have expected the {@code @After}
+	 * advice method to be invoked before {@code @AfterThrowing} and
+	 * {@code @AfterReturning} advice methods due to the AspectJ precedence
+	 * rules implemented in
+	 * {@link org.springframework.aop.aspectj.autoproxy.AspectJPrecedenceComparator}.
+	 */
+	@Nested
+	@SpringJUnitConfig(AfterAdviceLastConfig.class)
+	@DirtiesContext
+	class AfterAdviceLastTests {
+
+		@Test
+		void afterAdviceIsInvokedLast(@Autowired Echo echo, @Autowired AfterAdviceLastAspect aspect) throws Exception {
+			assertThat(aspect.invocations).isEmpty();
+			assertThat(echo.echo(42)).isEqualTo(42);
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "after returning", "after", "around - end");
+
+			aspect.invocations.clear();
+			assertThatExceptionOfType(Exception.class).isThrownBy(
+					() -> echo.echo(new Exception()));
+			assertThat(aspect.invocations).containsExactly("around - start", "before", "after throwing", "after", "around - end");
+		}
+	}
+
+
+	@Configuration
+	@EnableAspectJAutoProxy(proxyTargetClass = true)
+	static class AfterAdviceFirstConfig {
+
+		@Bean
+		AfterAdviceFirstAspect echoAspect() {
+			return new AfterAdviceFirstAspect();
+		}
+
+		@Bean
+		Echo echo() {
+			return new Echo();
+		}
+	}
+
+	@Configuration
+	@EnableAspectJAutoProxy(proxyTargetClass = true)
+	static class AfterAdviceLastConfig {
+
+		@Bean
+		AfterAdviceLastAspect echoAspect() {
+			return new AfterAdviceLastAspect();
+		}
+
+		@Bean
+		Echo echo() {
+			return new Echo();
+		}
+	}
+
+	static class Echo {
+
+		Object echo(Object obj) throws Exception {
+			if (obj instanceof Exception) {
+				throw (Exception) obj;
+			}
+			return obj;
+		}
+	}
+
+	/**
+	 * {@link After @After} advice declared as first <em>after</em> method in source code.
+	 */
+	@Aspect
+	static class AfterAdviceFirstAspect {
+
+		List<String> invocations = new ArrayList<>();
+
+		@Pointcut("execution(* echo(*))")
+		void echo() {
+		}
+
+		@After("echo()")
+		void after() {
+			invocations.add("after");
+		}
+
+		@AfterReturning("echo()")
+		void afterReturning() {
+			invocations.add("after returning");
+		}
+
+		@AfterThrowing("echo()")
+		void afterThrowing() {
+			invocations.add("after throwing");
+		}
+
+		@Before("echo()")
+		void before() {
+			invocations.add("before");
+		}
+
+		@Around("echo()")
+		Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+			invocations.add("around - start");
+			try {
+				return joinPoint.proceed();
+			}
+			finally {
+				invocations.add("around - end");
+			}
+		}
+	}
+
+	/**
+	 * {@link After @After} advice declared as last <em>after</em> method in source code.
+	 */
+	@Aspect
+	static class AfterAdviceLastAspect {
+
+		List<String> invocations = new ArrayList<>();
+
+		@Pointcut("execution(* echo(*))")
+		void echo() {
+		}
+
+		@Around("echo()")
+		Object around(ProceedingJoinPoint joinPoint) throws Throwable {
+			invocations.add("around - start");
+			try {
+				return joinPoint.proceed();
+			}
+			finally {
+				invocations.add("around - end");
+			}
+		}
+
+		@Before("echo()")
+		void before() {
+			invocations.add("before");
+		}
+
+		@AfterReturning("echo()")
+		void afterReturning() {
+			invocations.add("after returning");
+		}
+
+		@AfterThrowing("echo()")
+		void afterThrowing() {
+			invocations.add("after throwing");
+		}
+
+		@After("echo()")
+		void after() {
+			invocations.add("after");
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/beans/factory/xml/Component.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.xml;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Component {
+
+	private String name;
+	private List<Component> components = new ArrayList<>();
+
+	// mmm, there is no setter method for the 'components'
+	public void addComponent(Component component) {
+		this.components.add(component);
+	}
+
+	public List<Component> getComponents() {
+		return components;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+}

integration-tests/src/test/java/org/springframework/beans/factory/xml/ComponentBeanDefinitionParser.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.xml;
+
+import java.util.List;
+
+import org.w3c.dom.Element;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.xml.DomUtils;
+
+public class ComponentBeanDefinitionParser extends AbstractBeanDefinitionParser {
+
+	@Override
+	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
+		return parseComponentElement(element);
+	}
+
+	private static AbstractBeanDefinition parseComponentElement(Element element) {
+		BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean.class);
+		factory.addPropertyValue("parent", parseComponent(element));
+
+		List<Element> childElements = DomUtils.getChildElementsByTagName(element, "component");
+		if (!CollectionUtils.isEmpty(childElements)) {
+			parseChildComponents(childElements, factory);
+		}
+
+		return factory.getBeanDefinition();
+	}
+
+	private static BeanDefinition parseComponent(Element element) {
+		BeanDefinitionBuilder component = BeanDefinitionBuilder.rootBeanDefinition(Component.class);
+		component.addPropertyValue("name", element.getAttribute("name"));
+		return component.getBeanDefinition();
+	}
+
+	private static void parseChildComponents(List<Element> childElements, BeanDefinitionBuilder factory) {
+		ManagedList<BeanDefinition> children = new ManagedList<>(childElements.size());
+		for (Element element : childElements) {
+			children.add(parseComponentElement(element));
+		}
+		factory.addPropertyValue("children", children);
+	}
+
+}

integration-tests/src/test/java/org/springframework/beans/factory/xml/ComponentBeanDefinitionParserTests.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.xml;
+
+import java.util.List;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.core.io.ClassPathResource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Costin Leau
+ */
+@TestInstance(Lifecycle.PER_CLASS)
+class ComponentBeanDefinitionParserTests {
+
+	private final DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+
+
+	@BeforeAll
+	void setUp() throws Exception {
+		new XmlBeanDefinitionReader(bf).loadBeanDefinitions(
+			new ClassPathResource("component-config.xml", ComponentBeanDefinitionParserTests.class));
+	}
+
+	@AfterAll
+	void tearDown() {
+		bf.destroySingletons();
+	}
+
+	@Test
+	void testBionicBasic() {
+		Component cp = getBionicFamily();
+		assertThat("Bionic-1").isEqualTo(cp.getName());
+	}
+
+	@Test
+	void testBionicFirstLevelChildren() {
+		Component cp = getBionicFamily();
+		List<Component> components = cp.getComponents();
+		assertThat(2).isEqualTo(components.size());
+		assertThat("Mother-1").isEqualTo(components.get(0).getName());
+		assertThat("Rock-1").isEqualTo(components.get(1).getName());
+	}
+
+	@Test
+	void testBionicSecondLevelChildren() {
+		Component cp = getBionicFamily();
+		List<Component> components = cp.getComponents().get(0).getComponents();
+		assertThat(2).isEqualTo(components.size());
+		assertThat("Karate-1").isEqualTo(components.get(0).getName());
+		assertThat("Sport-1").isEqualTo(components.get(1).getName());
+	}
+
+	private Component getBionicFamily() {
+		return bf.getBean("bionic-family", Component.class);
+	}
+
+}
+

integration-tests/src/test/java/org/springframework/beans/factory/xml/ComponentFactoryBean.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.xml;
+
+import java.util.List;
+
+import org.springframework.beans.factory.FactoryBean;
+
+public class ComponentFactoryBean implements FactoryBean<Component> {
+
+	private Component parent;
+	private List<Component> children;
+
+	public void setParent(Component parent) {
+		this.parent = parent;
+	}
+
+	public void setChildren(List<Component> children) {
+		this.children = children;
+	}
+
+	@Override
+	public Component getObject() throws Exception {
+		if (this.children != null && this.children.size() > 0) {
+			for (Component child : children) {
+				this.parent.addComponent(child);
+			}
+		}
+		return this.parent;
+	}
+
+	@Override
+	public Class<Component> getObjectType() {
+		return Component.class;
+	}
+
+	@Override
+	public boolean isSingleton() {
+		return true;
+	}
+
+}

integration-tests/src/test/java/org/springframework/beans/factory/xml/ComponentNamespaceHandler.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.beans.factory.xml;
+
+public class ComponentNamespaceHandler extends NamespaceHandlerSupport {
+
+	@Override
+	public void init() {
+		registerBeanDefinitionParser("component", new ComponentBeanDefinitionParser());
+	}
+}

integration-tests/src/test/java/org/springframework/cache/annotation/EnableCachingIntegrationTests.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.cache.annotation;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.interceptor.BeanFactoryCacheOperationSourceAdvisor;
+import org.springframework.cache.support.NoOpCacheManager;
+import org.springframework.context.annotation.AdviceMode;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Integration tests for the @EnableCaching annotation.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ */
+@SuppressWarnings("resource")
+class EnableCachingIntegrationTests {
+
+	@Test
+	void repositoryIsClassBasedCacheProxy() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, ProxyTargetClassCachingConfig.class);
+		ctx.refresh();
+
+		assertCacheProxying(ctx);
+		assertThat(AopUtils.isCglibProxy(ctx.getBean(FooRepository.class))).isTrue();
+	}
+
+	@Test
+	void repositoryUsesAspectJAdviceMode() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, AspectJCacheConfig.class);
+		// this test is a bit fragile, but gets the job done, proving that an
+		// attempt was made to look up the AJ aspect. It's due to classpath issues
+		// in .integration-tests that it's not found.
+		assertThatExceptionOfType(Exception.class).isThrownBy(
+				ctx::refresh)
+			.withMessageContaining("AspectJCachingConfiguration");
+	}
+
+
+	private void assertCacheProxying(AnnotationConfigApplicationContext ctx) {
+		FooRepository repo = ctx.getBean(FooRepository.class);
+		assertThat(isCacheProxy(repo)).isTrue();
+	}
+
+	private boolean isCacheProxy(FooRepository repo) {
+		if (AopUtils.isAopProxy(repo)) {
+			for (Advisor advisor : ((Advised)repo).getAdvisors()) {
+				if (advisor instanceof BeanFactoryCacheOperationSourceAdvisor) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+
+	@Configuration
+	@EnableCaching(proxyTargetClass=true)
+	static class ProxyTargetClassCachingConfig {
+
+		@Bean
+		CacheManager mgr() {
+			return new NoOpCacheManager();
+		}
+	}
+
+
+	@Configuration
+	static class Config {
+
+		@Bean
+		FooRepository fooRepository() {
+			return new DummyFooRepository();
+		}
+	}
+
+
+	@Configuration
+	@EnableCaching(mode=AdviceMode.ASPECTJ)
+	static class AspectJCacheConfig {
+
+		@Bean
+		CacheManager cacheManager() {
+			return new NoOpCacheManager();
+		}
+	}
+
+
+	interface FooRepository {
+
+		List<Object> findAll();
+	}
+
+
+	@Repository
+	static class DummyFooRepository implements FooRepository {
+
+		@Override
+		@Cacheable("primary")
+		public List<Object> findAll() {
+			return Collections.emptyList();
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/context/annotation/jsr330/ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests.java

@@ -0,0 +1,405 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.context.annotation.jsr330;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
+import org.springframework.context.annotation.ScopeMetadata;
+import org.springframework.context.annotation.ScopeMetadataResolver;
+import org.springframework.context.annotation.ScopedProxyMode;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import org.springframework.web.context.support.GenericWebApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Mark Fisher
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ */
+class ClassPathBeanDefinitionScannerJsr330ScopeIntegrationTests {
+
+	private static final String DEFAULT_NAME = "default";
+
+	private static final String MODIFIED_NAME = "modified";
+
+	private ServletRequestAttributes oldRequestAttributes;
+
+	private ServletRequestAttributes newRequestAttributes;
+
+	private ServletRequestAttributes oldRequestAttributesWithSession;
+
+	private ServletRequestAttributes newRequestAttributesWithSession;
+
+
+	@BeforeEach
+	void setup() {
+		this.oldRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
+		this.newRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
+
+		MockHttpServletRequest oldRequestWithSession = new MockHttpServletRequest();
+		oldRequestWithSession.setSession(new MockHttpSession());
+		this.oldRequestAttributesWithSession = new ServletRequestAttributes(oldRequestWithSession);
+
+		MockHttpServletRequest newRequestWithSession = new MockHttpServletRequest();
+		newRequestWithSession.setSession(new MockHttpSession());
+		this.newRequestAttributesWithSession = new ServletRequestAttributes(newRequestWithSession);
+	}
+
+	@AfterEach
+	void reset() {
+		RequestContextHolder.setRequestAttributes(null);
+	}
+
+
+	@Test
+	void testPrototype() {
+		ApplicationContext context = createContext(ScopedProxyMode.NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("prototype");
+		assertThat(bean).isNotNull();
+		assertThat(context.isPrototype("prototype")).isTrue();
+		assertThat(context.isSingleton("prototype")).isFalse();
+	}
+
+	@Test
+	void testSingletonScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+		assertThat(context.isSingleton("singleton")).isTrue();
+		assertThat(context.isPrototype("singleton")).isFalse();
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testSingletonScopeIgnoresProxyInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testSingletonScopeIgnoresProxyTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testRequestScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("request");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// but a newly retrieved bean should have the default name
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("request");
+		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
+	}
+
+	@Test
+	void testRequestScopeWithProxiedInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
+
+		// should be dynamic proxy, implementing both interfaces
+		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
+		boolean condition = bean instanceof AnotherScopeTestInterface;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testRequestScopeWithProxiedTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
+
+		// should be a class-based proxy
+		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
+		boolean condition = bean instanceof RequestScopedTestBean;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testSessionScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(ScopedProxyMode.NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("session");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// but a newly retrieved bean should have the default name
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
+	}
+
+	@Test
+	void testSessionScopeWithProxiedInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(ScopedProxyMode.INTERFACES);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
+
+		// should be dynamic proxy, implementing both interfaces
+		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
+		boolean condition = bean instanceof AnotherScopeTestInterface;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+		bean2.setName(DEFAULT_NAME);
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void testSessionScopeWithProxiedTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(ScopedProxyMode.TARGET_CLASS);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
+
+		// should be a class-based proxy
+		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
+		boolean condition1 = bean instanceof ScopedTestBean;
+		assertThat(condition1).isTrue();
+		boolean condition = bean instanceof SessionScopedTestBean;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+		bean2.setName(DEFAULT_NAME);
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+
+	private ApplicationContext createContext(final ScopedProxyMode scopedProxyMode) {
+		GenericWebApplicationContext context = new GenericWebApplicationContext();
+		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
+		scanner.setIncludeAnnotationConfig(false);
+		scanner.setScopeMetadataResolver(new ScopeMetadataResolver() {
+			@Override
+			public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
+				ScopeMetadata metadata = new ScopeMetadata();
+				if (definition instanceof AnnotatedBeanDefinition) {
+					AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
+					for (String type : annDef.getMetadata().getAnnotationTypes()) {
+						if (type.equals(javax.inject.Singleton.class.getName())) {
+							metadata.setScopeName(BeanDefinition.SCOPE_SINGLETON);
+							break;
+						}
+						else if (annDef.getMetadata().getMetaAnnotationTypes(type).contains(javax.inject.Scope.class.getName())) {
+							metadata.setScopeName(type.substring(type.length() - 13, type.length() - 6).toLowerCase());
+							metadata.setScopedProxyMode(scopedProxyMode);
+							break;
+						}
+						else if (type.startsWith("javax.inject")) {
+							metadata.setScopeName(BeanDefinition.SCOPE_PROTOTYPE);
+						}
+					}
+				}
+				return metadata;
+			}
+		});
+
+		// Scan twice in order to find errors in the bean definition compatibility check.
+		scanner.scan(getClass().getPackage().getName());
+		scanner.scan(getClass().getPackage().getName());
+
+		context.registerAlias("classPathBeanDefinitionScannerJsr330ScopeIntegrationTests.SessionScopedTestBean", "session");
+		context.refresh();
+		return context;
+	}
+
+
+	public interface IScopedTestBean {
+
+		String getName();
+
+		void setName(String name);
+	}
+
+
+	public static abstract class ScopedTestBean implements IScopedTestBean {
+
+		private String name = DEFAULT_NAME;
+
+		@Override
+		public String getName() { return this.name; }
+
+		@Override
+		public void setName(String name) { this.name = name; }
+	}
+
+
+	@Named("prototype")
+	public static class PrototypeScopedTestBean extends ScopedTestBean {
+	}
+
+
+	@Named("singleton")
+	@Singleton
+	public static class SingletonScopedTestBean extends ScopedTestBean {
+	}
+
+
+	public interface AnotherScopeTestInterface {
+	}
+
+
+	@Named("request")
+	@RequestScoped
+	public static class RequestScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
+	}
+
+
+	@Named
+	@SessionScoped
+	public static class SessionScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
+	}
+
+
+	@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
+	@Retention(RetentionPolicy.RUNTIME)
+	@javax.inject.Scope
+	public @interface RequestScoped {
+	}
+
+
+	@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
+	@Retention(RetentionPolicy.RUNTIME)
+	@javax.inject.Scope
+	public @interface SessionScoped {
+	}
+
+}

integration-tests/src/test/java/org/springframework/context/annotation/scope/ClassPathBeanDefinitionScannerScopeIntegrationTests.java

@@ -0,0 +1,341 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.context.annotation.scope;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
+import org.springframework.context.annotation.ScopedProxyMode;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpSession;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.annotation.RequestScope;
+import org.springframework.web.context.annotation.SessionScope;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import org.springframework.web.context.support.GenericWebApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.context.annotation.ScopedProxyMode.DEFAULT;
+import static org.springframework.context.annotation.ScopedProxyMode.INTERFACES;
+import static org.springframework.context.annotation.ScopedProxyMode.NO;
+import static org.springframework.context.annotation.ScopedProxyMode.TARGET_CLASS;
+
+/**
+ * @author Mark Fisher
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ * @author Sam Brannen
+ */
+class ClassPathBeanDefinitionScannerScopeIntegrationTests {
+
+	private static final String DEFAULT_NAME = "default";
+	private static final String MODIFIED_NAME = "modified";
+
+	private ServletRequestAttributes oldRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
+	private ServletRequestAttributes newRequestAttributes = new ServletRequestAttributes(new MockHttpServletRequest());
+
+	private ServletRequestAttributes oldRequestAttributesWithSession;
+	private ServletRequestAttributes newRequestAttributesWithSession;
+
+
+	@BeforeEach
+	void setup() {
+		MockHttpServletRequest oldRequestWithSession = new MockHttpServletRequest();
+		oldRequestWithSession.setSession(new MockHttpSession());
+		this.oldRequestAttributesWithSession = new ServletRequestAttributes(oldRequestWithSession);
+
+		MockHttpServletRequest newRequestWithSession = new MockHttpServletRequest();
+		newRequestWithSession.setSession(new MockHttpSession());
+		this.newRequestAttributesWithSession = new ServletRequestAttributes(newRequestWithSession);
+	}
+
+	@AfterEach
+	void reset() {
+		RequestContextHolder.resetRequestAttributes();
+	}
+
+
+	@Test
+	void singletonScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void singletonScopeIgnoresProxyInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(INTERFACES);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void singletonScopeIgnoresProxyTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(TARGET_CLASS);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("singleton");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// singleton bean, so name should be modified even after lookup
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("singleton");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void requestScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("request");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// but a newly retrieved bean should have the default name
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("request");
+		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
+	}
+
+	@Test
+	void requestScopeWithProxiedInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(INTERFACES);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
+
+		// should be dynamic proxy, implementing both interfaces
+		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
+		boolean condition = bean instanceof AnotherScopeTestInterface;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void requestScopeWithProxiedTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		ApplicationContext context = createContext(TARGET_CLASS);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("request");
+
+		// should be a class-based proxy
+		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
+		boolean condition = bean instanceof RequestScopedTestBean;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributes);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributes);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void sessionScopeWithNoProxy() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(NO);
+		ScopedTestBean bean = (ScopedTestBean) context.getBean("session");
+
+		// should not be a proxy
+		assertThat(AopUtils.isAopProxy(bean)).isFalse();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// not a proxy so this should not have changed
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+
+		// but a newly retrieved bean should have the default name
+		ScopedTestBean bean2 = (ScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(DEFAULT_NAME);
+	}
+
+	@Test
+	void sessionScopeWithProxiedInterfaces() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(INTERFACES);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
+
+		// should be dynamic proxy, implementing both interfaces
+		assertThat(AopUtils.isJdkDynamicProxy(bean)).isTrue();
+		boolean condition = bean instanceof AnotherScopeTestInterface;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+		bean2.setName(DEFAULT_NAME);
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+	@Test
+	void sessionScopeWithProxiedTargetClass() {
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		ApplicationContext context = createContext(TARGET_CLASS);
+		IScopedTestBean bean = (IScopedTestBean) context.getBean("session");
+
+		// should be a class-based proxy
+		assertThat(AopUtils.isCglibProxy(bean)).isTrue();
+		boolean condition1 = bean instanceof ScopedTestBean;
+		assertThat(condition1).isTrue();
+		boolean condition = bean instanceof SessionScopedTestBean;
+		assertThat(condition).isTrue();
+
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		RequestContextHolder.setRequestAttributes(newRequestAttributesWithSession);
+		// this is a proxy so it should be reset to default
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+		bean.setName(MODIFIED_NAME);
+
+		IScopedTestBean bean2 = (IScopedTestBean) context.getBean("session");
+		assertThat(bean2.getName()).isEqualTo(MODIFIED_NAME);
+		bean2.setName(DEFAULT_NAME);
+		assertThat(bean.getName()).isEqualTo(DEFAULT_NAME);
+
+		RequestContextHolder.setRequestAttributes(oldRequestAttributesWithSession);
+		assertThat(bean.getName()).isEqualTo(MODIFIED_NAME);
+	}
+
+
+	private ApplicationContext createContext(ScopedProxyMode scopedProxyMode) {
+		GenericWebApplicationContext context = new GenericWebApplicationContext();
+		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
+		scanner.setIncludeAnnotationConfig(false);
+		scanner.setBeanNameGenerator((definition, registry) -> definition.getScope());
+		scanner.setScopedProxyMode(scopedProxyMode);
+
+		// Scan twice in order to find errors in the bean definition compatibility check.
+		scanner.scan(getClass().getPackage().getName());
+		scanner.scan(getClass().getPackage().getName());
+
+		context.refresh();
+		return context;
+	}
+
+
+	interface IScopedTestBean {
+
+		String getName();
+
+		void setName(String name);
+	}
+
+
+	static abstract class ScopedTestBean implements IScopedTestBean {
+
+		private String name = DEFAULT_NAME;
+
+		@Override
+		public String getName() { return this.name; }
+
+		@Override
+		public void setName(String name) { this.name = name; }
+	}
+
+
+	@Component
+	static class SingletonScopedTestBean extends ScopedTestBean {
+	}
+
+
+	interface AnotherScopeTestInterface {
+	}
+
+
+	@Component
+	@RequestScope(proxyMode = DEFAULT)
+	static class RequestScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
+	}
+
+
+	@Component
+	@SessionScope(proxyMode = DEFAULT)
+	static class SessionScopedTestBean extends ScopedTestBean implements AnotherScopeTestInterface {
+	}
+
+}

integration-tests/src/test/java/org/springframework/core/env/EnvironmentSystemIntegrationTests.java

@@ -0,0 +1,710 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.EnvironmentAware;
+import org.springframework.context.annotation.AnnotatedBeanDefinitionReader;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.context.support.FileSystemXmlApplicationContext;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.context.support.GenericXmlApplicationContext;
+import org.springframework.context.support.StaticApplicationContext;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.jca.context.ResourceAdapterApplicationContext;
+import org.springframework.jca.support.SimpleBootstrapContext;
+import org.springframework.jca.work.SimpleTaskWorkManager;
+import org.springframework.mock.env.MockEnvironment;
+import org.springframework.mock.env.MockPropertySource;
+import org.springframework.mock.web.MockServletConfig;
+import org.springframework.mock.web.MockServletContext;
+import org.springframework.util.FileCopyUtils;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.AbstractRefreshableWebApplicationContext;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.context.support.GenericWebApplicationContext;
+import org.springframework.web.context.support.StandardServletEnvironment;
+import org.springframework.web.context.support.StaticWebApplicationContext;
+import org.springframework.web.context.support.XmlWebApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
+import static org.springframework.context.ConfigurableApplicationContext.ENVIRONMENT_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DERIVED_DEV_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DERIVED_DEV_ENV_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.ENVIRONMENT_AWARE_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.TRANSITIVE_BEAN_NAME;
+import static org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.XML_PATH;
+
+/**
+ * System integration tests for container support of the {@link Environment} API.
+ *
+ * <p>
+ * Tests all existing BeanFactory and ApplicationContext implementations to ensure that:
+ * <ul>
+ * <li>a standard environment object is always present
+ * <li>a custom environment object can be set and retrieved against the factory/context
+ * <li>the {@link EnvironmentAware} interface is respected
+ * <li>the environment object is registered with the container as a singleton bean (if an
+ * ApplicationContext)
+ * <li>bean definition files (if any, and whether XML or @Configuration) are registered
+ * conditionally based on environment metadata
+ * </ul>
+ *
+ * @author Chris Beams
+ * @author Sam Brannen
+ * @see org.springframework.context.support.EnvironmentIntegrationTests
+ */
+@SuppressWarnings("resource")
+public class EnvironmentSystemIntegrationTests {
+
+	private final ConfigurableEnvironment prodEnv = new StandardEnvironment();
+
+	private final ConfigurableEnvironment devEnv = new StandardEnvironment();
+
+	private final ConfigurableEnvironment prodWebEnv = new StandardServletEnvironment();
+
+	@BeforeEach
+	void setUp() {
+		prodEnv.setActiveProfiles(PROD_ENV_NAME);
+		devEnv.setActiveProfiles(DEV_ENV_NAME);
+		prodWebEnv.setActiveProfiles(PROD_ENV_NAME);
+	}
+
+	@Test
+	void genericApplicationContext_standardEnv() {
+		ConfigurableApplicationContext ctx = new GenericApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
+		ctx.refresh();
+
+		assertHasStandardEnvironment(ctx);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
+	}
+
+	@Test
+	void genericApplicationContext_customEnv() {
+		GenericApplicationContext ctx = new GenericApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
+		ctx.setEnvironment(prodEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+	}
+
+	@Test
+	void xmlBeanDefinitionReader_inheritsEnvironmentFromEnvironmentCapableBDR() {
+		GenericApplicationContext ctx = new GenericApplicationContext();
+		ctx.setEnvironment(prodEnv);
+		new XmlBeanDefinitionReader(ctx).loadBeanDefinitions(XML_PATH);
+		ctx.refresh();
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void annotatedBeanDefinitionReader_inheritsEnvironmentFromEnvironmentCapableBDR() {
+		GenericApplicationContext ctx = new GenericApplicationContext();
+		ctx.setEnvironment(prodEnv);
+		new AnnotatedBeanDefinitionReader(ctx).register(Config.class);
+		ctx.refresh();
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void classPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedConfigClasses() {
+		// it's actually ConfigurationClassPostProcessor's Environment that gets the job done here.
+		GenericApplicationContext ctx = new GenericApplicationContext();
+		ctx.setEnvironment(prodEnv);
+		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(ctx);
+		scanner.scan("org.springframework.core.env.scan1");
+		ctx.refresh();
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void classPathBeanDefinitionScanner_inheritsEnvironmentFromEnvironmentCapableBDR_scanProfileAnnotatedComponents() {
+		GenericApplicationContext ctx = new GenericApplicationContext();
+		ctx.setEnvironment(prodEnv);
+		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(ctx);
+		scanner.scan("org.springframework.core.env.scan2");
+		ctx.refresh();
+		assertThat(scanner.getEnvironment()).isEqualTo(ctx.getEnvironment());
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void genericXmlApplicationContext() {
+		GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(prodEnv);
+		ctx.load(XML_PATH);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void classPathXmlApplicationContext() {
+		ConfigurableApplicationContext ctx = new ClassPathXmlApplicationContext(XML_PATH);
+		ctx.setEnvironment(prodEnv);
+		ctx.refresh();
+
+		assertEnvironmentBeanRegistered(ctx);
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void fileSystemXmlApplicationContext() throws IOException {
+		ClassPathResource xml = new ClassPathResource(XML_PATH);
+		File tmpFile = File.createTempFile("test", "xml");
+		FileCopyUtils.copy(xml.getFile(), tmpFile);
+
+		// strange - FSXAC strips leading '/' unless prefixed with 'file:'
+		ConfigurableApplicationContext ctx =
+				new FileSystemXmlApplicationContext(new String[] {"file:" + tmpFile.getPath()}, false);
+		ctx.setEnvironment(prodEnv);
+		ctx.refresh();
+		assertEnvironmentBeanRegistered(ctx);
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentAwareInvoked(ctx, ctx.getEnvironment());
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withPojos() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(prodEnv);
+
+		ctx.register(EnvironmentAwareBean.class);
+		ctx.refresh();
+
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProdEnvAndProdConfigClass() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(prodEnv);
+
+		ctx.register(ProdConfig.class);
+		ctx.refresh();
+
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProdEnvAndDevConfigClass() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(prodEnv);
+
+		ctx.register(DevConfig.class);
+		ctx.refresh();
+
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withDevEnvAndDevConfigClass() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(devEnv);
+
+		ctx.register(DevConfig.class);
+		ctx.refresh();
+
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isTrue();
+		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withImportedConfigClasses() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+		ctx.setEnvironment(prodEnv);
+
+		ctx.register(Config.class);
+		ctx.refresh();
+
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
+	}
+
+	@Test
+	void mostSpecificDerivedClassDrivesEnvironment_withDerivedDevEnvAndDerivedDevConfigClass() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		StandardEnvironment derivedDevEnv = new StandardEnvironment();
+		derivedDevEnv.setActiveProfiles(DERIVED_DEV_ENV_NAME);
+		ctx.setEnvironment(derivedDevEnv);
+		ctx.register(DerivedDevConfig.class);
+		ctx.refresh();
+
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isTrue();
+		assertThat(ctx.containsBean(DERIVED_DEV_BEAN_NAME)).isTrue();
+		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void mostSpecificDerivedClassDrivesEnvironment_withDevEnvAndDerivedDevConfigClass() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.setEnvironment(devEnv);
+		ctx.register(DerivedDevConfig.class);
+		ctx.refresh();
+
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(DERIVED_DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(TRANSITIVE_BEAN_NAME)).isFalse();
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProfileExpressionMatchOr() {
+		testProfileExpression(true, "p3");
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProfileExpressionMatchAnd() {
+		testProfileExpression(true, "p1", "p2");
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProfileExpressionNoMatchAnd() {
+		testProfileExpression(false, "p1");
+	}
+
+	@Test
+	void annotationConfigApplicationContext_withProfileExpressionNoMatchNone() {
+		testProfileExpression(false, "p4");
+	}
+
+	private void testProfileExpression(boolean expected, String... activeProfiles) {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		StandardEnvironment environment = new StandardEnvironment();
+		environment.setActiveProfiles(activeProfiles);
+		ctx.setEnvironment(environment);
+		ctx.register(ProfileExpressionConfig.class);
+		ctx.refresh();
+		assertThat(ctx.containsBean("expressionBean")).isEqualTo(expected);
+	}
+
+	@Test
+	void webApplicationContext() {
+		GenericWebApplicationContext ctx = new GenericWebApplicationContext(newBeanFactoryWithEnvironmentAwareBean());
+		assertHasStandardServletEnvironment(ctx);
+		ctx.setEnvironment(prodWebEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodWebEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
+	}
+
+	@Test
+	void xmlWebApplicationContext() {
+		AbstractRefreshableWebApplicationContext ctx = new XmlWebApplicationContext();
+		ctx.setConfigLocation("classpath:" + XML_PATH);
+		ctx.setEnvironment(prodWebEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodWebEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
+		assertThat(ctx.containsBean(DEV_BEAN_NAME)).isFalse();
+		assertThat(ctx.containsBean(PROD_BEAN_NAME)).isTrue();
+	}
+
+	@Test
+	void staticApplicationContext() {
+		StaticApplicationContext ctx = new StaticApplicationContext();
+
+		assertHasStandardEnvironment(ctx);
+
+		registerEnvironmentBeanDefinition(ctx);
+
+		ctx.setEnvironment(prodEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+	}
+
+	@Test
+	void staticWebApplicationContext() {
+		StaticWebApplicationContext ctx = new StaticWebApplicationContext();
+
+		assertHasStandardServletEnvironment(ctx);
+
+		registerEnvironmentBeanDefinition(ctx);
+
+		ctx.setEnvironment(prodWebEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodWebEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
+	}
+
+	@Test
+	void annotationConfigWebApplicationContext() {
+		AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
+		ctx.setEnvironment(prodWebEnv);
+		ctx.setConfigLocation(EnvironmentAwareBean.class.getName());
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodWebEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodWebEnv);
+	}
+
+	@Test
+	void registerServletParamPropertySources_AbstractRefreshableWebApplicationContext() {
+		MockServletContext servletContext = new MockServletContext();
+		servletContext.addInitParameter("pCommon", "pCommonContextValue");
+		servletContext.addInitParameter("pContext1", "pContext1Value");
+
+		MockServletConfig servletConfig = new MockServletConfig(servletContext);
+		servletConfig.addInitParameter("pCommon", "pCommonConfigValue");
+		servletConfig.addInitParameter("pConfig1", "pConfig1Value");
+
+		AbstractRefreshableWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
+		ctx.setConfigLocation(EnvironmentAwareBean.class.getName());
+		ctx.setServletConfig(servletConfig);
+		ctx.refresh();
+
+		ConfigurableEnvironment environment = ctx.getEnvironment();
+		assertThat(environment).isInstanceOf(StandardServletEnvironment.class);
+		MutablePropertySources propertySources = environment.getPropertySources();
+		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
+		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)).isTrue();
+
+		// ServletConfig gets precedence
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
+		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
+				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)));
+
+		// but all params are available
+		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
+		assertThat(environment.getProperty("pConfig1")).isEqualTo("pConfig1Value");
+
+		// Servlet* PropertySources have precedence over System* PropertySources
+		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
+				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
+
+		// Replace system properties with a mock property source for convenience
+		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
+		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
+		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
+		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
+
+		// assert that servletconfig params resolve with higher precedence than sysprops
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
+		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
+	}
+
+	@Test
+	void registerServletParamPropertySources_GenericWebApplicationContext() {
+		MockServletContext servletContext = new MockServletContext();
+		servletContext.addInitParameter("pCommon", "pCommonContextValue");
+		servletContext.addInitParameter("pContext1", "pContext1Value");
+
+		GenericWebApplicationContext ctx = new GenericWebApplicationContext();
+		ctx.setServletContext(servletContext);
+		ctx.refresh();
+
+		ConfigurableEnvironment environment = ctx.getEnvironment();
+		assertThat(environment).isInstanceOf(StandardServletEnvironment.class);
+		MutablePropertySources propertySources = environment.getPropertySources();
+		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
+
+		// ServletContext params are available
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonContextValue");
+		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
+
+		// Servlet* PropertySources have precedence over System* PropertySources
+		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)))
+				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
+
+		// Replace system properties with a mock property source for convenience
+		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
+		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
+		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
+		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
+
+		// assert that servletcontext init params resolve with higher precedence than sysprops
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonContextValue");
+		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
+	}
+
+	@Test
+	void registerServletParamPropertySources_StaticWebApplicationContext() {
+		MockServletContext servletContext = new MockServletContext();
+		servletContext.addInitParameter("pCommon", "pCommonContextValue");
+		servletContext.addInitParameter("pContext1", "pContext1Value");
+
+		MockServletConfig servletConfig = new MockServletConfig(servletContext);
+		servletConfig.addInitParameter("pCommon", "pCommonConfigValue");
+		servletConfig.addInitParameter("pConfig1", "pConfig1Value");
+
+		StaticWebApplicationContext ctx = new StaticWebApplicationContext();
+		ctx.setServletConfig(servletConfig);
+		ctx.refresh();
+
+		ConfigurableEnvironment environment = ctx.getEnvironment();
+		MutablePropertySources propertySources = environment.getPropertySources();
+		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)).isTrue();
+		assertThat(propertySources.contains(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)).isTrue();
+
+		// ServletConfig gets precedence
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
+		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
+				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME)));
+
+		// but all params are available
+		assertThat(environment.getProperty("pContext1")).isEqualTo("pContext1Value");
+		assertThat(environment.getProperty("pConfig1")).isEqualTo("pConfig1Value");
+
+		// Servlet* PropertySources have precedence over System* PropertySources
+		assertThat(propertySources.precedenceOf(PropertySource.named(StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME)))
+				.isLessThan(propertySources.precedenceOf(PropertySource.named(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME)));
+
+		// Replace system properties with a mock property source for convenience
+		MockPropertySource mockSystemProperties = new MockPropertySource(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME);
+		mockSystemProperties.setProperty("pCommon", "pCommonSysPropsValue");
+		mockSystemProperties.setProperty("pSysProps1", "pSysProps1Value");
+		propertySources.replace(StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, mockSystemProperties);
+
+		// assert that servletconfig params resolve with higher precedence than sysprops
+		assertThat(environment.getProperty("pCommon")).isEqualTo("pCommonConfigValue");
+		assertThat(environment.getProperty("pSysProps1")).isEqualTo("pSysProps1Value");
+	}
+
+	@Test
+	void resourceAdapterApplicationContext() {
+		ResourceAdapterApplicationContext ctx = new ResourceAdapterApplicationContext(new SimpleBootstrapContext(new SimpleTaskWorkManager()));
+
+		assertHasStandardEnvironment(ctx);
+
+		registerEnvironmentBeanDefinition(ctx);
+
+		ctx.setEnvironment(prodEnv);
+		ctx.refresh();
+
+		assertHasEnvironment(ctx, prodEnv);
+		assertEnvironmentBeanRegistered(ctx);
+		assertEnvironmentAwareInvoked(ctx, prodEnv);
+	}
+
+	@Test
+	void abstractApplicationContextValidatesRequiredPropertiesOnRefresh() {
+		{
+			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
+			ctx.refresh();
+		}
+
+		{
+			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
+			ctx.getEnvironment().setRequiredProperties("foo", "bar");
+			assertThatExceptionOfType(MissingRequiredPropertiesException.class).isThrownBy(
+					ctx::refresh);
+		}
+
+		{
+			ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext();
+			ctx.getEnvironment().setRequiredProperties("foo");
+			ctx.setEnvironment(new MockEnvironment().withProperty("foo", "fooValue"));
+			ctx.refresh(); // should succeed
+		}
+	}
+
+
+	private DefaultListableBeanFactory newBeanFactoryWithEnvironmentAwareBean() {
+		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+		registerEnvironmentBeanDefinition(bf);
+		return bf;
+	}
+
+	private void registerEnvironmentBeanDefinition(BeanDefinitionRegistry registry) {
+		registry.registerBeanDefinition(ENVIRONMENT_AWARE_BEAN_NAME,
+				rootBeanDefinition(EnvironmentAwareBean.class).getBeanDefinition());
+	}
+
+	private void assertEnvironmentBeanRegistered(
+			ConfigurableApplicationContext ctx) {
+		// ensure environment is registered as a bean
+		assertThat(ctx.containsBean(ENVIRONMENT_BEAN_NAME)).isTrue();
+	}
+
+	private void assertHasStandardEnvironment(ApplicationContext ctx) {
+		Environment defaultEnv = ctx.getEnvironment();
+		assertThat(defaultEnv).isNotNull();
+		assertThat(defaultEnv).isInstanceOf(StandardEnvironment.class);
+	}
+
+	private void assertHasStandardServletEnvironment(WebApplicationContext ctx) {
+		// ensure a default servlet environment exists
+		Environment defaultEnv = ctx.getEnvironment();
+		assertThat(defaultEnv).isNotNull();
+		assertThat(defaultEnv).isInstanceOf(StandardServletEnvironment.class);
+	}
+
+	private void assertHasEnvironment(ApplicationContext ctx, Environment expectedEnv) {
+		// ensure the custom environment took
+		Environment actualEnv = ctx.getEnvironment();
+		assertThat(actualEnv).isNotNull();
+		assertThat(actualEnv).isEqualTo(expectedEnv);
+		// ensure environment is registered as a bean
+		assertThat(ctx.containsBean(ENVIRONMENT_BEAN_NAME)).isTrue();
+	}
+
+	private void assertEnvironmentAwareInvoked(ConfigurableApplicationContext ctx, Environment expectedEnv) {
+		assertThat(ctx.getBean(EnvironmentAwareBean.class).environment).isEqualTo(expectedEnv);
+	}
+
+
+	private static class EnvironmentAwareBean implements EnvironmentAware {
+
+		public Environment environment;
+
+		@Override
+		public void setEnvironment(Environment environment) {
+			this.environment = environment;
+		}
+	}
+
+
+	/**
+	 * Mirrors the structure of beans and environment-specific config files in
+	 * EnvironmentSystemIntegrationTests-context.xml
+	 */
+	@Configuration
+	@Import({DevConfig.class, ProdConfig.class})
+	static class Config {
+		@Bean
+		public EnvironmentAwareBean envAwareBean() {
+			return new EnvironmentAwareBean();
+		}
+	}
+
+	@Profile(DEV_ENV_NAME)
+	@Configuration
+	@Import(TransitiveConfig.class)
+	static class DevConfig {
+		@Bean
+		public Object devBean() {
+			return new Object();
+		}
+	}
+
+	@Profile(PROD_ENV_NAME)
+	@Configuration
+	static class ProdConfig {
+		@Bean
+		public Object prodBean() {
+			return new Object();
+		}
+	}
+
+	@Configuration
+	static class TransitiveConfig {
+		@Bean
+		public Object transitiveBean() {
+			return new Object();
+		}
+	}
+
+	@Profile(DERIVED_DEV_ENV_NAME)
+	@Configuration
+	static class DerivedDevConfig extends DevConfig {
+		@Bean
+		public Object derivedDevBean() {
+			return new Object();
+		}
+	}
+
+	@Profile("(p1 & p2) | p3")
+	@Configuration
+	static class ProfileExpressionConfig {
+		@Bean
+		public Object expressionBean() {
+			return new Object();
+		}
+	}
+
+
+	/**
+	 * Constants used both locally and in scan* sub-packages
+	 */
+	public static class Constants {
+
+		public static final String XML_PATH = "org/springframework/core/env/EnvironmentSystemIntegrationTests-context.xml";
+
+		public static final String ENVIRONMENT_AWARE_BEAN_NAME = "envAwareBean";
+
+		public static final String PROD_BEAN_NAME = "prodBean";
+		public static final String DEV_BEAN_NAME = "devBean";
+		public static final String DERIVED_DEV_BEAN_NAME = "derivedDevBean";
+		public static final String TRANSITIVE_BEAN_NAME = "transitiveBean";
+
+		public static final String PROD_ENV_NAME = "prod";
+		public static final String DEV_ENV_NAME = "dev";
+		public static final String DERIVED_DEV_ENV_NAME = "derivedDev";
+	}
+
+}

integration-tests/src/test/java/org/springframework/core/env/PropertyPlaceholderConfigurerEnvironmentIntegrationTests.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.context.support.GenericApplicationContext;
+
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.rootBeanDefinition;
+
+class PropertyPlaceholderConfigurerEnvironmentIntegrationTests {
+
+	@Test
+	@SuppressWarnings("deprecation")
+	void test() {
+		GenericApplicationContext ctx = new GenericApplicationContext();
+		ctx.registerBeanDefinition("ppc",
+				rootBeanDefinition(org.springframework.beans.factory.config.PropertyPlaceholderConfigurer.class)
+				.addPropertyValue("searchSystemEnvironment", false)
+				.getBeanDefinition());
+		ctx.refresh();
+		ctx.getBean("ppc");
+		ctx.close();
+	}
+
+}

integration-tests/src/test/java/org/springframework/core/env/scan1/Config.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env.scan1;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+@Configuration
+@Import({ DevConfig.class, ProdConfig.class })
+class Config {
+
+}

integration-tests/src/test/java/org/springframework/core/env/scan1/DevConfig.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env.scan1;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+
+@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME)
+@Configuration
+class DevConfig {
+
+	@Bean
+	public Object devBean() {
+		return new Object();
+	}
+
+}

integration-tests/src/test/java/org/springframework/core/env/scan1/ProdConfig.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env.scan1;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+
+@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME)
+@Configuration
+class ProdConfig {
+
+	@Bean
+	public Object prodBean() {
+		return new Object();
+	}
+
+}

integration-tests/src/test/java/org/springframework/core/env/scan2/DevBean.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env.scan2;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_ENV_NAME)
+@Component(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.DEV_BEAN_NAME)
+class DevBean {
+}

integration-tests/src/test/java/org/springframework/core/env/scan2/ProdBean.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env.scan2;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+@Profile(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_ENV_NAME)
+@Component(org.springframework.core.env.EnvironmentSystemIntegrationTests.Constants.PROD_BEAN_NAME)
+class ProdBean {
+
+}

integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.expression.spel.support;
+
+import java.beans.PropertyEditor;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.SimpleTypeConverter;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.core.convert.support.DefaultConversionService;
+import org.springframework.expression.TypeConverter;
+
+/**
+ * Copied from Spring Integration for purposes of reproducing
+ * {@link Spr7538Tests}.
+ */
+class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {
+
+	private SimpleTypeConverter delegate = new SimpleTypeConverter();
+
+	private static ConversionService defaultConversionService;
+
+	private ConversionService conversionService;
+
+	public BeanFactoryTypeConverter() {
+		synchronized (this) {
+			if (defaultConversionService == null) {
+				defaultConversionService = new DefaultConversionService();
+			}
+		}
+		this.conversionService = defaultConversionService;
+	}
+
+	public BeanFactoryTypeConverter(ConversionService conversionService) {
+		this.conversionService = conversionService;
+	}
+
+	public void setConversionService(ConversionService conversionService) {
+		this.conversionService = conversionService;
+	}
+
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		if (beanFactory instanceof ConfigurableBeanFactory) {
+			Object typeConverter = ((ConfigurableBeanFactory) beanFactory).getTypeConverter();
+			if (typeConverter instanceof SimpleTypeConverter) {
+				delegate = (SimpleTypeConverter) typeConverter;
+			}
+		}
+	}
+
+	public boolean canConvert(Class<?> sourceType, Class<?> targetType) {
+		if (conversionService.canConvert(sourceType, targetType)) {
+			return true;
+		}
+		if (!String.class.isAssignableFrom(sourceType) && !String.class.isAssignableFrom(targetType)) {
+			// PropertyEditor cannot convert non-Strings
+			return false;
+		}
+		if (!String.class.isAssignableFrom(sourceType)) {
+			return delegate.findCustomEditor(sourceType, null) != null || delegate.getDefaultEditor(sourceType) != null;
+		}
+		return delegate.findCustomEditor(targetType, null) != null || delegate.getDefaultEditor(targetType) != null;
+	}
+
+	@Override
+	public boolean canConvert(TypeDescriptor sourceTypeDescriptor, TypeDescriptor targetTypeDescriptor) {
+		if (conversionService.canConvert(sourceTypeDescriptor, targetTypeDescriptor)) {
+			return true;
+		}
+		// TODO: what does this mean? This method is not used in SpEL so probably ignorable?
+		Class<?> sourceType = sourceTypeDescriptor.getObjectType();
+		Class<?> targetType = targetTypeDescriptor.getObjectType();
+		return canConvert(sourceType, targetType);
+	}
+
+	@Override
+	public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) {
+		if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) {
+			return null;
+		}
+		if (conversionService.canConvert(sourceType, targetType)) {
+			return conversionService.convert(value, sourceType, targetType);
+		}
+		if (!String.class.isAssignableFrom(sourceType.getType())) {
+			PropertyEditor editor = delegate.findCustomEditor(sourceType.getType(), null);
+			editor.setValue(value);
+			return editor.getAsText();
+		}
+		return delegate.convertIfNecessary(value, targetType.getType());
+	}
+
+}

integration-tests/src/test/java/org/springframework/expression/spel/support/Spr7538Tests.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.expression.spel.support;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.expression.MethodExecutor;
+
+class Spr7538Tests {
+
+	@Test
+	void repro() throws Exception {
+		AlwaysTrueReleaseStrategy target = new AlwaysTrueReleaseStrategy();
+		BeanFactoryTypeConverter converter = new BeanFactoryTypeConverter();
+
+		StandardEvaluationContext context = new StandardEvaluationContext();
+		context.setTypeConverter(converter);
+
+		List<Foo> arguments = Collections.emptyList();
+
+		List<TypeDescriptor> paramDescriptors = new ArrayList<>();
+		Method method = AlwaysTrueReleaseStrategy.class.getMethod("checkCompleteness", List.class);
+		paramDescriptors.add(new TypeDescriptor(new MethodParameter(method, 0)));
+
+
+		List<TypeDescriptor> argumentTypes = new ArrayList<>();
+		argumentTypes.add(TypeDescriptor.forObject(arguments));
+		ReflectiveMethodResolver resolver = new ReflectiveMethodResolver();
+		MethodExecutor executor = resolver.resolve(context, target, "checkCompleteness", argumentTypes);
+
+		Object result = executor.execute(context, target, arguments);
+		System.out.println("Result: " + result);
+	}
+
+	static class AlwaysTrueReleaseStrategy {
+		public boolean checkCompleteness(List<Foo> messages) {
+			return true;
+		}
+	}
+
+	static class Foo{}
+}

integration-tests/src/test/java/org/springframework/scheduling/annotation/ScheduledAndTransactionalAnnotationIntegrationTests.java

@@ -0,0 +1,250 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.scheduling.annotation;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.aspectj.lang.annotation.Aspect;
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.testfixture.EnabledForTestGroups;
+import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.testfixture.CallCountingTransactionManager;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.mockito.Mockito.mock;
+import static org.springframework.core.testfixture.TestGroup.LONG_RUNNING;
+
+/**
+ * Integration tests cornering bug SPR-8651, which revealed that @Scheduled methods may
+ * not work well with beans that have already been proxied for other reasons such
+ * as @Transactional or @Async processing.
+ *
+ * @author Chris Beams
+ * @author Juergen Hoeller
+ * @since 3.1
+ */
+@SuppressWarnings("resource")
+@EnabledForTestGroups(LONG_RUNNING)
+class ScheduledAndTransactionalAnnotationIntegrationTests {
+
+	@Test
+	void failsWhenJdkProxyAndScheduledMethodNotPresentOnInterface() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, JdkProxyTxConfig.class, RepoConfigA.class);
+		assertThatExceptionOfType(BeanCreationException.class)
+			.isThrownBy(ctx::refresh)
+			.withCauseInstanceOf(IllegalStateException.class);
+	}
+
+	@Test
+	void succeedsWhenSubclassProxyAndScheduledMethodNotPresentOnInterface() throws InterruptedException {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, SubclassProxyTxConfig.class, RepoConfigA.class);
+		ctx.refresh();
+
+		Thread.sleep(100);  // allow @Scheduled method to be called several times
+
+		MyRepository repository = ctx.getBean(MyRepository.class);
+		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
+		assertThat(AopUtils.isCglibProxy(repository)).isEqualTo(true);
+		assertThat(repository.getInvocationCount()).isGreaterThan(0);
+		assertThat(txManager.commits).isGreaterThan(0);
+	}
+
+	@Test
+	void succeedsWhenJdkProxyAndScheduledMethodIsPresentOnInterface() throws InterruptedException {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, JdkProxyTxConfig.class, RepoConfigB.class);
+		ctx.refresh();
+
+		Thread.sleep(100);  // allow @Scheduled method to be called several times
+
+		MyRepositoryWithScheduledMethod repository = ctx.getBean(MyRepositoryWithScheduledMethod.class);
+		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
+		assertThat(AopUtils.isJdkDynamicProxy(repository)).isTrue();
+		assertThat(repository.getInvocationCount()).isGreaterThan(0);
+		assertThat(txManager.commits).isGreaterThan(0);
+	}
+
+	@Test
+	void withAspectConfig() throws InterruptedException {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(AspectConfig.class, MyRepositoryWithScheduledMethodImpl.class);
+		ctx.refresh();
+
+		Thread.sleep(100);  // allow @Scheduled method to be called several times
+
+		MyRepositoryWithScheduledMethod repository = ctx.getBean(MyRepositoryWithScheduledMethod.class);
+		assertThat(AopUtils.isCglibProxy(repository)).isTrue();
+		assertThat(repository.getInvocationCount()).isGreaterThan(0);
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class JdkProxyTxConfig {
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement(proxyTargetClass = true)
+	static class SubclassProxyTxConfig {
+	}
+
+
+	@Configuration
+	static class RepoConfigA {
+
+		@Bean
+		MyRepository repository() {
+			return new MyRepositoryImpl();
+		}
+	}
+
+
+	@Configuration
+	static class RepoConfigB {
+
+		@Bean
+		MyRepositoryWithScheduledMethod repository() {
+			return new MyRepositoryWithScheduledMethodImpl();
+		}
+	}
+
+
+	@Configuration
+	@EnableScheduling
+	static class Config {
+
+		@Bean
+		PlatformTransactionManager txManager() {
+			return new CallCountingTransactionManager();
+		}
+
+		@Bean
+		PersistenceExceptionTranslator peTranslator() {
+			return mock(PersistenceExceptionTranslator.class);
+		}
+
+		@Bean
+		static PersistenceExceptionTranslationPostProcessor peTranslationPostProcessor() {
+			return new PersistenceExceptionTranslationPostProcessor();
+		}
+	}
+
+
+	@Configuration
+	@EnableScheduling
+	static class AspectConfig {
+
+		@Bean
+		static AnnotationAwareAspectJAutoProxyCreator autoProxyCreator() {
+			AnnotationAwareAspectJAutoProxyCreator apc = new AnnotationAwareAspectJAutoProxyCreator();
+			apc.setProxyTargetClass(true);
+			return apc;
+		}
+
+		@Bean
+		static MyAspect myAspect() {
+			return new MyAspect();
+		}
+	}
+
+
+	@Aspect
+	public static class MyAspect {
+
+		private final AtomicInteger count = new AtomicInteger();
+
+		@org.aspectj.lang.annotation.Before("execution(* scheduled())")
+		public void checkTransaction() {
+			this.count.incrementAndGet();
+		}
+	}
+
+
+	public interface MyRepository {
+
+		int getInvocationCount();
+	}
+
+
+	@Repository
+	static class MyRepositoryImpl implements MyRepository {
+
+		private final AtomicInteger count = new AtomicInteger();
+
+		@Transactional
+		@Scheduled(fixedDelay = 5)
+		public void scheduled() {
+			this.count.incrementAndGet();
+		}
+
+		@Override
+		public int getInvocationCount() {
+			return this.count.get();
+		}
+	}
+
+
+	public interface MyRepositoryWithScheduledMethod {
+
+		int getInvocationCount();
+
+		void scheduled();
+	}
+
+
+	@Repository
+	static class MyRepositoryWithScheduledMethodImpl implements MyRepositoryWithScheduledMethod {
+
+		private final AtomicInteger count = new AtomicInteger();
+
+		@Autowired(required = false)
+		private MyAspect myAspect;
+
+		@Override
+		@Transactional
+		@Scheduled(fixedDelay = 5)
+		public void scheduled() {
+			this.count.incrementAndGet();
+		}
+
+		@Override
+		public int getInvocationCount() {
+			if (this.myAspect != null) {
+				assertThat(this.myAspect.count.get()).isEqualTo(this.count.get());
+			}
+			return this.count.get();
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/transaction/annotation/EnableTransactionManagementIntegrationTests.java

@@ -0,0 +1,331 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.transaction.annotation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import javax.sql.DataSource;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.concurrent.ConcurrentMapCache;
+import org.springframework.cache.support.SimpleCacheManager;
+import org.springframework.context.annotation.AdviceMode;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.ImportResource;
+import org.springframework.jdbc.datasource.DataSourceTransactionManager;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
+import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;
+import org.springframework.transaction.testfixture.CallCountingTransactionManager;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+/**
+ * Integration tests for the @EnableTransactionManagement annotation.
+ *
+ * @author Chris Beams
+ * @author Sam Brannen
+ * @since 3.1
+ */
+@SuppressWarnings("resource")
+class EnableTransactionManagementIntegrationTests {
+
+	@Test
+	void repositoryIsNotTxProxy() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
+
+		assertThat(isTxProxy(ctx.getBean(FooRepository.class))).isFalse();
+	}
+
+	@Test
+	void repositoryIsTxProxy_withDefaultTxManagerName() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, DefaultTxManagerNameConfig.class);
+
+		assertTxProxying(ctx);
+	}
+
+	@Test
+	void repositoryIsTxProxy_withCustomTxManagerName() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, CustomTxManagerNameConfig.class);
+
+		assertTxProxying(ctx);
+	}
+
+	@Test
+	void repositoryIsTxProxy_withNonConventionalTxManagerName_fallsBackToByTypeLookup() {
+		assertTxProxying(new AnnotationConfigApplicationContext(Config.class, NonConventionalTxManagerNameConfig.class));
+	}
+
+	@Test
+	void repositoryIsClassBasedTxProxy() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class, ProxyTargetClassTxConfig.class);
+
+		assertTxProxying(ctx);
+		assertThat(AopUtils.isCglibProxy(ctx.getBean(FooRepository.class))).isTrue();
+	}
+
+	@Test
+	void repositoryUsesAspectJAdviceMode() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(Config.class, AspectJTxConfig.class);
+		// this test is a bit fragile, but gets the job done, proving that an
+		// attempt was made to look up the AJ aspect. It's due to classpath issues
+		// in .integration-tests that it's not found.
+		assertThatExceptionOfType(Exception.class)
+			.isThrownBy(ctx::refresh)
+			.withMessageContaining("AspectJJtaTransactionManagementConfiguration");
+	}
+
+	@Test
+	void implicitTxManager() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ImplicitTxManagerConfig.class);
+
+		FooRepository fooRepository = ctx.getBean(FooRepository.class);
+		fooRepository.findAll();
+
+		CallCountingTransactionManager txManager = ctx.getBean(CallCountingTransactionManager.class);
+		assertThat(txManager.begun).isEqualTo(1);
+		assertThat(txManager.commits).isEqualTo(1);
+		assertThat(txManager.rollbacks).isEqualTo(0);
+	}
+
+	@Test
+	void explicitTxManager() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ExplicitTxManagerConfig.class);
+
+		FooRepository fooRepository = ctx.getBean(FooRepository.class);
+		fooRepository.findAll();
+
+		CallCountingTransactionManager txManager1 = ctx.getBean("txManager1", CallCountingTransactionManager.class);
+		assertThat(txManager1.begun).isEqualTo(1);
+		assertThat(txManager1.commits).isEqualTo(1);
+		assertThat(txManager1.rollbacks).isEqualTo(0);
+
+		CallCountingTransactionManager txManager2 = ctx.getBean("txManager2", CallCountingTransactionManager.class);
+		assertThat(txManager2.begun).isEqualTo(0);
+		assertThat(txManager2.commits).isEqualTo(0);
+		assertThat(txManager2.rollbacks).isEqualTo(0);
+	}
+
+	@Test
+	void apcEscalation() {
+		new AnnotationConfigApplicationContext(EnableTxAndCachingConfig.class);
+	}
+
+
+	private void assertTxProxying(AnnotationConfigApplicationContext ctx) {
+		FooRepository repo = ctx.getBean(FooRepository.class);
+		assertThat(isTxProxy(repo)).isTrue();
+		// trigger a transaction
+		repo.findAll();
+	}
+
+	private boolean isTxProxy(FooRepository repo) {
+		if (!AopUtils.isAopProxy(repo)) {
+			return false;
+		}
+		return Arrays.stream(((Advised) repo).getAdvisors())
+				.anyMatch(BeanFactoryTransactionAttributeSourceAdvisor.class::isInstance);
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	@ImportResource("org/springframework/transaction/annotation/enable-caching.xml")
+	static class EnableTxAndCachingConfig {
+
+		@Bean
+		public PlatformTransactionManager txManager() {
+			return new CallCountingTransactionManager();
+		}
+
+		@Bean
+		public FooRepository fooRepository() {
+			return new DummyFooRepository();
+		}
+
+		@Bean
+		public CacheManager cacheManager() {
+			SimpleCacheManager mgr = new SimpleCacheManager();
+			ArrayList<Cache> caches = new ArrayList<>();
+			caches.add(new ConcurrentMapCache(""));
+			mgr.setCaches(caches);
+			return mgr;
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class ImplicitTxManagerConfig {
+
+		@Bean
+		public PlatformTransactionManager txManager() {
+			return new CallCountingTransactionManager();
+		}
+
+		@Bean
+		public FooRepository fooRepository() {
+			return new DummyFooRepository();
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class ExplicitTxManagerConfig implements TransactionManagementConfigurer {
+
+		@Bean
+		public PlatformTransactionManager txManager1() {
+			return new CallCountingTransactionManager();
+		}
+
+		@Bean
+		public PlatformTransactionManager txManager2() {
+			return new CallCountingTransactionManager();
+		}
+
+		@Override
+		public PlatformTransactionManager annotationDrivenTransactionManager() {
+			return txManager1();
+		}
+
+		@Bean
+		public FooRepository fooRepository() {
+			return new DummyFooRepository();
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class DefaultTxManagerNameConfig {
+
+		@Bean
+		PlatformTransactionManager transactionManager(DataSource dataSource) {
+			return new DataSourceTransactionManager(dataSource);
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class CustomTxManagerNameConfig {
+
+		@Bean
+		PlatformTransactionManager txManager(DataSource dataSource) {
+			return new DataSourceTransactionManager(dataSource);
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement
+	static class NonConventionalTxManagerNameConfig {
+
+		@Bean
+		PlatformTransactionManager txManager(DataSource dataSource) {
+			return new DataSourceTransactionManager(dataSource);
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement(proxyTargetClass=true)
+	static class ProxyTargetClassTxConfig {
+
+		@Bean
+		PlatformTransactionManager transactionManager(DataSource dataSource) {
+			return new DataSourceTransactionManager(dataSource);
+		}
+	}
+
+
+	@Configuration
+	@EnableTransactionManagement(mode=AdviceMode.ASPECTJ)
+	static class AspectJTxConfig {
+
+		@Bean
+		PlatformTransactionManager transactionManager(DataSource dataSource) {
+			return new DataSourceTransactionManager(dataSource);
+		}
+	}
+
+
+	@Configuration
+	static class Config {
+
+		@Bean
+		FooRepository fooRepository() {
+			JdbcFooRepository repos = new JdbcFooRepository();
+			repos.setDataSource(dataSource());
+			return repos;
+		}
+
+		@Bean
+		DataSource dataSource() {
+			return new EmbeddedDatabaseBuilder()
+				.setType(EmbeddedDatabaseType.HSQL)
+				.build();
+		}
+	}
+
+
+	interface FooRepository {
+
+		List<Object> findAll();
+	}
+
+
+	@Repository
+	static class JdbcFooRepository implements FooRepository {
+
+		public void setDataSource(DataSource dataSource) {
+		}
+
+		@Override
+		@Transactional
+		public List<Object> findAll() {
+			return Collections.emptyList();
+		}
+	}
+
+
+	@Repository
+	static class DummyFooRepository implements FooRepository {
+
+		@Override
+		@Transactional
+		public List<Object> findAll() {
+			return Collections.emptyList();
+		}
+	}
+
+}

integration-tests/src/test/java/org/springframework/transaction/annotation/ProxyAnnotationDiscoveryTests.java

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.transaction.annotation;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.support.AopUtils;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Configuration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests proving that regardless the proxy strategy used (JDK interface-based vs. CGLIB
+ * subclass-based), discovery of advice-oriented annotations is consistent.
+ *
+ * For example, Spring's @Transactional may be declared at the interface or class level,
+ * and whether interface or subclass proxies are used, the @Transactional annotation must
+ * be discovered in a consistent fashion.
+ *
+ * @author Chris Beams
+ */
+@SuppressWarnings("resource")
+class ProxyAnnotationDiscoveryTests {
+
+	@Test
+	void annotatedServiceWithoutInterface_PTC_true() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCTrue.class, AnnotatedServiceWithoutInterface.class);
+		ctx.refresh();
+		AnnotatedServiceWithoutInterface s = ctx.getBean(AnnotatedServiceWithoutInterface.class);
+		assertThat(AopUtils.isCglibProxy(s)).isTrue();
+		assertThat(s).isInstanceOf(AnnotatedServiceWithoutInterface.class);
+	}
+
+	@Test
+	void annotatedServiceWithoutInterface_PTC_false() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCFalse.class, AnnotatedServiceWithoutInterface.class);
+		ctx.refresh();
+		AnnotatedServiceWithoutInterface s = ctx.getBean(AnnotatedServiceWithoutInterface.class);
+		assertThat(AopUtils.isCglibProxy(s)).isTrue();
+		assertThat(s).isInstanceOf(AnnotatedServiceWithoutInterface.class);
+	}
+
+	@Test
+	void nonAnnotatedService_PTC_true() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCTrue.class, AnnotatedServiceImpl.class);
+		ctx.refresh();
+		NonAnnotatedService s = ctx.getBean(NonAnnotatedService.class);
+		assertThat(AopUtils.isCglibProxy(s)).isTrue();
+		assertThat(s).isInstanceOf(AnnotatedServiceImpl.class);
+	}
+
+	@Test
+	void nonAnnotatedService_PTC_false() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCFalse.class, AnnotatedServiceImpl.class);
+		ctx.refresh();
+		NonAnnotatedService s = ctx.getBean(NonAnnotatedService.class);
+		assertThat(AopUtils.isJdkDynamicProxy(s)).isTrue();
+		assertThat(s).isNotInstanceOf(AnnotatedServiceImpl.class);
+	}
+
+	@Test
+	void annotatedService_PTC_true() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCTrue.class, NonAnnotatedServiceImpl.class);
+		ctx.refresh();
+		AnnotatedService s = ctx.getBean(AnnotatedService.class);
+		assertThat(AopUtils.isCglibProxy(s)).isTrue();
+		assertThat(s).isInstanceOf(NonAnnotatedServiceImpl.class);
+	}
+
+	@Test
+	void annotatedService_PTC_false() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(PTCFalse.class, NonAnnotatedServiceImpl.class);
+		ctx.refresh();
+		AnnotatedService s = ctx.getBean(AnnotatedService.class);
+		assertThat(AopUtils.isJdkDynamicProxy(s)).isTrue();
+		assertThat(s).isNotInstanceOf(NonAnnotatedServiceImpl.class);
+	}
+}
+
+@Configuration
+@EnableTransactionManagement(proxyTargetClass=false)
+class PTCFalse { }
+
+@Configuration
+@EnableTransactionManagement(proxyTargetClass=true)
+class PTCTrue { }
+
+interface NonAnnotatedService {
+	void m();
+}
+
+interface AnnotatedService {
+	@Transactional void m();
+}
+
+class NonAnnotatedServiceImpl implements AnnotatedService {
+	@Override
+	public void m() { }
+}
+
+class AnnotatedServiceImpl implements NonAnnotatedService {
+	@Override
+	@Transactional public void m() { }
+}
+
+class AnnotatedServiceWithoutInterface {
+	@Transactional public void m() { }
+}

integration-tests/src/test/resources/log4j2-test.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN">
+	<Appenders>
+		<Console name="Console" target="SYSTEM_OUT">
+			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{1.} - %msg%n" />
+		</Console>
+	</Appenders>
+	<Loggers>
+		<Root level="debug">
+			<AppenderRef ref="Console" />
+		</Root>
+	</Loggers>
+</Configuration>

integration-tests/src/test/resources/org/springframework/aop/config/AopNamespaceHandlerAdviceOrderIntegrationTests-afterFirst.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
+
+	<bean id="echo" class="org.springframework.aop.config.AopNamespaceHandlerAdviceOrderIntegrationTests$Echo"/>
+
+	<bean id="invocationTrackingAspect" class="org.springframework.aop.config.AopNamespaceHandlerAdviceOrderIntegrationTests$InvocationTrackingAspect" />
+
+	<aop:config>
+		<aop:aspect id="echoAdvice" ref="invocationTrackingAspect">
+			<aop:pointcut id="echoMethod" expression="execution(* echo(*))" />
+			<aop:around method="around" pointcut-ref="echoMethod" />
+			<aop:before method="before" pointcut-ref="echoMethod" />
+			<aop:after method="after" pointcut-ref="echoMethod" />
+			<aop:after-throwing method="afterThrowing" pointcut-ref="echoMethod" />
+			<aop:after-returning method="afterReturning" pointcut-ref="echoMethod" />
+		</aop:aspect>
+	</aop:config>
+
+</beans>

integration-tests/src/test/resources/org/springframework/aop/config/AopNamespaceHandlerAdviceOrderIntegrationTests-afterLast.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
+
+	<bean id="echo" class="org.springframework.aop.config.AopNamespaceHandlerAdviceOrderIntegrationTests$Echo"/>
+
+	<bean id="invocationTrackingAspect" class="org.springframework.aop.config.AopNamespaceHandlerAdviceOrderIntegrationTests$InvocationTrackingAspect" />
+
+	<aop:config>
+		<aop:aspect id="echoAdvice" ref="invocationTrackingAspect">
+			<aop:pointcut id="echoMethod" expression="execution(* echo(*))" />
+			<aop:around method="around" pointcut-ref="echoMethod" />
+			<aop:before method="before" pointcut-ref="echoMethod" />
+			<aop:after-throwing method="afterThrowing" pointcut-ref="echoMethod" />
+			<aop:after-returning method="afterReturning" pointcut-ref="echoMethod" />
+			<aop:after method="after" pointcut-ref="echoMethod" />
+		</aop:aspect>
+	</aop:config>
+
+</beans>

integration-tests/src/test/resources/org/springframework/aop/config/AopNamespaceHandlerScopeIntegrationTests-context.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:aop="http://www.springframework.org/schema/aop"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-2.0.xsd
+				http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
+
+	<aop:config>
+		<aop:advisor advice-ref="advice" pointcut="execution(* *..ITestBean.*(..))"/>
+	</aop:config>
+
+	<bean id="advice" class="org.springframework.aop.interceptor.DebugInterceptor"/>
+
+	<bean id="testBean" class="org.springframework.beans.testfixture.beans.TestBean"/>
+
+	<bean id="singletonScoped" class="org.springframework.beans.testfixture.beans.TestBean">
+		<aop:scoped-proxy/>
+		<property name="name" value="Rob Harrop"/>
+	</bean>
+
+	<bean id="requestScoped" class="org.springframework.beans.testfixture.beans.TestBean" scope="request">
+		<aop:scoped-proxy/>
+		<property name="name" value="Rob Harrop"/>
+	</bean>
+
+	<bean id="sessionScoped" name="sessionScopedAlias" class="org.springframework.beans.testfixture.beans.TestBean" scope="session">
+		<aop:scoped-proxy proxy-target-class="false"/>
+		<property name="name" value="Rob Harrop"/>
+	</bean>
+
+</beans>

integration-tests/src/test/resources/org/springframework/aop/framework/autoproxy/AdvisorAutoProxyCreatorIntegrationTests-context.xml

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "https://www.springframework.org/dtd/spring-beans-2.0.dtd">
+
+<!--
+	Common bean definitions for auto proxy creator tests.
+-->
+<beans>
+
+	<description>
+		Matches all Advisors in the factory: we don't use a prefix
+	</description>
+
+	<bean id="aapc" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
+
+	<!--
+		Depending on the order value, these beans should appear
+		before or after the transaction advisor. Thus we configure
+		them to check for or to refuse to accept a transaction.
+		The transaction advisor's order value is 10.
+	-->
+	<bean id="orderedBeforeTransaction" class="org.springframework.aop.framework.autoproxy.OrderedTxCheckAdvisor">
+		<property name="order"><value>9</value></property>
+		<property name="requireTransactionContext"><value>false</value></property>
+	</bean>
+
+	<bean id="orderedAfterTransaction" class="org.springframework.aop.framework.autoproxy.OrderedTxCheckAdvisor">
+		<property name="order"><value>11</value></property>
+		<property name="requireTransactionContext"><value>true</value></property>
+	</bean>
+
+	<bean id="orderedAfterTransaction2" class="org.springframework.aop.framework.autoproxy.OrderedTxCheckAdvisor">
+		<!-- Don't set order value: should remain Integer.MAX_VALUE, so it's non-ordered -->
+		<property name="requireTransactionContext"><value>true</value></property>
+	</bean>
+
+	<!-- Often we can leave the definition of such infrastructural beans to child factories -->
+	<bean id="txManager" class="org.springframework.transaction.testfixture.CallCountingTransactionManager"/>
+
+	<bean id="tas" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
+		<property name="properties">
+			<props>
+				<prop key="setA*">PROPAGATION_REQUIRED</prop>
+				<prop key="rollbackOnly">PROPAGATION_REQUIRED</prop>
+				<prop key="echoException">PROPAGATION_REQUIRED,+javax.servlet.ServletException,-java.lang.Exception</prop>
+			</props>
+		</property>
+	</bean>
+
+	<bean id="txInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
+		<property name="transactionManager"><ref bean="txManager"/></property>
+		<property name="transactionAttributeSource"><ref bean="tas"/></property>
+	</bean>
+
+	<bean id="txAdvisor" class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
+		<property name="transactionInterceptor"><ref bean="txInterceptor"/></property>
+		<property name="order"><value>10</value></property>
+	</bean>
+
+	<!-- ====== Test for prototype definitions to try to provoke circular references ========================= -->
+	<!--
+		This advisor should never match and should not change how any of the tests run,
+		but it's a prototype referencing another (unused) prototype, as well as a
+		singleton, so it may pose circular reference problems, or an infinite loop.
+	-->
+	<bean id="neverMatchAdvisor" class="org.springframework.aop.framework.autoproxy.NeverMatchAdvisor"
+			scope="prototype">
+		<property name="dependencies">
+			<list>
+				<ref bean="singletonDependency"/>
+				<ref bean="prototypeDependency"/>
+			</list>
+		</property>
+	</bean>
+
+	<!-- These two beans would otherwise be eligible for autoproxying -->
+
+	<bean id="singletonDependency" class="org.springframework.beans.testfixture.beans.TestBean" scope="singleton"/>
+
+	<bean id="prototypeDependency" class="org.springframework.beans.testfixture.beans.TestBean" scope="prototype"/>
+
+	<!-- ====== End test for prototype definitions to try to provoke circular references ========================= -->
+
+	<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
+		<property name="advice"><ref bean="countingAdvice"/></property>
+		<property name="pattern"><value>org.springframework.beans.testfixture.beans.ITestBean.getName</value></property>
+	</bean>
+
+	<bean id="countingAdvice" class="org.springframework.aop.testfixture.advice.CountingAfterReturningAdvice"/>
+
+	<bean id="test" class="org.springframework.beans.testfixture.beans.TestBean">
+		<property name="age"><value>4</value></property>
+	</bean>
+
+	<bean id="noSetters" class="org.springframework.aop.framework.autoproxy.NoSetters"/>
+
+	<bean id="rollback" class="org.springframework.aop.framework.autoproxy.Rollback"/>
+
+	<!-- The following beans test whether auto-proxying falls over for a null value -->
+
+	<bean id="tb" class="org.springframework.beans.testfixture.beans.TestBean"/>
+
+	<bean id="nullValueReturned" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
+		<property name="targetObject" ref="tb"/>
+		<property name="targetMethod" value="getSpouse"/>
+	</bean>
+
+</beans>

integration-tests/src/test/resources/org/springframework/beans/factory/xml/component-config.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      xmlns:foo="http://www.foo.example/schema/component"
+      xsi:schemaLocation="
+http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+http://www.foo.example/schema/component http://www.foo.example/schema/component/component.xsd">
+
+   <foo:component id="bionic-family" name="Bionic-1">
+      <foo:component name="Mother-1">
+      	<foo:component name="Karate-1"/>
+  		<foo:component name="Sport-1"/>
+      </foo:component>
+      <foo:component name="Rock-1"/>
+   </foo:component>
+
+</beans>

integration-tests/src/test/resources/org/springframework/beans/factory/xml/component.xsd

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+
+<xsd:schema xmlns="http://www.foo.example/schema/component"
+         xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+         targetNamespace="http://www.foo.example/schema/component"
+         elementFormDefault="qualified"
+         attributeFormDefault="unqualified">
+
+   <xsd:element name="component">
+      <xsd:complexType>
+         <xsd:choice minOccurs="0" maxOccurs="unbounded">
+            <xsd:element ref="component"/>
+         </xsd:choice>
+         <xsd:attribute name="id" type="xsd:ID"/>
+         <xsd:attribute name="name" use="required" type="xsd:string"/>
+      </xsd:complexType>
+   </xsd:element>
+
+</xsd:schema>

integration-tests/src/test/resources/org/springframework/context/annotation/ltw/ComponentScanningWithLTWTests.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:context="http://www.springframework.org/schema/context"
+	xsi:schemaLocation=
+		"http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"
+	default-autowire="byType">
+
+	<context:component-scan base-package="org.springframework.context.annotation">
+		<context:exclude-filter type="annotation"
+		                        expression="org.springframework.context.annotation.Configuration"/>
+	</context:component-scan>
+
+	<context:load-time-weaver aspectj-weaving="off"/>
+
+	<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" autowire="no"/>
+
+</beans>

integration-tests/src/test/resources/org/springframework/core/env/EnvironmentSystemIntegrationTests-context-dev.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-3.1.xsd"
+	profile="dev">
+
+	<bean id="devBean" class="java.lang.Object"/>
+
+</beans>

integration-tests/src/test/resources/org/springframework/core/env/EnvironmentSystemIntegrationTests-context-prod.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-3.1.xsd"
+	profile="prod">
+
+	<bean id="prodBean" class="java.lang.Object"/>
+
+</beans>

integration-tests/src/test/resources/org/springframework/core/env/EnvironmentSystemIntegrationTests-context.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
+
+	<bean id="envAwareBean" class="org.springframework.core.env.EnvironmentSystemIntegrationTests$EnvironmentAwareBean"/>
+
+	<import resource="classpath:org/springframework/core/env/EnvironmentSystemIntegrationTests-context-dev.xml"/>
+	<import resource="classpath:org/springframework/core/env/EnvironmentSystemIntegrationTests-context-prod.xml"/>
+
+</beans>

integration-tests/src/test/resources/org/springframework/transaction/annotation/enable-caching.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:cache="http://www.springframework.org/schema/cache"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/cache https://www.springframework.org/schema/cache/spring-cache.xsd">
+
+	<cache:annotation-driven/>
+
+</beans>

integration-tests/src/test/resources/org/springframework/util/testlog4j.properties

@@ -0,0 +1,2 @@
+log4j.rootCategory=DEBUG, mock
+log4j.appender.mock=org.springframework.util.MockLog4jAppender

integration-tests/src/test/resources/org/springframework/web/util/testlog4j.properties

@@ -0,0 +1,2 @@
+log4j.rootCategory=DEBUG, mock
+log4j.appender.mock=org.springframework.util.MockLog4jAppender

spring-aop/spring-aop.gradle

@@ -0,0 +1,12 @@
+description = "Spring AOP"
+
+dependencies {
+	compile(project(":spring-beans"))
+	compile(project(":spring-core"))
+	optional("org.aspectj:aspectjweaver")
+	optional("org.apache.commons:commons-pool2")
+	optional("com.jamonapi:jamon")
+	testCompile(testFixtures(project(":spring-beans")))
+	testCompile(testFixtures(project(":spring-core")))
+	testFixturesImplementation(testFixtures(project(":spring-core")))
+}

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.aop;
+
+/**
+ * Tag interface for Advice. Implementations can be any type
+ * of advice, such as Interceptors.
+ *
+ * @author Rod Johnson
+ * @version $Id: Advice.java,v 1.1 2004/03/19 17:02:16 johnsonr Exp $
+ */
+public interface Advice {
+
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.aop;
+
+/**
+ * Superclass for all AOP infrastructure exceptions.
+ * Unchecked, as such exceptions are fatal and end user
+ * code shouldn't be forced to catch them.
+ *
+ * @author Rod Johnson
+ * @author Bob Lee
+ * @author Juergen Hoeller
+ */
+@SuppressWarnings("serial")
+public class AspectException extends RuntimeException {
+
+	/**
+	 * Constructor for AspectException.
+	 * @param message the exception message
+	 */
+	public AspectException(String message) {
+		super(message);
+	}
+
+	/**
+	 * Constructor for AspectException.
+	 * @param message the exception message
+	 * @param cause the root cause, if any
+	 */
+	public AspectException(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+}

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

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

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Intercepts the construction of a new object.
+ *
+ * <p>The user should implement the {@link
+ * #construct(ConstructorInvocation)} method to modify the original
+ * behavior. E.g. the following class implements a singleton
+ * interceptor (allows only one unique instance for the intercepted
+ * class):
+ *
+ * <pre class=code>
+ * class DebuggingInterceptor implements ConstructorInterceptor {
+ *   Object instance=null;
+ *
+ *   Object construct(ConstructorInvocation i) throws Throwable {
+ *     if(instance==null) {
+ *       return instance=i.proceed();
+ *     } else {
+ *       throw new Exception("singleton does not allow multiple instance");
+ *     }
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ */
+public interface ConstructorInterceptor extends Interceptor  {
+
+	/**
+	 * Implement this method to perform extra treatments before and
+	 * after the construction of a new object. Polite implementations
+	 * would certainly like to invoke {@link Joinpoint#proceed()}.
+	 * @param invocation the construction joinpoint
+	 * @return the newly created object, which is also the result of
+	 * the call to {@link Joinpoint#proceed()}; might be replaced by
+	 * the interceptor
+	 * @throws Throwable if the interceptors or the target object
+	 * throws an exception
+	 */
+	@Nonnull
+	Object construct(ConstructorInvocation invocation) throws Throwable;
+
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import java.lang.reflect.Constructor;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Description of an invocation to a constructor, given to an
+ * interceptor upon constructor-call.
+ *
+ * <p>A constructor invocation is a joinpoint and can be intercepted
+ * by a constructor interceptor.
+ *
+ * @author Rod Johnson
+ * @see ConstructorInterceptor
+ */
+public interface ConstructorInvocation extends Invocation {
+
+	/**
+	 * Get the constructor being called.
+	 * <p>This method is a friendly implementation of the
+	 * {@link Joinpoint#getStaticPart()} method (same result).
+	 * @return the constructor being called
+	 */
+	@Nonnull
+	Constructor<?> getConstructor();
+
+}

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * This interface represents a generic interceptor.
+ *
+ * <p>A generic interceptor can intercept runtime events that occur
+ * within a base program. Those events are materialized by (reified
+ * in) joinpoints. Runtime joinpoints can be invocations, field
+ * access, exceptions...
+ *
+ * <p>This interface is not used directly. Use the sub-interfaces
+ * to intercept specific events. For instance, the following class
+ * implements some specific interceptors in order to implement a
+ * debugger:
+ *
+ * <pre class=code>
+ * class DebuggingInterceptor implements MethodInterceptor,
+ *     ConstructorInterceptor {
+ *
+ *   Object invoke(MethodInvocation i) throws Throwable {
+ *     debug(i.getMethod(), i.getThis(), i.getArgs());
+ *     return i.proceed();
+ *   }
+ *
+ *   Object construct(ConstructorInvocation i) throws Throwable {
+ *     debug(i.getConstructor(), i.getThis(), i.getArgs());
+ *     return i.proceed();
+ *   }
+ *
+ *   void debug(AccessibleObject ao, Object this, Object value) {
+ *     ...
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ * @see Joinpoint
+ */
+public interface Interceptor extends Advice {
+
+}

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import javax.annotation.Nonnull;
+
+/**
+ * This interface represents an invocation in the program.
+ *
+ * <p>An invocation is a joinpoint and can be intercepted by an
+ * interceptor.
+ *
+ * @author Rod Johnson
+ */
+public interface Invocation extends Joinpoint {
+
+	/**
+	 * Get the arguments as an array object.
+	 * It is possible to change element values within this
+	 * array to change the arguments.
+	 * @return the argument of the invocation
+	 */
+	@Nonnull
+	Object[] getArguments();
+
+}

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import java.lang.reflect.AccessibleObject;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * This interface represents a generic runtime joinpoint (in the AOP
+ * terminology).
+ *
+ * <p>A runtime joinpoint is an <i>event</i> that occurs on a static
+ * joinpoint (i.e. a location in a the program). For instance, an
+ * invocation is the runtime joinpoint on a method (static joinpoint).
+ * The static part of a given joinpoint can be generically retrieved
+ * using the {@link #getStaticPart()} method.
+ *
+ * <p>In the context of an interception framework, a runtime joinpoint
+ * is then the reification of an access to an accessible object (a
+ * method, a constructor, a field), i.e. the static part of the
+ * joinpoint. It is passed to the interceptors that are installed on
+ * the static joinpoint.
+ *
+ * @author Rod Johnson
+ * @see Interceptor
+ */
+public interface Joinpoint {
+
+	/**
+	 * Proceed to the next interceptor in the chain.
+	 * <p>The implementation and the semantics of this method depends
+	 * on the actual joinpoint type (see the children interfaces).
+	 * @return see the children interfaces' proceed definition
+	 * @throws Throwable if the joinpoint throws an exception
+	 */
+	@Nullable
+	Object proceed() throws Throwable;
+
+	/**
+	 * Return the object that holds the current joinpoint's static part.
+	 * <p>For instance, the target object for an invocation.
+	 * @return the object (can be null if the accessible object is static)
+	 */
+	@Nullable
+	Object getThis();
+
+	/**
+	 * Return the static part of this joinpoint.
+	 * <p>The static part is an accessible object on which a chain of
+	 * interceptors are installed.
+	 */
+	@Nonnull
+	AccessibleObject getStaticPart();
+
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Intercepts calls on an interface on its way to the target. These
+ * are nested "on top" of the target.
+ *
+ * <p>The user should implement the {@link #invoke(MethodInvocation)}
+ * method to modify the original behavior. E.g. the following class
+ * implements a tracing interceptor (traces all the calls on the
+ * intercepted method(s)):
+ *
+ * <pre class=code>
+ * class TracingInterceptor implements MethodInterceptor {
+ *   Object invoke(MethodInvocation i) throws Throwable {
+ *     System.out.println("method "+i.getMethod()+" is called on "+
+ *                        i.getThis()+" with args "+i.getArguments());
+ *     Object ret=i.proceed();
+ *     System.out.println("method "+i.getMethod()+" returns "+ret);
+ *     return ret;
+ *   }
+ * }
+ * </pre>
+ *
+ * @author Rod Johnson
+ */
+@FunctionalInterface
+public interface MethodInterceptor extends Interceptor {
+
+	/**
+	 * Implement this method to perform extra treatments before and
+	 * after the invocation. Polite implementations would certainly
+	 * like to invoke {@link Joinpoint#proceed()}.
+	 * @param invocation the method invocation joinpoint
+	 * @return the result of the call to {@link Joinpoint#proceed()};
+	 * might be intercepted by the interceptor
+	 * @throws Throwable if the interceptors or the target object
+	 * throws an exception
+	 */
+	@Nullable
+	Object invoke(@Nonnull MethodInvocation invocation) throws Throwable;
+
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.aopalliance.intercept;
+
+import java.lang.reflect.Method;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Description of an invocation to a method, given to an interceptor
+ * upon method-call.
+ *
+ * <p>A method invocation is a joinpoint and can be intercepted by a
+ * method interceptor.
+ *
+ * @author Rod Johnson
+ * @see MethodInterceptor
+ */
+public interface MethodInvocation extends Invocation {
+
+	/**
+	 * Get the method being called.
+	 * <p>This method is a friendly implementation of the
+	 * {@link Joinpoint#getStaticPart()} method (same result).
+	 * @return the method being called
+	 */
+	@Nonnull
+	Method getMethod();
+
+}

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

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

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

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

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Base interface holding AOP <b>advice</b> (action to take at a joinpoint)
+ * and a filter determining the applicability of the advice (such as
+ * a pointcut). <i>This interface is not for use by Spring users, but to
+ * allow for commonality in support for different types of advice.</i>
+ *
+ * <p>Spring AOP is based around <b>around advice</b> delivered via method
+ * <b>interception</b>, compliant with the AOP Alliance interception API.
+ * The Advisor interface allows support for different types of advice,
+ * such as <b>before</b> and <b>after</b> advice, which need not be
+ * implemented using interception.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ */
+public interface Advisor {
+
+	/**
+	 * Common placeholder for an empty {@code Advice} to be returned from
+	 * {@link #getAdvice()} if no proper advice has been configured (yet).
+	 * @since 5.0
+	 */
+	Advice EMPTY_ADVICE = new Advice() {};
+
+
+	/**
+	 * Return the advice part of this aspect. An advice may be an
+	 * interceptor, a before advice, a throws advice, etc.
+	 * @return the advice that should apply if the pointcut matches
+	 * @see org.aopalliance.intercept.MethodInterceptor
+	 * @see BeforeAdvice
+	 * @see ThrowsAdvice
+	 * @see AfterReturningAdvice
+	 */
+	Advice getAdvice();
+
+	/**
+	 * Return whether this advice is associated with a particular instance
+	 * (for example, creating a mixin) or shared with all instances of
+	 * the advised class obtained from the same Spring bean factory.
+	 * <p><b>Note that this method is not currently used by the framework.</b>
+	 * Typical Advisor implementations always return {@code true}.
+	 * Use singleton/prototype bean definitions or appropriate programmatic
+	 * proxy creation to ensure that Advisors have the correct lifecycle model.
+	 * @return whether this advice is associated with a particular target instance
+	 */
+	boolean isPerInstance();
+
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Common marker interface for after advice,
+ * such as {@link AfterReturningAdvice} and {@link ThrowsAdvice}.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.3
+ * @see BeforeAdvice
+ */
+public interface AfterAdvice extends Advice {
+
+}

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * After returning advice is invoked only on normal method return, not if an
+ * exception is thrown. Such advice can see the return value, but cannot change it.
+ *
+ * @author Rod Johnson
+ * @see MethodBeforeAdvice
+ * @see ThrowsAdvice
+ */
+public interface AfterReturningAdvice extends AfterAdvice {
+
+	/**
+	 * Callback after a given method successfully returned.
+	 * @param returnValue the value returned by the method, if any
+	 * @param method the method being invoked
+	 * @param args the arguments to the method
+	 * @param target the target of the method invocation. May be {@code null}.
+	 * @throws Throwable if this object wishes to abort the call.
+	 * Any exception thrown will be returned to the caller if it's
+	 * allowed by the method signature. Otherwise the exception
+	 * will be wrapped as a runtime exception.
+	 */
+	void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
+
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.springframework.core.NestedRuntimeException;
+
+/**
+ * Exception that gets thrown when an AOP invocation failed
+ * because of misconfiguration or unexpected runtime issues.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AopInvocationException extends NestedRuntimeException {
+
+	/**
+	 * Constructor for AopInvocationException.
+	 * @param msg the detail message
+	 */
+	public AopInvocationException(String msg) {
+		super(msg);
+	}
+
+	/**
+	 * Constructor for AopInvocationException.
+	 * @param msg the detail message
+	 * @param cause the root cause
+	 */
+	public AopInvocationException(String msg, Throwable cause) {
+		super(msg, cause);
+	}
+
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Common marker interface for before advice, such as {@link MethodBeforeAdvice}.
+ *
+ * <p>Spring supports only method before advice. Although this is unlikely to change,
+ * this API is designed to allow field advice in future if desired.
+ *
+ * @author Rod Johnson
+ * @see AfterAdvice
+ */
+public interface BeforeAdvice extends Advice {
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Filter that restricts matching of a pointcut or introduction to
+ * a given set of target classes.
+ *
+ * <p>Can be used as part of a {@link Pointcut} or for the entire
+ * targeting of an {@link IntroductionAdvisor}.
+ *
+ * <p>Concrete implementations of this interface typically should provide proper
+ * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
+ * in order to allow the filter to be used in caching scenarios &mdash; for
+ * example, in proxies generated by CGLIB.
+ *
+ * @author Rod Johnson
+ * @see Pointcut
+ * @see MethodMatcher
+ */
+@FunctionalInterface
+public interface ClassFilter {
+
+	/**
+	 * Should the pointcut apply to the given interface or target class?
+	 * @param clazz the candidate target class
+	 * @return whether the advice should apply to the given target class
+	 */
+	boolean matches(Class<?> clazz);
+
+
+	/**
+	 * Canonical instance of a ClassFilter that matches all classes.
+	 */
+	ClassFilter TRUE = TrueClassFilter.INSTANCE;
+
+}

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.aop.Advice;
+
+/**
+ * Subinterface of AOP Alliance Advice that allows additional interfaces
+ * to be implemented by an Advice, and available via a proxy using that
+ * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
+ *
+ * <p>Introductions are often <b>mixins</b>, enabling the building of composite
+ * objects that can achieve many of the goals of multiple inheritance in Java.
+ *
+ * <p>Compared to {qlink IntroductionInfo}, this interface allows an advice to
+ * implement a range of interfaces that is not necessarily known in advance.
+ * Thus an {@link IntroductionAdvisor} can be used to specify which interfaces
+ * will be exposed in an advised object.
+ *
+ * @author Rod Johnson
+ * @since 1.1.1
+ * @see IntroductionInfo
+ * @see IntroductionAdvisor
+ */
+public interface DynamicIntroductionAdvice extends Advice {
+
+	/**
+	 * Does this introduction advice implement the given interface?
+	 * @param intf the interface to check
+	 * @return whether the advice implements the specified interface
+	 */
+	boolean implementsInterface(Class<?> intf);
+
+}

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Superinterface for advisors that perform one or more AOP <b>introductions</b>.
+ *
+ * <p>This interface cannot be implemented directly; subinterfaces must
+ * provide the advice type implementing the introduction.
+ *
+ * <p>Introduction is the implementation of additional interfaces
+ * (not implemented by a target) via AOP advice.
+ *
+ * @author Rod Johnson
+ * @since 04.04.2003
+ * @see IntroductionInterceptor
+ */
+public interface IntroductionAdvisor extends Advisor, IntroductionInfo {
+
+	/**
+	 * Return the filter determining which target classes this introduction
+	 * should apply to.
+	 * <p>This represents the class part of a pointcut. Note that method
+	 * matching doesn't make sense to introductions.
+	 * @return the class filter
+	 */
+	ClassFilter getClassFilter();
+
+	/**
+	 * Can the advised interfaces be implemented by the introduction advice?
+	 * Invoked before adding an IntroductionAdvisor.
+	 * @throws IllegalArgumentException if the advised interfaces can't be
+	 * implemented by the introduction advice
+	 */
+	void validateInterfaces() throws IllegalArgumentException;
+
+}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+/**
+ * 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
+ */
+public interface IntroductionAwareMethodMatcher extends MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches. This may be invoked
+	 * instead of the 2-arg {@link #matches(java.lang.reflect.Method, Class)} method
+	 * if the caller supports the extended IntroductionAwareMethodMatcher interface.
+	 * @param method the candidate method
+	 * @param targetClass the target class
+	 * @param hasIntroductions {@code true} if the object on whose behalf we are
+	 * asking is the subject on one or more introductions; {@code false} otherwise
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions);
+
+}

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Interface supplying the information necessary to describe an introduction.
+ *
+ * <p>{@link IntroductionAdvisor IntroductionAdvisors} must implement this
+ * interface. If an {@link org.aopalliance.aop.Advice} implements this,
+ * it may be used as an introduction without an {@link IntroductionAdvisor}.
+ * In this case, the advice is self-describing, providing not only the
+ * necessary behavior, but describing the interfaces it introduces.
+ *
+ * @author Rod Johnson
+ * @since 1.1.1
+ */
+public interface IntroductionInfo {
+
+	/**
+	 * Return the additional interfaces introduced by this Advisor or Advice.
+	 * @return the introduced interfaces
+	 */
+	Class<?>[] getInterfaces();
+
+}

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.intercept.MethodInterceptor;
+
+/**
+ * Subinterface of AOP Alliance MethodInterceptor that allows additional interfaces
+ * to be implemented by the interceptor, and available via a proxy using that
+ * interceptor. This is a fundamental AOP concept called <b>introduction</b>.
+ *
+ * <p>Introductions are often <b>mixins</b>, enabling the building of composite
+ * objects that can achieve many of the goals of multiple inheritance in Java.
+ *
+ * @author Rod Johnson
+ * @see DynamicIntroductionAdvice
+ */
+public interface IntroductionInterceptor extends MethodInterceptor, DynamicIntroductionAdvice {
+
+}

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * Advice invoked before a method is invoked. Such advices cannot
+ * prevent the method call proceeding, unless they throw a Throwable.
+ *
+ * @author Rod Johnson
+ * @see AfterReturningAdvice
+ * @see ThrowsAdvice
+ */
+public interface MethodBeforeAdvice extends BeforeAdvice {
+
+	/**
+	 * Callback before a given method is invoked.
+	 * @param method the method being invoked
+	 * @param args the arguments to the method
+	 * @param target the target of the method invocation. May be {@code null}.
+	 * @throws Throwable if this object wishes to abort the call.
+	 * Any exception thrown will be returned to the caller if it's
+	 * allowed by the method signature. Otherwise the exception
+	 * will be wrapped as a runtime exception.
+	 */
+	void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
+
+}

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.lang.reflect.Method;
+
+/**
+ * Part of a {@link Pointcut}: Checks whether the target method is eligible for advice.
+ *
+ * <p>A MethodMatcher may be evaluated <b>statically</b> or at <b>runtime</b> (dynamically).
+ * Static matching involves method and (possibly) method attributes. Dynamic matching
+ * also makes arguments for a particular call available, and any effects of running
+ * previous advice applying to the joinpoint.
+ *
+ * <p>If an implementation returns {@code false} from its {@link #isRuntime()}
+ * method, evaluation can be performed statically, and the result will be the same
+ * for all invocations of this method, whatever their arguments. This means that
+ * if the {@link #isRuntime()} method returns {@code false}, the 3-arg
+ * {@link #matches(java.lang.reflect.Method, Class, Object[])} method will never be invoked.
+ *
+ * <p>If an implementation returns {@code true} from its 2-arg
+ * {@link #matches(java.lang.reflect.Method, Class)} method and its {@link #isRuntime()} method
+ * returns {@code true}, the 3-arg {@link #matches(java.lang.reflect.Method, Class, Object[])}
+ * method will be invoked <i>immediately before each potential execution of the related advice</i>,
+ * to decide whether the advice should run. All previous advice, such as earlier interceptors
+ * in an interceptor chain, will have run, so any state changes they have produced in
+ * parameters or ThreadLocal state will be available at the time of evaluation.
+ *
+ * <p>Concrete implementations of this interface typically should provide proper
+ * implementations of {@link Object#equals(Object)} and {@link Object#hashCode()}
+ * in order to allow the matcher to be used in caching scenarios &mdash; for
+ * example, in proxies generated by CGLIB.
+ *
+ * @author Rod Johnson
+ * @since 11.11.2003
+ * @see Pointcut
+ * @see ClassFilter
+ */
+public interface MethodMatcher {
+
+	/**
+	 * Perform static checking whether the given method matches.
+	 * <p>If this returns {@code false} or if the {@link #isRuntime()}
+	 * method returns {@code false}, no runtime check (i.e. no
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} call)
+	 * will be made.
+	 * @param method the candidate method
+	 * @param targetClass the target class
+	 * @return whether or not this method matches statically
+	 */
+	boolean matches(Method method, Class<?> targetClass);
+
+	/**
+	 * Is this MethodMatcher dynamic, that is, must a final call be made on the
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at
+	 * runtime even if the 2-arg matches method returns {@code true}?
+	 * <p>Can be invoked when an AOP proxy is created, and need not be invoked
+	 * again before each method invocation,
+	 * @return whether or not a runtime match via the 3-arg
+	 * {@link #matches(java.lang.reflect.Method, Class, Object[])} method
+	 * is required if static matching passed
+	 */
+	boolean isRuntime();
+
+	/**
+	 * Check whether there a runtime (dynamic) match for this method,
+	 * which must have matched statically.
+	 * <p>This method is invoked only if the 2-arg matches method returns
+	 * {@code true} for the given method and target class, and if the
+	 * {@link #isRuntime()} method returns {@code true}. Invoked
+	 * immediately before potential running of the advice, after any
+	 * advice earlier in the advice chain has run.
+	 * @param method the candidate method
+	 * @param targetClass the target class
+	 * @param args arguments to the method
+	 * @return whether there's a runtime match
+	 * @see MethodMatcher#matches(Method, Class)
+	 */
+	boolean matches(Method method, Class<?> targetClass, Object... args);
+
+
+	/**
+	 * Canonical instance that matches all methods.
+	 */
+	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
+
+}

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Core Spring pointcut abstraction.
+ *
+ * <p>A pointcut is composed of a {@link ClassFilter} and a {@link MethodMatcher}.
+ * Both these basic terms and a Pointcut itself can be combined to build up combinations
+ * (e.g. through {@link org.springframework.aop.support.ComposablePointcut}).
+ *
+ * @author Rod Johnson
+ * @see ClassFilter
+ * @see MethodMatcher
+ * @see org.springframework.aop.support.Pointcuts
+ * @see org.springframework.aop.support.ClassFilters
+ * @see org.springframework.aop.support.MethodMatchers
+ */
+public interface Pointcut {
+
+	/**
+	 * Return the ClassFilter for this pointcut.
+	 * @return the ClassFilter (never {@code null})
+	 */
+	ClassFilter getClassFilter();
+
+	/**
+	 * Return the MethodMatcher for this pointcut.
+	 * @return the MethodMatcher (never {@code null})
+	 */
+	MethodMatcher getMethodMatcher();
+
+
+	/**
+	 * Canonical Pointcut instance that always matches.
+	 */
+	Pointcut TRUE = TruePointcut.INSTANCE;
+
+}

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Superinterface for all Advisors that are driven by a pointcut.
+ * This covers nearly all advisors except introduction advisors,
+ * for which method-level matching doesn't apply.
+ *
+ * @author Rod Johnson
+ */
+public interface PointcutAdvisor extends Advisor {
+
+	/**
+	 * Get the Pointcut that drives this advisor.
+	 */
+	Pointcut getPointcut();
+
+}

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * Extension of the AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}
+ * interface, allowing access to the proxy that the method invocation was made through.
+ *
+ * <p>Useful to be able to substitute return values with the proxy,
+ * if necessary, for example if the invocation target returned itself.
+ *
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @since 1.1.3
+ * @see org.springframework.aop.framework.ReflectiveMethodInvocation
+ * @see org.springframework.aop.support.DelegatingIntroductionInterceptor
+ */
+public interface ProxyMethodInvocation extends MethodInvocation {
+
+	/**
+	 * Return the proxy that this method invocation was made through.
+	 * @return the original proxy object
+	 */
+	Object getProxy();
+
+	/**
+	 * Create a clone of this object. If cloning is done before {@code proceed()}
+	 * is invoked on this object, {@code proceed()} can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @return an invocable clone of this invocation.
+	 * {@code proceed()} can be called once per clone.
+	 */
+	MethodInvocation invocableClone();
+
+	/**
+	 * Create a clone of this object. If cloning is done before {@code proceed()}
+	 * is invoked on this object, {@code proceed()} can be invoked once per clone
+	 * to invoke the joinpoint (and the rest of the advice chain) more than once.
+	 * @param arguments the arguments that the cloned invocation is supposed to use,
+	 * overriding the original arguments
+	 * @return an invocable clone of this invocation.
+	 * {@code proceed()} can be called once per clone.
+	 */
+	MethodInvocation invocableClone(Object... arguments);
+
+	/**
+	 * Set the arguments to be used on subsequent invocations in the any advice
+	 * in this chain.
+	 * @param arguments the argument array
+	 */
+	void setArguments(Object... arguments);
+
+	/**
+	 * Add the specified user attribute with the given value to this invocation.
+	 * <p>Such attributes are not used within the AOP framework itself. They are
+	 * just kept as part of the invocation object, for use in special interceptors.
+	 * @param key the name of the attribute
+	 * @param value the value of the attribute, or {@code null} to reset it
+	 */
+	void setUserAttribute(String key, @Nullable Object value);
+
+	/**
+	 * Return the value of the specified user attribute.
+	 * @param key the name of the attribute
+	 * @return the value of the attribute, or {@code null} if not set
+	 * @see #setUserAttribute
+	 */
+	@Nullable
+	Object getUserAttribute(String key);
+
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Marker for AOP proxy interfaces (in particular: introduction interfaces)
+ * that explicitly intend to return the raw target object (which would normally
+ * get replaced with the proxy object when returned from a method invocation).
+ *
+ * <p>Note that this is a marker interface in the style of {@link java.io.Serializable},
+ * semantically applying to a declared interface rather than to the full class
+ * of a concrete object. In other words, this marker applies to a particular
+ * interface only (typically an introduction interface that does not serve
+ * as the primary interface of an AOP proxy), and hence does not affect
+ * other interfaces that a concrete AOP proxy may implement.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.5
+ * @see org.springframework.aop.scope.ScopedObject
+ */
+public interface RawTargetAccess {
+
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2002-2007 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Marker interface implemented by all AOP proxies. Used to detect
+ * whether or not objects are Spring-generated proxies.
+ *
+ * @author Rob Harrop
+ * @since 2.0.1
+ * @see org.springframework.aop.support.AopUtils#isAopProxy(Object)
+ */
+public interface SpringProxy {
+
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * Minimal interface for exposing the target class behind a proxy.
+ *
+ * <p>Implemented by AOP proxy objects and proxy factories
+ * (via {@link org.springframework.aop.framework.Advised})
+ * as well as by {@link TargetSource TargetSources}.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.3
+ * @see org.springframework.aop.support.AopUtils#getTargetClass(Object)
+ */
+public interface TargetClassAware {
+
+	/**
+	 * Return the target class behind the implementing object
+	 * (typically a proxy configuration or an actual proxy).
+	 * @return the target Class, or {@code null} if not known
+	 */
+	@Nullable
+	Class<?> getTargetClass();
+
+}

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * A {@code TargetSource} is used to obtain the current "target" of
+ * an AOP invocation, which will be invoked via reflection if no around
+ * advice chooses to end the interceptor chain itself.
+ *
+ * <p>If a {@code TargetSource} is "static", it will always return
+ * the same target, allowing optimizations in the AOP framework. Dynamic
+ * target sources can support pooling, hot swapping, etc.
+ *
+ * <p>Application developers don't usually need to work with
+ * {@code TargetSources} directly: this is an AOP framework interface.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ */
+public interface TargetSource extends TargetClassAware {
+
+	/**
+	 * Return the type of targets returned by this {@link TargetSource}.
+	 * <p>Can return {@code null}, although certain usages of a {@code TargetSource}
+	 * might just work with a predetermined target class.
+	 * @return the type of targets returned by this {@link TargetSource}
+	 */
+	@Override
+	@Nullable
+	Class<?> getTargetClass();
+
+	/**
+	 * Will all calls to {@link #getTarget()} return the same object?
+	 * <p>In that case, there will be no need to invoke {@link #releaseTarget(Object)},
+	 * and the AOP framework can cache the return value of {@link #getTarget()}.
+	 * @return {@code true} if the target is immutable
+	 * @see #getTarget
+	 */
+	boolean isStatic();
+
+	/**
+	 * Return a target instance. Invoked immediately before the
+	 * AOP framework calls the "target" of an AOP method invocation.
+	 * @return the target object which contains the joinpoint,
+	 * or {@code null} if there is no actual target instance
+	 * @throws Exception if the target object can't be resolved
+	 */
+	@Nullable
+	Object getTarget() throws Exception;
+
+	/**
+	 * Release the given target object obtained from the
+	 * {@link #getTarget()} method, if any.
+	 * @param target object obtained from a call to {@link #getTarget()}
+	 * @throws Exception if the object can't be released
+	 */
+	void releaseTarget(Object target) throws Exception;
+
+}

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2008 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+/**
+ * Tag interface for throws advice.
+ *
+ * <p>There are not any methods on this interface, as methods are invoked by
+ * reflection. Implementing classes must implement methods of the form:
+ *
+ * <pre class="code">void afterThrowing([Method, args, target], ThrowableSubclass);</pre>
+ *
+ * <p>Some examples of valid methods would be:
+ *
+ * <pre class="code">public void afterThrowing(Exception ex)</pre>
+ * <pre class="code">public void afterThrowing(RemoteException)</pre>
+ * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre>
+ * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre>
+ *
+ * The first three arguments are optional, and only useful if we want further
+ * information about the joinpoint, as in AspectJ <b>after-throwing</b> advice.
+ *
+ * <p><b>Note:</b> If a throws-advice method throws an exception itself, it will
+ * override the original exception (i.e. change the exception thrown to the user).
+ * The overriding exception will typically be a RuntimeException; this is compatible
+ * with any method signature. However, if a throws-advice method throws a checked
+ * exception, it will have to match the declared exceptions of the target method
+ * and is hence to some degree coupled to specific target method signatures.
+ * <b>Do not throw an undeclared checked exception that is incompatible with
+ * the target method's signature!</b>
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @see AfterReturningAdvice
+ * @see MethodBeforeAdvice
+ */
+public interface ThrowsAdvice extends AfterAdvice {
+
+}

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.io.Serializable;
+
+/**
+ * Canonical ClassFilter instance that matches all classes.
+ *
+ * @author Rod Johnson
+ */
+@SuppressWarnings("serial")
+final class TrueClassFilter implements ClassFilter, Serializable {
+
+	public static final TrueClassFilter INSTANCE = new TrueClassFilter();
+
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TrueClassFilter() {
+	}
+
+	@Override
+	public boolean matches(Class<?> clazz) {
+		return true;
+	}
+
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding {@code equals()}.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+
+	@Override
+	public String toString() {
+		return "ClassFilter.TRUE";
+	}
+
+}

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+/**
+ * Canonical MethodMatcher instance that matches all methods.
+ *
+ * @author Rod Johnson
+ */
+@SuppressWarnings("serial")
+final class TrueMethodMatcher implements MethodMatcher, Serializable {
+
+	public static final TrueMethodMatcher INSTANCE = new TrueMethodMatcher();
+
+
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TrueMethodMatcher() {
+	}
+
+
+	@Override
+	public boolean isRuntime() {
+		return false;
+	}
+
+	@Override
+	public boolean matches(Method method, Class<?> targetClass) {
+		return true;
+	}
+
+	@Override
+	public boolean matches(Method method, Class<?> targetClass, Object... args) {
+		// Should never be invoked as isRuntime returns false.
+		throw new UnsupportedOperationException();
+	}
+
+
+	@Override
+	public String toString() {
+		return "MethodMatcher.TRUE";
+	}
+
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding {@code equals()}.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop;
+
+import java.io.Serializable;
+
+/**
+ * Canonical Pointcut instance that always matches.
+ *
+ * @author Rod Johnson
+ */
+@SuppressWarnings("serial")
+final class TruePointcut implements Pointcut, Serializable {
+
+	public static final TruePointcut INSTANCE = new TruePointcut();
+
+	/**
+	 * Enforce Singleton pattern.
+	 */
+	private TruePointcut() {
+	}
+
+	@Override
+	public ClassFilter getClassFilter() {
+		return ClassFilter.TRUE;
+	}
+
+	@Override
+	public MethodMatcher getMethodMatcher() {
+		return MethodMatcher.TRUE;
+	}
+
+	/**
+	 * Required to support serialization. Replaces with canonical
+	 * instance on deserialization, protecting Singleton pattern.
+	 * Alternative to overriding {@code equals()}.
+	 */
+	private Object readResolve() {
+		return INSTANCE;
+	}
+
+	@Override
+	public String toString() {
+		return "Pointcut.TRUE";
+	}
+
+}

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

@@ -0,0 +1,735 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.aopalliance.aop.Advice;
+import org.aopalliance.intercept.MethodInvocation;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.weaver.tools.JoinPointMatch;
+import org.aspectj.weaver.tools.PointcutParameter;
+
+import org.springframework.aop.AopInvocationException;
+import org.springframework.aop.MethodMatcher;
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+import org.springframework.aop.support.ComposablePointcut;
+import org.springframework.aop.support.MethodMatchers;
+import org.springframework.aop.support.StaticMethodMatcher;
+import org.springframework.core.DefaultParameterNameDiscoverer;
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * Base class for AOP Alliance {@link org.aopalliance.aop.Advice} classes
+ * wrapping an AspectJ aspect or an AspectJ-annotated advice method.
+ *
+ * @author Rod Johnson
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public abstract class AbstractAspectJAdvice implements Advice, AspectJPrecedenceInformation, Serializable {
+
+	/**
+	 * Key used in ReflectiveMethodInvocation userAttributes map for the current joinpoint.
+	 */
+	protected static final String JOIN_POINT_KEY = JoinPoint.class.getName();
+
+
+	/**
+	 * Lazily instantiate joinpoint for the current invocation.
+	 * Requires MethodInvocation to be bound with ExposeInvocationInterceptor.
+	 * <p>Do not use if access is available to the current ReflectiveMethodInvocation
+	 * (in an around advice).
+	 * @return current AspectJ joinpoint, or through an exception if we're not in a
+	 * Spring AOP invocation.
+	 */
+	public static JoinPoint currentJoinPoint() {
+		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+		if (!(mi instanceof ProxyMethodInvocation)) {
+			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+		}
+		ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
+		JoinPoint jp = (JoinPoint) pmi.getUserAttribute(JOIN_POINT_KEY);
+		if (jp == null) {
+			jp = new MethodInvocationProceedingJoinPoint(pmi);
+			pmi.setUserAttribute(JOIN_POINT_KEY, jp);
+		}
+		return jp;
+	}
+
+
+	private final Class<?> declaringClass;
+
+	private final String methodName;
+
+	private final Class<?>[] parameterTypes;
+
+	protected transient Method aspectJAdviceMethod;
+
+	private final AspectJExpressionPointcut pointcut;
+
+	private final AspectInstanceFactory aspectInstanceFactory;
+
+	/**
+	 * The name of the aspect (ref bean) in which this advice was defined
+	 * (used when determining advice precedence so that we can determine
+	 * whether two pieces of advice come from the same aspect).
+	 */
+	private String aspectName = "";
+
+	/**
+	 * The order of declaration of this advice within the aspect.
+	 */
+	private int declarationOrder;
+
+	/**
+	 * This will be non-null if the creator of this advice object knows the argument names
+	 * and sets them explicitly.
+	 */
+	@Nullable
+	private String[] argumentNames;
+
+	/** Non-null if after throwing advice binds the thrown value. */
+	@Nullable
+	private String throwingName;
+
+	/** Non-null if after returning advice binds the return value. */
+	@Nullable
+	private String returningName;
+
+	private Class<?> discoveredReturningType = Object.class;
+
+	private Class<?> discoveredThrowingType = Object.class;
+
+	/**
+	 * Index for thisJoinPoint argument (currently only
+	 * supported at index 0 if present at all).
+	 */
+	private int joinPointArgumentIndex = -1;
+
+	/**
+	 * Index for thisJoinPointStaticPart argument (currently only
+	 * supported at index 0 if present at all).
+	 */
+	private int joinPointStaticPartArgumentIndex = -1;
+
+	@Nullable
+	private Map<String, Integer> argumentBindings;
+
+	private boolean argumentsIntrospected = false;
+
+	@Nullable
+	private Type discoveredReturningGenericType;
+	// Note: Unlike return type, no such generic information is needed for the throwing type,
+	// since Java doesn't allow exception types to be parameterized.
+
+
+	/**
+	 * Create a new AbstractAspectJAdvice for the given advice method.
+	 * @param aspectJAdviceMethod the AspectJ-style advice method
+	 * @param pointcut the AspectJ expression pointcut
+	 * @param aspectInstanceFactory the factory for aspect instances
+	 */
+	public AbstractAspectJAdvice(
+			Method aspectJAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aspectInstanceFactory) {
+
+		Assert.notNull(aspectJAdviceMethod, "Advice method must not be null");
+		this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
+		this.methodName = aspectJAdviceMethod.getName();
+		this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
+		this.aspectJAdviceMethod = aspectJAdviceMethod;
+		this.pointcut = pointcut;
+		this.aspectInstanceFactory = aspectInstanceFactory;
+	}
+
+
+	/**
+	 * Return the AspectJ-style advice method.
+	 */
+	public final Method getAspectJAdviceMethod() {
+		return this.aspectJAdviceMethod;
+	}
+
+	/**
+	 * Return the AspectJ expression pointcut.
+	 */
+	public final AspectJExpressionPointcut getPointcut() {
+		calculateArgumentBindings();
+		return this.pointcut;
+	}
+
+	/**
+	 * Build a 'safe' pointcut that excludes the AspectJ advice method itself.
+	 * @return a composable pointcut that builds on the original AspectJ expression pointcut
+	 * @see #getPointcut()
+	 */
+	public final Pointcut buildSafePointcut() {
+		Pointcut pc = getPointcut();
+		MethodMatcher safeMethodMatcher = MethodMatchers.intersection(
+				new AdviceExcludingMethodMatcher(this.aspectJAdviceMethod), pc.getMethodMatcher());
+		return new ComposablePointcut(pc.getClassFilter(), safeMethodMatcher);
+	}
+
+	/**
+	 * Return the factory for aspect instances.
+	 */
+	public final AspectInstanceFactory getAspectInstanceFactory() {
+		return this.aspectInstanceFactory;
+	}
+
+	/**
+	 * Return the ClassLoader for aspect instances.
+	 */
+	@Nullable
+	public final ClassLoader getAspectClassLoader() {
+		return this.aspectInstanceFactory.getAspectClassLoader();
+	}
+
+	@Override
+	public int getOrder() {
+		return this.aspectInstanceFactory.getOrder();
+	}
+
+
+	/**
+	 * Set the name of the aspect (bean) in which the advice was declared.
+	 */
+	public void setAspectName(String name) {
+		this.aspectName = name;
+	}
+
+	@Override
+	public String getAspectName() {
+		return this.aspectName;
+	}
+
+	/**
+	 * Set the declaration order of this advice within the aspect.
+	 */
+	public void setDeclarationOrder(int order) {
+		this.declarationOrder = order;
+	}
+
+	@Override
+	public int getDeclarationOrder() {
+		return this.declarationOrder;
+	}
+
+	/**
+	 * Set by creator of this advice object if the argument names are known.
+	 * <p>This could be for example because they have been explicitly specified in XML,
+	 * or in an advice annotation.
+	 * @param argNames comma delimited list of arg names
+	 */
+	public void setArgumentNames(String argNames) {
+		String[] tokens = StringUtils.commaDelimitedListToStringArray(argNames);
+		setArgumentNamesFromStringArray(tokens);
+	}
+
+	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]);
+			if (!isVariableName(this.argumentNames[i])) {
+				throw new IllegalArgumentException(
+						"'argumentNames' property of AbstractAspectJAdvice contains an argument name '" +
+						this.argumentNames[i] + "' that is not a valid Java identifier");
+			}
+		}
+		if (this.argumentNames != null) {
+			if (this.aspectJAdviceMethod.getParameterCount() == this.argumentNames.length + 1) {
+				// May need to add implicit join point arg name...
+				Class<?> firstArgType = this.aspectJAdviceMethod.getParameterTypes()[0];
+				if (firstArgType == JoinPoint.class ||
+						firstArgType == ProceedingJoinPoint.class ||
+						firstArgType == JoinPoint.StaticPart.class) {
+					String[] oldNames = this.argumentNames;
+					this.argumentNames = new String[oldNames.length + 1];
+					this.argumentNames[0] = "THIS_JOIN_POINT";
+					System.arraycopy(oldNames, 0, this.argumentNames, 1, oldNames.length);
+				}
+			}
+		}
+	}
+
+	public void setReturningName(String name) {
+		throw new UnsupportedOperationException("Only afterReturning advice can be used to bind a return value");
+	}
+
+	/**
+	 * We need to hold the returning name at this level for argument binding calculations,
+	 * this method allows the afterReturning advice subclass to set the name.
+	 */
+	protected void setReturningNameNoCheck(String name) {
+		// name could be a variable or a type...
+		if (isVariableName(name)) {
+			this.returningName = name;
+		}
+		else {
+			// assume a type
+			try {
+				this.discoveredReturningType = ClassUtils.forName(name, getAspectClassLoader());
+			}
+			catch (Throwable ex) {
+				throw new IllegalArgumentException("Returning name '" + name  +
+						"' is neither a valid argument name nor the fully-qualified " +
+						"name of a Java type on the classpath. Root cause: " + ex);
+			}
+		}
+	}
+
+	protected Class<?> getDiscoveredReturningType() {
+		return this.discoveredReturningType;
+	}
+
+	@Nullable
+	protected Type getDiscoveredReturningGenericType() {
+		return this.discoveredReturningGenericType;
+	}
+
+	public void setThrowingName(String name) {
+		throw new UnsupportedOperationException("Only afterThrowing advice can be used to bind a thrown exception");
+	}
+
+	/**
+	 * We need to hold the throwing name at this level for argument binding calculations,
+	 * this method allows the afterThrowing advice subclass to set the name.
+	 */
+	protected void setThrowingNameNoCheck(String name) {
+		// name could be a variable or a type...
+		if (isVariableName(name)) {
+			this.throwingName = name;
+		}
+		else {
+			// assume a type
+			try {
+				this.discoveredThrowingType = ClassUtils.forName(name, getAspectClassLoader());
+			}
+			catch (Throwable ex) {
+				throw new IllegalArgumentException("Throwing name '" + name  +
+						"' is neither a valid argument name nor the fully-qualified " +
+						"name of a Java type on the classpath. Root cause: " + ex);
+			}
+		}
+	}
+
+	protected Class<?> getDiscoveredThrowingType() {
+		return this.discoveredThrowingType;
+	}
+
+	private static boolean isVariableName(String name) {
+		return AspectJProxyUtils.isVariableName(name);
+	}
+
+
+	/**
+	 * Do as much work as we can as part of the set-up so that argument binding
+	 * on subsequent advice invocations can be as fast as possible.
+	 * <p>If the first argument is of type JoinPoint or ProceedingJoinPoint then we
+	 * pass a JoinPoint in that position (ProceedingJoinPoint for around advice).
+	 * <p>If the first argument is of type {@code JoinPoint.StaticPart}
+	 * then we pass a {@code JoinPoint.StaticPart} in that position.
+	 * <p>Remaining arguments have to be bound by pointcut evaluation at
+	 * a given join point. We will get back a map from argument name to
+	 * value. We need to calculate which advice parameter needs to be bound
+	 * to which argument name. There are multiple strategies for determining
+	 * this binding, which are arranged in a ChainOfResponsibility.
+	 */
+	public final synchronized void calculateArgumentBindings() {
+		// The simple case... nothing to bind.
+		if (this.argumentsIntrospected || this.parameterTypes.length == 0) {
+			return;
+		}
+
+		int numUnboundArgs = this.parameterTypes.length;
+		Class<?>[] parameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+		if (maybeBindJoinPoint(parameterTypes[0]) || maybeBindProceedingJoinPoint(parameterTypes[0]) ||
+				maybeBindJoinPointStaticPart(parameterTypes[0])) {
+			numUnboundArgs--;
+		}
+
+		if (numUnboundArgs > 0) {
+			// need to bind arguments by name as returned from the pointcut match
+			bindArgumentsByName(numUnboundArgs);
+		}
+
+		this.argumentsIntrospected = true;
+	}
+
+	private boolean maybeBindJoinPoint(Class<?> candidateParameterType) {
+		if (JoinPoint.class == candidateParameterType) {
+			this.joinPointArgumentIndex = 0;
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	private boolean maybeBindProceedingJoinPoint(Class<?> candidateParameterType) {
+		if (ProceedingJoinPoint.class == candidateParameterType) {
+			if (!supportsProceedingJoinPoint()) {
+				throw new IllegalArgumentException("ProceedingJoinPoint is only supported for around advice");
+			}
+			this.joinPointArgumentIndex = 0;
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	protected boolean supportsProceedingJoinPoint() {
+		return false;
+	}
+
+	private boolean maybeBindJoinPointStaticPart(Class<?> candidateParameterType) {
+		if (JoinPoint.StaticPart.class == candidateParameterType) {
+			this.joinPointStaticPartArgumentIndex = 0;
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	private void bindArgumentsByName(int numArgumentsExpectingToBind) {
+		if (this.argumentNames == null) {
+			this.argumentNames = createParameterNameDiscoverer().getParameterNames(this.aspectJAdviceMethod);
+		}
+		if (this.argumentNames != null) {
+			// We have been able to determine the arg names.
+			bindExplicitArguments(numArgumentsExpectingToBind);
+		}
+		else {
+			throw new IllegalStateException("Advice method [" + this.aspectJAdviceMethod.getName() + "] " +
+					"requires " + numArgumentsExpectingToBind + " arguments to be bound by name, but " +
+					"the argument names were not specified and could not be discovered.");
+		}
+	}
+
+	/**
+	 * Create a ParameterNameDiscoverer to be used for argument binding.
+	 * <p>The default implementation creates a {@link DefaultParameterNameDiscoverer}
+	 * and adds a specifically configured {@link AspectJAdviceParameterNameDiscoverer}.
+	 */
+	protected ParameterNameDiscoverer createParameterNameDiscoverer() {
+		// We need to discover them, or if that fails, guess,
+		// and if we can't guess with 100% accuracy, fail.
+		DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();
+		AspectJAdviceParameterNameDiscoverer adviceParameterNameDiscoverer =
+				new AspectJAdviceParameterNameDiscoverer(this.pointcut.getExpression());
+		adviceParameterNameDiscoverer.setReturningName(this.returningName);
+		adviceParameterNameDiscoverer.setThrowingName(this.throwingName);
+		// Last in chain, so if we're called and we fail, that's bad...
+		adviceParameterNameDiscoverer.setRaiseExceptions(true);
+		discoverer.addDiscoverer(adviceParameterNameDiscoverer);
+		return discoverer;
+	}
+
+	private void bindExplicitArguments(int numArgumentsLeftToBind) {
+		Assert.state(this.argumentNames != null, "No argument names available");
+		this.argumentBindings = new HashMap<>();
+
+		int numExpectedArgumentNames = this.aspectJAdviceMethod.getParameterCount();
+		if (this.argumentNames.length != numExpectedArgumentNames) {
+			throw new IllegalStateException("Expecting to find " + numExpectedArgumentNames +
+					" arguments to bind by name in advice, but actually found " +
+					this.argumentNames.length + " arguments.");
+		}
+
+		// So we match in number...
+		int argumentIndexOffset = this.parameterTypes.length - numArgumentsLeftToBind;
+		for (int i = argumentIndexOffset; i < this.argumentNames.length; i++) {
+			this.argumentBindings.put(this.argumentNames[i], i);
+		}
+
+		// Check that returning and throwing were in the argument names list if
+		// specified, and find the discovered argument types.
+		if (this.returningName != null) {
+			if (!this.argumentBindings.containsKey(this.returningName)) {
+				throw new IllegalStateException("Returning argument name '" + this.returningName +
+						"' was not bound in advice arguments");
+			}
+			else {
+				Integer index = this.argumentBindings.get(this.returningName);
+				this.discoveredReturningType = this.aspectJAdviceMethod.getParameterTypes()[index];
+				this.discoveredReturningGenericType = this.aspectJAdviceMethod.getGenericParameterTypes()[index];
+			}
+		}
+		if (this.throwingName != null) {
+			if (!this.argumentBindings.containsKey(this.throwingName)) {
+				throw new IllegalStateException("Throwing argument name '" + this.throwingName +
+						"' was not bound in advice arguments");
+			}
+			else {
+				Integer index = this.argumentBindings.get(this.throwingName);
+				this.discoveredThrowingType = this.aspectJAdviceMethod.getParameterTypes()[index];
+			}
+		}
+
+		// configure the pointcut expression accordingly.
+		configurePointcutParameters(this.argumentNames, argumentIndexOffset);
+	}
+
+	/**
+	 * All parameters from argumentIndexOffset onwards are candidates for
+	 * pointcut parameters - but returning and throwing vars are handled differently
+	 * and must be removed from the list if present.
+	 */
+	private void configurePointcutParameters(String[] argumentNames, int argumentIndexOffset) {
+		int numParametersToRemove = argumentIndexOffset;
+		if (this.returningName != null) {
+			numParametersToRemove++;
+		}
+		if (this.throwingName != null) {
+			numParametersToRemove++;
+		}
+		String[] pointcutParameterNames = new String[argumentNames.length - numParametersToRemove];
+		Class<?>[] pointcutParameterTypes = new Class<?>[pointcutParameterNames.length];
+		Class<?>[] methodParameterTypes = this.aspectJAdviceMethod.getParameterTypes();
+
+		int index = 0;
+		for (int i = 0; i < argumentNames.length; i++) {
+			if (i < argumentIndexOffset) {
+				continue;
+			}
+			if (argumentNames[i].equals(this.returningName) ||
+				argumentNames[i].equals(this.throwingName)) {
+				continue;
+			}
+			pointcutParameterNames[index] = argumentNames[i];
+			pointcutParameterTypes[index] = methodParameterTypes[i];
+			index++;
+		}
+
+		this.pointcut.setParameterNames(pointcutParameterNames);
+		this.pointcut.setParameterTypes(pointcutParameterTypes);
+	}
+
+	/**
+	 * Take the arguments at the method execution join point and output a set of arguments
+	 * to the advice method.
+	 * @param jp the current JoinPoint
+	 * @param jpMatch the join point match that matched this execution join point
+	 * @param returnValue the return value from the method execution (may be null)
+	 * @param ex the exception thrown by the method execution (may be null)
+	 * @return the empty array if there are no arguments
+	 */
+	protected Object[] argBinding(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
+			@Nullable Object returnValue, @Nullable Throwable ex) {
+
+		calculateArgumentBindings();
+
+		// AMC start
+		Object[] adviceInvocationArgs = new Object[this.parameterTypes.length];
+		int numBound = 0;
+
+		if (this.joinPointArgumentIndex != -1) {
+			adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
+			numBound++;
+		}
+		else if (this.joinPointStaticPartArgumentIndex != -1) {
+			adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
+			numBound++;
+		}
+
+		if (!CollectionUtils.isEmpty(this.argumentBindings)) {
+			// binding from pointcut match
+			if (jpMatch != null) {
+				PointcutParameter[] parameterBindings = jpMatch.getParameterBindings();
+				for (PointcutParameter parameter : parameterBindings) {
+					String name = parameter.getName();
+					Integer index = this.argumentBindings.get(name);
+					adviceInvocationArgs[index] = parameter.getBinding();
+					numBound++;
+				}
+			}
+			// binding from returning clause
+			if (this.returningName != null) {
+				Integer index = this.argumentBindings.get(this.returningName);
+				adviceInvocationArgs[index] = returnValue;
+				numBound++;
+			}
+			// binding from thrown exception
+			if (this.throwingName != null) {
+				Integer index = this.argumentBindings.get(this.throwingName);
+				adviceInvocationArgs[index] = ex;
+				numBound++;
+			}
+		}
+
+		if (numBound != this.parameterTypes.length) {
+			throw new IllegalStateException("Required to bind " + this.parameterTypes.length +
+					" arguments, but only bound " + numBound + " (JoinPointMatch " +
+					(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
+		}
+
+		return adviceInvocationArgs;
+	}
+
+
+	/**
+	 * Invoke the advice method.
+	 * @param jpMatch the JoinPointMatch that matched this execution join point
+	 * @param returnValue the return value from the method execution (may be null)
+	 * @param ex the exception thrown by the method execution (may be null)
+	 * @return the invocation result
+	 * @throws Throwable in case of invocation failure
+	 */
+	protected Object invokeAdviceMethod(
+			@Nullable JoinPointMatch jpMatch, @Nullable Object returnValue, @Nullable Throwable ex)
+			throws Throwable {
+
+		return invokeAdviceMethodWithGivenArgs(argBinding(getJoinPoint(), jpMatch, returnValue, ex));
+	}
+
+	// As above, but in this case we are given the join point.
+	protected Object invokeAdviceMethod(JoinPoint jp, @Nullable JoinPointMatch jpMatch,
+			@Nullable Object returnValue, @Nullable Throwable t) throws Throwable {
+
+		return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
+	}
+
+	protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
+		Object[] actualArgs = args;
+		if (this.aspectJAdviceMethod.getParameterCount() == 0) {
+			actualArgs = null;
+		}
+		try {
+			ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
+			return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
+		}
+		catch (IllegalArgumentException ex) {
+			throw new AopInvocationException("Mismatch on arguments to advice method [" +
+					this.aspectJAdviceMethod + "]; pointcut expression [" +
+					this.pointcut.getPointcutExpression() + "]", ex);
+		}
+		catch (InvocationTargetException ex) {
+			throw ex.getTargetException();
+		}
+	}
+
+	/**
+	 * Overridden in around advice to return proceeding join point.
+	 */
+	protected JoinPoint getJoinPoint() {
+		return currentJoinPoint();
+	}
+
+	/**
+	 * Get the current join point match at the join point we are being dispatched on.
+	 */
+	@Nullable
+	protected JoinPointMatch getJoinPointMatch() {
+		MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+		if (!(mi instanceof ProxyMethodInvocation)) {
+			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+		}
+		return getJoinPointMatch((ProxyMethodInvocation) mi);
+	}
+
+	// Note: We can't use JoinPointMatch.getClass().getName() as the key, since
+	// Spring AOP does all the matching at a join point, and then all the invocations.
+	// Under this scenario, if we just use JoinPointMatch as the key, then
+	// 'last man wins' which is not what we want at all.
+	// Using the expression is guaranteed to be safe, since 2 identical expressions
+	// are guaranteed to bind in exactly the same way.
+	@Nullable
+	protected JoinPointMatch getJoinPointMatch(ProxyMethodInvocation pmi) {
+		String expression = this.pointcut.getExpression();
+		return (expression != null ? (JoinPointMatch) pmi.getUserAttribute(expression) : null);
+	}
+
+
+	@Override
+	public String toString() {
+		return getClass().getName() + ": advice method [" + this.aspectJAdviceMethod + "]; " +
+				"aspect name '" + this.aspectName + "'";
+	}
+
+	private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
+		inputStream.defaultReadObject();
+		try {
+			this.aspectJAdviceMethod = this.declaringClass.getMethod(this.methodName, this.parameterTypes);
+		}
+		catch (NoSuchMethodException ex) {
+			throw new IllegalStateException("Failed to find advice method on deserialization", ex);
+		}
+	}
+
+
+	/**
+	 * MethodMatcher that excludes the specified advice method.
+	 * @see AbstractAspectJAdvice#buildSafePointcut()
+	 */
+	private static class AdviceExcludingMethodMatcher extends StaticMethodMatcher {
+
+		private final Method adviceMethod;
+
+		public AdviceExcludingMethodMatcher(Method adviceMethod) {
+			this.adviceMethod = adviceMethod;
+		}
+
+		@Override
+		public boolean matches(Method method, Class<?> targetClass) {
+			return !this.adviceMethod.equals(method);
+		}
+
+		@Override
+		public boolean equals(@Nullable Object other) {
+			if (this == other) {
+				return true;
+			}
+			if (!(other instanceof AdviceExcludingMethodMatcher)) {
+				return false;
+			}
+			AdviceExcludingMethodMatcher otherMm = (AdviceExcludingMethodMatcher) other;
+			return this.adviceMethod.equals(otherMm.adviceMethod);
+		}
+
+		@Override
+		public int hashCode() {
+			return this.adviceMethod.hashCode();
+		}
+
+		@Override
+		public String toString() {
+			return getClass().getName() + ": " + this.adviceMethod;
+		}
+	}
+
+}

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.springframework.core.Ordered;
+import org.springframework.lang.Nullable;
+
+/**
+ * Interface implemented to provide an instance of an AspectJ aspect.
+ * Decouples from Spring's bean factory.
+ *
+ * <p>Extends the {@link org.springframework.core.Ordered} interface
+ * to express an order value for the underlying aspect in a chain.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ * @see org.springframework.beans.factory.BeanFactory#getBean
+ */
+public interface AspectInstanceFactory extends Ordered {
+
+	/**
+	 * Create an instance of this factory's aspect.
+	 * @return the aspect instance (never {@code null})
+	 */
+	Object getAspectInstance();
+
+	/**
+	 * Expose the aspect class loader that this factory uses.
+	 * @return the aspect class loader (or {@code null} for the bootstrap loader)
+	 * @see org.springframework.util.ClassUtils#getDefaultClassLoader()
+	 */
+	@Nullable
+	ClassLoader getAspectClassLoader();
+
+}

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

@@ -0,0 +1,790 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.weaver.tools.PointcutParser;
+import org.aspectj.weaver.tools.PointcutPrimitive;
+
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
+
+/**
+ * {@link ParameterNameDiscoverer} implementation that tries to deduce parameter names
+ * for an advice method from the pointcut expression, returning, and throwing clauses.
+ * If an unambiguous interpretation is not available, it returns {@code null}.
+ *
+ * <p>This class interprets arguments in the following way:
+ * <ol>
+ * <li>If the first parameter of the method is of type {@link JoinPoint}
+ * or {@link ProceedingJoinPoint}, it is assumed to be for passing
+ * {@code thisJoinPoint} to the advice, and the parameter name will
+ * be assigned the value {@code "thisJoinPoint"}.</li>
+ * <li>If the first parameter of the method is of type
+ * {@code JoinPoint.StaticPart}, it is assumed to be for passing
+ * {@code "thisJoinPointStaticPart"} to the advice, and the parameter name
+ * will be assigned the value {@code "thisJoinPointStaticPart"}.</li>
+ * <li>If a {@link #setThrowingName(String) throwingName} has been set, and
+ * there are no unbound arguments of type {@code Throwable+}, then an
+ * {@link IllegalArgumentException} is raised. If there is more than one
+ * unbound argument of type {@code Throwable+}, then an
+ * {@link AmbiguousBindingException} is raised. If there is exactly one
+ * unbound argument of type {@code Throwable+}, then the corresponding
+ * parameter name is assigned the value &lt;throwingName&gt;.</li>
+ * <li>If there remain unbound arguments, then the pointcut expression is
+ * examined. Let {@code a} be the number of annotation-based pointcut
+ * expressions (&#64;annotation, &#64;this, &#64;target, &#64;args,
+ * &#64;within, &#64;withincode) that are used in binding form. Usage in
+ * binding form has itself to be deduced: if the expression inside the
+ * pointcut is a single string literal that meets Java variable name
+ * conventions it is assumed to be a variable name. If {@code a} is
+ * zero we proceed to the next stage. If {@code a} &gt; 1 then an
+ * {@code AmbiguousBindingException} is raised. If {@code a} == 1,
+ * and there are no unbound arguments of type {@code Annotation+},
+ * then an {@code IllegalArgumentException} is raised. if there is
+ * exactly one such argument, then the corresponding parameter name is
+ * assigned the value from the pointcut expression.</li>
+ * <li>If a returningName has been set, and there are no unbound arguments
+ * then an {@code IllegalArgumentException} is raised. If there is
+ * more than one unbound argument then an
+ * {@code AmbiguousBindingException} is raised. If there is exactly
+ * one unbound argument then the corresponding parameter name is assigned
+ * the value &lt;returningName&gt;.</li>
+ * <li>If there remain unbound arguments, then the pointcut expression is
+ * examined once more for {@code this}, {@code target}, and
+ * {@code args} pointcut expressions used in the binding form (binding
+ * forms are deduced as described for the annotation based pointcuts). If
+ * there remains more than one unbound argument of a primitive type (which
+ * can only be bound in {@code args}) then an
+ * {@code AmbiguousBindingException} is raised. If there is exactly
+ * one argument of a primitive type, then if exactly one {@code args}
+ * bound variable was found, we assign the corresponding parameter name
+ * the variable name. If there were no {@code args} bound variables
+ * found an {@code IllegalStateException} is raised. If there are
+ * multiple {@code args} bound variables, an
+ * {@code AmbiguousBindingException} is raised. At this point, if
+ * there remains more than one unbound argument we raise an
+ * {@code AmbiguousBindingException}. If there are no unbound arguments
+ * remaining, we are done. If there is exactly one unbound argument
+ * remaining, and only one candidate variable name unbound from
+ * {@code this}, {@code target}, or {@code args}, it is
+ * assigned as the corresponding parameter name. If there are multiple
+ * possibilities, an {@code AmbiguousBindingException} is raised.</li>
+ * </ol>
+ *
+ * <p>The behavior on raising an {@code IllegalArgumentException} or
+ * {@code AmbiguousBindingException} is configurable to allow this discoverer
+ * to be used as part of a chain-of-responsibility. By default the condition will
+ * be logged and the {@code getParameterNames(..)} method will simply return
+ * {@code null}. If the {@link #setRaiseExceptions(boolean) raiseExceptions}
+ * property is set to {@code true}, the conditions will be thrown as
+ * {@code IllegalArgumentException} and {@code AmbiguousBindingException},
+ * respectively.
+ *
+ * <p>Was that perfectly clear? ;)
+ *
+ * <p>Short version: If an unambiguous binding can be deduced, then it is.
+ * If the advice requirements cannot possibly be satisfied, then {@code null}
+ * is returned. By setting the {@link #setRaiseExceptions(boolean) raiseExceptions}
+ * property to {@code true}, descriptive exceptions will be thrown instead of
+ * returning {@code null} in the case that the parameter names cannot be discovered.
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJAdviceParameterNameDiscoverer implements ParameterNameDiscoverer {
+
+	private static final String THIS_JOIN_POINT = "thisJoinPoint";
+	private static final String THIS_JOIN_POINT_STATIC_PART = "thisJoinPointStaticPart";
+
+	// Steps in the binding algorithm...
+	private static final int STEP_JOIN_POINT_BINDING = 1;
+	private static final int STEP_THROWING_BINDING = 2;
+	private static final int STEP_ANNOTATION_BINDING = 3;
+	private static final int STEP_RETURNING_BINDING = 4;
+	private static final int STEP_PRIMITIVE_ARGS_BINDING = 5;
+	private static final int STEP_THIS_TARGET_ARGS_BINDING = 6;
+	private static final int STEP_REFERENCE_PCUT_BINDING = 7;
+	private static final int STEP_FINISHED = 8;
+
+	private static final Set<String> singleValuedAnnotationPcds = new HashSet<>();
+	private static final Set<String> nonReferencePointcutTokens = new HashSet<>();
+
+
+	static {
+		singleValuedAnnotationPcds.add("@this");
+		singleValuedAnnotationPcds.add("@target");
+		singleValuedAnnotationPcds.add("@within");
+		singleValuedAnnotationPcds.add("@withincode");
+		singleValuedAnnotationPcds.add("@annotation");
+
+		Set<PointcutPrimitive> pointcutPrimitives = PointcutParser.getAllSupportedPointcutPrimitives();
+		for (PointcutPrimitive primitive : pointcutPrimitives) {
+			nonReferencePointcutTokens.add(primitive.getName());
+		}
+		nonReferencePointcutTokens.add("&&");
+		nonReferencePointcutTokens.add("!");
+		nonReferencePointcutTokens.add("||");
+		nonReferencePointcutTokens.add("and");
+		nonReferencePointcutTokens.add("or");
+		nonReferencePointcutTokens.add("not");
+	}
+
+
+	/** The pointcut expression associated with the advice, as a simple String. */
+	@Nullable
+	private String pointcutExpression;
+
+	private boolean raiseExceptions;
+
+	/** If the advice is afterReturning, and binds the return value, this is the parameter name used. */
+	@Nullable
+	private String returningName;
+
+	/** If the advice is afterThrowing, and binds the thrown value, this is the parameter name used. */
+	@Nullable
+	private String throwingName;
+
+	private Class<?>[] argumentTypes = new Class<?>[0];
+
+	private String[] parameterNameBindings = new String[0];
+
+	private int numberOfRemainingUnboundArguments;
+
+
+	/**
+	 * Create a new discoverer that attempts to discover parameter names.
+	 * from the given pointcut expression.
+	 */
+	public AspectJAdviceParameterNameDiscoverer(@Nullable String pointcutExpression) {
+		this.pointcutExpression = pointcutExpression;
+	}
+
+
+	/**
+	 * Indicate whether {@link IllegalArgumentException} and {@link AmbiguousBindingException}
+	 * must be thrown as appropriate in the case of failing to deduce advice parameter names.
+	 * @param raiseExceptions {@code true} if exceptions are to be thrown
+	 */
+	public void setRaiseExceptions(boolean raiseExceptions) {
+		this.raiseExceptions = raiseExceptions;
+	}
+
+	/**
+	 * If {@code afterReturning} advice binds the return value, the
+	 * returning variable name must be specified.
+	 * @param returningName the name of the returning variable
+	 */
+	public void setReturningName(@Nullable String returningName) {
+		this.returningName = returningName;
+	}
+
+	/**
+	 * If {@code afterThrowing} advice binds the thrown value, the
+	 * throwing variable name must be specified.
+	 * @param throwingName the name of the throwing variable
+	 */
+	public void setThrowingName(@Nullable String throwingName) {
+		this.throwingName = throwingName;
+	}
+
+
+	/**
+	 * Deduce the parameter names for an advice method.
+	 * <p>See the {@link AspectJAdviceParameterNameDiscoverer class level javadoc}
+	 * for this class for details of the algorithm used.
+	 * @param method the target {@link Method}
+	 * @return the parameter names
+	 */
+	@Override
+	@Nullable
+	public String[] getParameterNames(Method method) {
+		this.argumentTypes = method.getParameterTypes();
+		this.numberOfRemainingUnboundArguments = this.argumentTypes.length;
+		this.parameterNameBindings = new String[this.numberOfRemainingUnboundArguments];
+
+		int minimumNumberUnboundArgs = 0;
+		if (this.returningName != null) {
+			minimumNumberUnboundArgs++;
+		}
+		if (this.throwingName != null) {
+			minimumNumberUnboundArgs++;
+		}
+		if (this.numberOfRemainingUnboundArguments < minimumNumberUnboundArgs) {
+			throw new IllegalStateException(
+					"Not enough arguments in method to satisfy binding of returning and throwing variables");
+		}
+
+		try {
+			int algorithmicStep = STEP_JOIN_POINT_BINDING;
+			while ((this.numberOfRemainingUnboundArguments > 0) && algorithmicStep < STEP_FINISHED) {
+				switch (algorithmicStep++) {
+					case STEP_JOIN_POINT_BINDING:
+						if (!maybeBindThisJoinPoint()) {
+							maybeBindThisJoinPointStaticPart();
+						}
+						break;
+					case STEP_THROWING_BINDING:
+						maybeBindThrowingVariable();
+						break;
+					case STEP_ANNOTATION_BINDING:
+						maybeBindAnnotationsFromPointcutExpression();
+						break;
+					case STEP_RETURNING_BINDING:
+						maybeBindReturningVariable();
+						break;
+					case STEP_PRIMITIVE_ARGS_BINDING:
+						maybeBindPrimitiveArgsFromPointcutExpression();
+						break;
+					case STEP_THIS_TARGET_ARGS_BINDING:
+						maybeBindThisOrTargetOrArgsFromPointcutExpression();
+						break;
+					case STEP_REFERENCE_PCUT_BINDING:
+						maybeBindReferencePointcutParameter();
+						break;
+					default:
+						throw new IllegalStateException("Unknown algorithmic step: " + (algorithmicStep - 1));
+				}
+			}
+		}
+		catch (AmbiguousBindingException | IllegalArgumentException ex) {
+			if (this.raiseExceptions) {
+				throw ex;
+			}
+			else {
+				return null;
+			}
+		}
+
+		if (this.numberOfRemainingUnboundArguments == 0) {
+			return this.parameterNameBindings;
+		}
+		else {
+			if (this.raiseExceptions) {
+				throw new IllegalStateException("Failed to bind all argument names: " +
+						this.numberOfRemainingUnboundArguments + " argument(s) could not be bound");
+			}
+			else {
+				// convention for failing is to return null, allowing participation in a chain of responsibility
+				return null;
+			}
+		}
+	}
+
+	/**
+	 * An advice method can never be a constructor in Spring.
+	 * @return {@code null}
+	 * @throws UnsupportedOperationException if
+	 * {@link #setRaiseExceptions(boolean) raiseExceptions} has been set to {@code true}
+	 */
+	@Override
+	@Nullable
+	public String[] getParameterNames(Constructor<?> ctor) {
+		if (this.raiseExceptions) {
+			throw new UnsupportedOperationException("An advice method can never be a constructor");
+		}
+		else {
+			// we return null rather than throw an exception so that we behave well
+			// in a chain-of-responsibility.
+			return null;
+		}
+	}
+
+
+	private void bindParameterName(int index, String name) {
+		this.parameterNameBindings[index] = name;
+		this.numberOfRemainingUnboundArguments--;
+	}
+
+	/**
+	 * If the first parameter is of type JoinPoint or ProceedingJoinPoint,bind "thisJoinPoint" as
+	 * parameter name and return true, else return false.
+	 */
+	private boolean maybeBindThisJoinPoint() {
+		if ((this.argumentTypes[0] == JoinPoint.class) || (this.argumentTypes[0] == ProceedingJoinPoint.class)) {
+			bindParameterName(0, THIS_JOIN_POINT);
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	private void maybeBindThisJoinPointStaticPart() {
+		if (this.argumentTypes[0] == JoinPoint.StaticPart.class) {
+			bindParameterName(0, THIS_JOIN_POINT_STATIC_PART);
+		}
+	}
+
+	/**
+	 * If a throwing name was specified and there is exactly one choice remaining
+	 * (argument that is a subtype of Throwable) then bind it.
+	 */
+	private void maybeBindThrowingVariable() {
+		if (this.throwingName == null) {
+			return;
+		}
+
+		// So there is binding work to do...
+		int throwableIndex = -1;
+		for (int i = 0; i < this.argumentTypes.length; i++) {
+			if (isUnbound(i) && isSubtypeOf(Throwable.class, i)) {
+				if (throwableIndex == -1) {
+					throwableIndex = i;
+				}
+				else {
+					// Second candidate we've found - ambiguous binding
+					throw new AmbiguousBindingException("Binding of throwing parameter '" +
+							this.throwingName + "' is ambiguous: could be bound to argument " +
+							throwableIndex + " or argument " + i);
+				}
+			}
+		}
+
+		if (throwableIndex == -1) {
+			throw new IllegalStateException("Binding of throwing parameter '" + this.throwingName
+					+ "' could not be completed as no available arguments are a subtype of Throwable");
+		}
+		else {
+			bindParameterName(throwableIndex, this.throwingName);
+		}
+	}
+
+	/**
+	 * If a returning variable was specified and there is only one choice remaining, bind it.
+	 */
+	private void maybeBindReturningVariable() {
+		if (this.numberOfRemainingUnboundArguments == 0) {
+			throw new IllegalStateException(
+					"Algorithm assumes that there must be at least one unbound parameter on entry to this method");
+		}
+
+		if (this.returningName != null) {
+			if (this.numberOfRemainingUnboundArguments > 1) {
+				throw new AmbiguousBindingException("Binding of returning parameter '" + this.returningName +
+						"' is ambiguous, there are " + this.numberOfRemainingUnboundArguments + " candidates.");
+			}
+
+			// We're all set... find the unbound parameter, and bind it.
+			for (int i = 0; i < this.parameterNameBindings.length; i++) {
+				if (this.parameterNameBindings[i] == null) {
+					bindParameterName(i, this.returningName);
+					break;
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * Parse the string pointcut expression looking for:
+	 * &#64;this, &#64;target, &#64;args, &#64;within, &#64;withincode, &#64;annotation.
+	 * If we find one of these pointcut expressions, try and extract a candidate variable
+	 * name (or variable names, in the case of args).
+	 * <p>Some more support from AspectJ in doing this exercise would be nice... :)
+	 */
+	private void maybeBindAnnotationsFromPointcutExpression() {
+		List<String> varNames = new ArrayList<>();
+		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
+		for (int i = 0; i < tokens.length; i++) {
+			String toMatch = tokens[i];
+			int firstParenIndex = toMatch.indexOf('(');
+			if (firstParenIndex != -1) {
+				toMatch = toMatch.substring(0, firstParenIndex);
+			}
+			if (singleValuedAnnotationPcds.contains(toMatch)) {
+				PointcutBody body = getPointcutBody(tokens, i);
+				i += body.numTokensConsumed;
+				String varName = maybeExtractVariableName(body.text);
+				if (varName != null) {
+					varNames.add(varName);
+				}
+			}
+			else if (tokens[i].startsWith("@args(") || tokens[i].equals("@args")) {
+				PointcutBody body = getPointcutBody(tokens, i);
+				i += body.numTokensConsumed;
+				maybeExtractVariableNamesFromArgs(body.text, varNames);
+			}
+		}
+
+		bindAnnotationsFromVarNames(varNames);
+	}
+
+	/**
+	 * Match the given list of extracted variable names to argument slots.
+	 */
+	private void bindAnnotationsFromVarNames(List<String> varNames) {
+		if (!varNames.isEmpty()) {
+			// we have work to do...
+			int numAnnotationSlots = countNumberOfUnboundAnnotationArguments();
+			if (numAnnotationSlots > 1) {
+				throw new AmbiguousBindingException("Found " + varNames.size() +
+						" potential annotation variable(s), and " +
+						numAnnotationSlots + " potential argument slots");
+			}
+			else if (numAnnotationSlots == 1) {
+				if (varNames.size() == 1) {
+					// it's a match
+					findAndBind(Annotation.class, varNames.get(0));
+				}
+				else {
+					// multiple candidate vars, but only one slot
+					throw new IllegalArgumentException("Found " + varNames.size() +
+							" candidate annotation binding variables" +
+							" but only one potential argument binding slot");
+				}
+			}
+			else {
+				// no slots so presume those candidate vars were actually type names
+			}
+		}
+	}
+
+	/*
+	 * If the token starts meets Java identifier conventions, it's in.
+	 */
+	@Nullable
+	private String maybeExtractVariableName(@Nullable String candidateToken) {
+		if (AspectJProxyUtils.isVariableName(candidateToken)) {
+			return candidateToken;
+		}
+		return null;
+	}
+
+	/**
+	 * Given an args pointcut body (could be {@code args} or {@code at_args}),
+	 * add any candidate variable names to the given list.
+	 */
+	private void maybeExtractVariableNamesFromArgs(@Nullable String argsSpec, List<String> varNames) {
+		if (argsSpec == null) {
+			return;
+		}
+		String[] tokens = StringUtils.tokenizeToStringArray(argsSpec, ",");
+		for (int i = 0; i < tokens.length; i++) {
+			tokens[i] = StringUtils.trimWhitespace(tokens[i]);
+			String varName = maybeExtractVariableName(tokens[i]);
+			if (varName != null) {
+				varNames.add(varName);
+			}
+		}
+	}
+
+	/**
+	 * Parse the string pointcut expression looking for this(), target() and args() expressions.
+	 * If we find one, try and extract a candidate variable name and bind it.
+	 */
+	private void maybeBindThisOrTargetOrArgsFromPointcutExpression() {
+		if (this.numberOfRemainingUnboundArguments > 1) {
+			throw new AmbiguousBindingException("Still " + this.numberOfRemainingUnboundArguments
+					+ " unbound args at this(),target(),args() binding stage, with no way to determine between them");
+		}
+
+		List<String> varNames = new ArrayList<>();
+		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
+		for (int i = 0; i < tokens.length; i++) {
+			if (tokens[i].equals("this") ||
+					tokens[i].startsWith("this(") ||
+					tokens[i].equals("target") ||
+					tokens[i].startsWith("target(")) {
+				PointcutBody body = getPointcutBody(tokens, i);
+				i += body.numTokensConsumed;
+				String varName = maybeExtractVariableName(body.text);
+				if (varName != null) {
+					varNames.add(varName);
+				}
+			}
+			else if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
+				PointcutBody body = getPointcutBody(tokens, i);
+				i += body.numTokensConsumed;
+				List<String> candidateVarNames = new ArrayList<>();
+				maybeExtractVariableNamesFromArgs(body.text, candidateVarNames);
+				// we may have found some var names that were bound in previous primitive args binding step,
+				// filter them out...
+				for (String varName : candidateVarNames) {
+					if (!alreadyBound(varName)) {
+						varNames.add(varName);
+					}
+				}
+			}
+		}
+
+
+		if (varNames.size() > 1) {
+			throw new AmbiguousBindingException("Found " + varNames.size() +
+					" candidate this(), target() or args() variables but only one unbound argument slot");
+		}
+		else if (varNames.size() == 1) {
+			for (int j = 0; j < this.parameterNameBindings.length; j++) {
+				if (isUnbound(j)) {
+					bindParameterName(j, varNames.get(0));
+					break;
+				}
+			}
+		}
+		// else varNames.size must be 0 and we have nothing to bind.
+	}
+
+	private void maybeBindReferencePointcutParameter() {
+		if (this.numberOfRemainingUnboundArguments > 1) {
+			throw new AmbiguousBindingException("Still " + this.numberOfRemainingUnboundArguments
+					+ " unbound args at reference pointcut binding stage, with no way to determine between them");
+		}
+
+		List<String> varNames = new ArrayList<>();
+		String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
+		for (int i = 0; i < tokens.length; i++) {
+			String toMatch = tokens[i];
+			if (toMatch.startsWith("!")) {
+				toMatch = toMatch.substring(1);
+			}
+			int firstParenIndex = toMatch.indexOf('(');
+			if (firstParenIndex != -1) {
+				toMatch = toMatch.substring(0, firstParenIndex);
+			}
+			else {
+				if (tokens.length < i + 2) {
+					// no "(" and nothing following
+					continue;
+				}
+				else {
+					String nextToken = tokens[i + 1];
+					if (nextToken.charAt(0) != '(') {
+						// next token is not "(" either, can't be a pc...
+						continue;
+					}
+				}
+
+			}
+
+			// eat the body
+			PointcutBody body = getPointcutBody(tokens, i);
+			i += body.numTokensConsumed;
+
+			if (!nonReferencePointcutTokens.contains(toMatch)) {
+				// then it could be a reference pointcut
+				String varName = maybeExtractVariableName(body.text);
+				if (varName != null) {
+					varNames.add(varName);
+				}
+			}
+		}
+
+		if (varNames.size() > 1) {
+			throw new AmbiguousBindingException("Found " + varNames.size() +
+					" candidate reference pointcut variables but only one unbound argument slot");
+		}
+		else if (varNames.size() == 1) {
+			for (int j = 0; j < this.parameterNameBindings.length; j++) {
+				if (isUnbound(j)) {
+					bindParameterName(j, varNames.get(0));
+					break;
+				}
+			}
+		}
+		// else varNames.size must be 0 and we have nothing to bind.
+	}
+
+	/*
+	 * We've found the start of a binding pointcut at the given index into the
+	 * token array. Now we need to extract the pointcut body and return it.
+	 */
+	private PointcutBody getPointcutBody(String[] tokens, int startIndex) {
+		int numTokensConsumed = 0;
+		String currentToken = tokens[startIndex];
+		int bodyStart = currentToken.indexOf('(');
+		if (currentToken.charAt(currentToken.length() - 1) == ')') {
+			// It's an all in one... get the text between the first (and the last)
+			return new PointcutBody(0, currentToken.substring(bodyStart + 1, currentToken.length() - 1));
+		}
+		else {
+			StringBuilder sb = new StringBuilder();
+			if (bodyStart >= 0 && bodyStart != (currentToken.length() - 1)) {
+				sb.append(currentToken.substring(bodyStart + 1));
+				sb.append(" ");
+			}
+			numTokensConsumed++;
+			int currentIndex = startIndex + numTokensConsumed;
+			while (currentIndex < tokens.length) {
+				if (tokens[currentIndex].equals("(")) {
+					currentIndex++;
+					continue;
+				}
+
+				if (tokens[currentIndex].endsWith(")")) {
+					sb.append(tokens[currentIndex], 0, tokens[currentIndex].length() - 1);
+					return new PointcutBody(numTokensConsumed, sb.toString().trim());
+				}
+
+				String toAppend = tokens[currentIndex];
+				if (toAppend.startsWith("(")) {
+					toAppend = toAppend.substring(1);
+				}
+				sb.append(toAppend);
+				sb.append(" ");
+				currentIndex++;
+				numTokensConsumed++;
+			}
+
+		}
+
+		// We looked and failed...
+		return new PointcutBody(numTokensConsumed, null);
+	}
+
+	/**
+	 * Match up args against unbound arguments of primitive types.
+	 */
+	private void maybeBindPrimitiveArgsFromPointcutExpression() {
+		int numUnboundPrimitives = countNumberOfUnboundPrimitiveArguments();
+		if (numUnboundPrimitives > 1) {
+			throw new AmbiguousBindingException("Found '" + numUnboundPrimitives +
+					"' unbound primitive arguments with no way to distinguish between them.");
+		}
+		if (numUnboundPrimitives == 1) {
+			// Look for arg variable and bind it if we find exactly one...
+			List<String> varNames = new ArrayList<>();
+			String[] tokens = StringUtils.tokenizeToStringArray(this.pointcutExpression, " ");
+			for (int i = 0; i < tokens.length; i++) {
+				if (tokens[i].equals("args") || tokens[i].startsWith("args(")) {
+					PointcutBody body = getPointcutBody(tokens, i);
+					i += body.numTokensConsumed;
+					maybeExtractVariableNamesFromArgs(body.text, varNames);
+				}
+			}
+			if (varNames.size() > 1) {
+				throw new AmbiguousBindingException("Found " + varNames.size() +
+						" candidate variable names but only one candidate binding slot when matching primitive args");
+			}
+			else if (varNames.size() == 1) {
+				// 1 primitive arg, and one candidate...
+				for (int i = 0; i < this.argumentTypes.length; i++) {
+					if (isUnbound(i) && this.argumentTypes[i].isPrimitive()) {
+						bindParameterName(i, varNames.get(0));
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	/*
+	 * Return true if the parameter name binding for the given parameter
+	 * index has not yet been assigned.
+	 */
+	private boolean isUnbound(int i) {
+		return this.parameterNameBindings[i] == null;
+	}
+
+	private boolean alreadyBound(String varName) {
+		for (int i = 0; i < this.parameterNameBindings.length; i++) {
+			if (!isUnbound(i) && varName.equals(this.parameterNameBindings[i])) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/*
+	 * Return {@code true} if the given argument type is a subclass
+	 * of the given supertype.
+	 */
+	private boolean isSubtypeOf(Class<?> supertype, int argumentNumber) {
+		return supertype.isAssignableFrom(this.argumentTypes[argumentNumber]);
+	}
+
+	private int countNumberOfUnboundAnnotationArguments() {
+		int count = 0;
+		for (int i = 0; i < this.argumentTypes.length; i++) {
+			if (isUnbound(i) && isSubtypeOf(Annotation.class, i)) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	private int countNumberOfUnboundPrimitiveArguments() {
+		int count = 0;
+		for (int i = 0; i < this.argumentTypes.length; i++) {
+			if (isUnbound(i) && this.argumentTypes[i].isPrimitive()) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	/*
+	 * Find the argument index with the given type, and bind the given
+	 * {@code varName} in that position.
+	 */
+	private void findAndBind(Class<?> argumentType, String varName) {
+		for (int i = 0; i < this.argumentTypes.length; i++) {
+			if (isUnbound(i) && isSubtypeOf(argumentType, i)) {
+				bindParameterName(i, varName);
+				return;
+			}
+		}
+		throw new IllegalStateException("Expected to find an unbound argument of type '" +
+				argumentType.getName() + "'");
+	}
+
+
+	/**
+	 * Simple struct to hold the extracted text from a pointcut body, together
+	 * with the number of tokens consumed in extracting it.
+	 */
+	private static class PointcutBody {
+
+		private int numTokensConsumed;
+
+		@Nullable
+		private String text;
+
+		public PointcutBody(int tokens, @Nullable String text) {
+			this.numTokensConsumed = tokens;
+			this.text = text;
+		}
+	}
+
+
+	/**
+	 * Thrown in response to an ambiguous binding being detected when
+	 * trying to resolve a method's parameter names.
+	 */
+	@SuppressWarnings("serial")
+	public static class AmbiguousBindingException extends RuntimeException {
+
+		/**
+		 * Construct a new AmbiguousBindingException with the specified message.
+		 * @param msg the detail message
+		 */
+		public AmbiguousBindingException(String msg) {
+			super(msg);
+		}
+	}
+
+}

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.aop.AfterAdvice;
+import org.springframework.lang.Nullable;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after advice method.
+ *
+ * @author Rod Johnson
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJAfterAdvice extends AbstractAspectJAdvice
+		implements MethodInterceptor, AfterAdvice, Serializable {
+
+	public AspectJAfterAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+
+	@Override
+	@Nullable
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		try {
+			return mi.proceed();
+		}
+		finally {
+			invokeAdviceMethod(getJoinPointMatch(), null, null);
+		}
+	}
+
+	@Override
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	@Override
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+}

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

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import org.springframework.aop.AfterAdvice;
+import org.springframework.aop.AfterReturningAdvice;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.TypeUtils;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after-returning advice method.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJAfterReturningAdvice extends AbstractAspectJAdvice
+		implements AfterReturningAdvice, AfterAdvice, Serializable {
+
+	public AspectJAfterReturningAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+
+	@Override
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	@Override
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+	@Override
+	public void setReturningName(String name) {
+		setReturningNameNoCheck(name);
+	}
+
+	@Override
+	public void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable {
+		if (shouldInvokeOnReturnValueOf(method, returnValue)) {
+			invokeAdviceMethod(getJoinPointMatch(), returnValue, null);
+		}
+	}
+
+
+	/**
+	 * Following AspectJ semantics, if a returning clause was specified, then the
+	 * advice is only invoked if the returned value is an instance of the given
+	 * returning type and generic type parameters, if any, match the assignment
+	 * rules. If the returning type is Object, the advice is *always* invoked.
+	 * @param returnValue the return value of the target method
+	 * @return whether to invoke the advice method for the given return value
+	 */
+	private boolean shouldInvokeOnReturnValueOf(Method method, @Nullable Object returnValue) {
+		Class<?> type = getDiscoveredReturningType();
+		Type genericType = getDiscoveredReturningGenericType();
+		// If we aren't dealing with a raw type, check if generic parameters are assignable.
+		return (matchesReturnValue(type, method, returnValue) &&
+				(genericType == null || genericType == type ||
+						TypeUtils.isAssignable(genericType, method.getGenericReturnType())));
+	}
+
+	/**
+	 * Following AspectJ semantics, if a return value is null (or return type is void),
+	 * then the return type of target method should be used to determine whether advice
+	 * is invoked or not. Also, even if the return type is void, if the type of argument
+	 * declared in the advice method is Object, then the advice must still get invoked.
+	 * @param type the type of argument declared in advice method
+	 * @param method the advice method
+	 * @param returnValue the return value of the target method
+	 * @return whether to invoke the advice method for the given return value and type
+	 */
+	private boolean matchesReturnValue(Class<?> type, Method method, @Nullable Object returnValue) {
+		if (returnValue != null) {
+			return ClassUtils.isAssignableValue(type, returnValue);
+		}
+		else if (Object.class == type && void.class == method.getReturnType()) {
+			return true;
+		}
+		else {
+			return ClassUtils.isAssignable(type, method.getReturnType());
+		}
+	}
+
+}

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+import org.springframework.aop.AfterAdvice;
+import org.springframework.lang.Nullable;
+
+/**
+ * Spring AOP advice wrapping an AspectJ after-throwing advice method.
+ *
+ * @author Rod Johnson
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJAfterThrowingAdvice extends AbstractAspectJAdvice
+		implements MethodInterceptor, AfterAdvice, Serializable {
+
+	public AspectJAfterThrowingAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+
+	@Override
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	@Override
+	public boolean isAfterAdvice() {
+		return true;
+	}
+
+	@Override
+	public void setThrowingName(String name) {
+		setThrowingNameNoCheck(name);
+	}
+
+	@Override
+	@Nullable
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		try {
+			return mi.proceed();
+		}
+		catch (Throwable ex) {
+			if (shouldInvokeOnThrowing(ex)) {
+				invokeAdviceMethod(getJoinPointMatch(), null, ex);
+			}
+			throw ex;
+		}
+	}
+
+	/**
+	 * In AspectJ semantics, after throwing advice that specifies a throwing clause
+	 * is only invoked if the thrown exception is a subtype of the given throwing type.
+	 */
+	private boolean shouldInvokeOnThrowing(Throwable ex) {
+		return getDiscoveredThrowingType().isAssignableFrom(ex.getClass());
+	}
+
+}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2002-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.AfterAdvice;
+import org.springframework.aop.BeforeAdvice;
+import org.springframework.lang.Nullable;
+
+/**
+ * Utility methods for dealing with AspectJ advisors.
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public abstract class AspectJAopUtils {
+
+	/**
+	 * Return {@code true} if the advisor is a form of before advice.
+	 */
+	public static boolean isBeforeAdvice(Advisor anAdvisor) {
+		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
+		if (precedenceInfo != null) {
+			return precedenceInfo.isBeforeAdvice();
+		}
+		return (anAdvisor.getAdvice() instanceof BeforeAdvice);
+	}
+
+	/**
+	 * Return {@code true} if the advisor is a form of after advice.
+	 */
+	public static boolean isAfterAdvice(Advisor anAdvisor) {
+		AspectJPrecedenceInformation precedenceInfo = getAspectJPrecedenceInformationFor(anAdvisor);
+		if (precedenceInfo != null) {
+			return precedenceInfo.isAfterAdvice();
+		}
+		return (anAdvisor.getAdvice() instanceof AfterAdvice);
+	}
+
+	/**
+	 * Return the AspectJPrecedenceInformation provided by this advisor or its advice.
+	 * If neither the advisor nor the advice have precedence information, this method
+	 * will return {@code null}.
+	 */
+	@Nullable
+	public static AspectJPrecedenceInformation getAspectJPrecedenceInformationFor(Advisor anAdvisor) {
+		if (anAdvisor instanceof AspectJPrecedenceInformation) {
+			return (AspectJPrecedenceInformation) anAdvisor;
+		}
+		Advice advice = anAdvisor.getAdvice();
+		if (advice instanceof AspectJPrecedenceInformation) {
+			return (AspectJPrecedenceInformation) advice;
+		}
+		return null;
+	}
+
+}

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

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.weaver.tools.JoinPointMatch;
+
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.lang.Nullable;
+
+/**
+ * Spring AOP around advice (MethodInterceptor) that wraps
+ * an AspectJ advice method. Exposes ProceedingJoinPoint.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJAroundAdvice extends AbstractAspectJAdvice implements MethodInterceptor, Serializable {
+
+	public AspectJAroundAdvice(
+			Method aspectJAroundAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJAroundAdviceMethod, pointcut, aif);
+	}
+
+
+	@Override
+	public boolean isBeforeAdvice() {
+		return false;
+	}
+
+	@Override
+	public boolean isAfterAdvice() {
+		return false;
+	}
+
+	@Override
+	protected boolean supportsProceedingJoinPoint() {
+		return true;
+	}
+
+	@Override
+	@Nullable
+	public Object invoke(MethodInvocation mi) throws Throwable {
+		if (!(mi instanceof ProxyMethodInvocation)) {
+			throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+		}
+		ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
+		ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
+		JoinPointMatch jpm = getJoinPointMatch(pmi);
+		return invokeAdviceMethod(pjp, jpm, null, null);
+	}
+
+	/**
+	 * Return the ProceedingJoinPoint for the current invocation,
+	 * instantiating it lazily if it hasn't been bound to the thread already.
+	 * @param rmi the current Spring AOP ReflectiveMethodInvocation,
+	 * which we'll use for attribute binding
+	 * @return the ProceedingJoinPoint to make available to advice methods
+	 */
+	protected ProceedingJoinPoint lazyGetProceedingJoinPoint(ProxyMethodInvocation rmi) {
+		return new MethodInvocationProceedingJoinPoint(rmi);
+	}
+
+}

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

@@ -0,0 +1,718 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.aopalliance.intercept.MethodInvocation;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.weaver.patterns.NamePattern;
+import org.aspectj.weaver.reflect.ReflectionWorld.ReflectionWorldException;
+import org.aspectj.weaver.reflect.ShadowMatchImpl;
+import org.aspectj.weaver.tools.ContextBasedMatcher;
+import org.aspectj.weaver.tools.FuzzyBoolean;
+import org.aspectj.weaver.tools.JoinPointMatch;
+import org.aspectj.weaver.tools.MatchingContext;
+import org.aspectj.weaver.tools.PointcutDesignatorHandler;
+import org.aspectj.weaver.tools.PointcutExpression;
+import org.aspectj.weaver.tools.PointcutParameter;
+import org.aspectj.weaver.tools.PointcutParser;
+import org.aspectj.weaver.tools.PointcutPrimitive;
+import org.aspectj.weaver.tools.ShadowMatch;
+
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.IntroductionAwareMethodMatcher;
+import org.springframework.aop.MethodMatcher;
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.aop.framework.autoproxy.ProxyCreationContext;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+import org.springframework.aop.support.AbstractExpressionPointcut;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.BeanFactoryUtils;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * Spring {@link org.springframework.aop.Pointcut} implementation
+ * that uses the AspectJ weaver to evaluate a pointcut expression.
+ *
+ * <p>The pointcut expression value is an AspectJ expression. This can
+ * reference other pointcuts and use composition and other operations.
+ *
+ * <p>Naturally, as this is to be processed by Spring AOP's proxy-based model,
+ * only method execution pointcuts are supported.
+ *
+ * @author Rob Harrop
+ * @author Adrian Colyer
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Ramnivas Laddad
+ * @author Dave Syer
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJExpressionPointcut extends AbstractExpressionPointcut
+		implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {
+
+	private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<>();
+
+	static {
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
+		SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
+	}
+
+
+	private static final Log logger = LogFactory.getLog(AspectJExpressionPointcut.class);
+
+	@Nullable
+	private Class<?> pointcutDeclarationScope;
+
+	private String[] pointcutParameterNames = new String[0];
+
+	private Class<?>[] pointcutParameterTypes = new Class<?>[0];
+
+	@Nullable
+	private BeanFactory beanFactory;
+
+	@Nullable
+	private transient ClassLoader pointcutClassLoader;
+
+	@Nullable
+	private transient PointcutExpression pointcutExpression;
+
+	private transient Map<Method, ShadowMatch> shadowMatchCache = new ConcurrentHashMap<>(32);
+
+
+	/**
+	 * Create a new default AspectJExpressionPointcut.
+	 */
+	public AspectJExpressionPointcut() {
+	}
+
+	/**
+	 * Create a new AspectJExpressionPointcut with the given settings.
+	 * @param declarationScope the declaration scope for the pointcut
+	 * @param paramNames the parameter names for the pointcut
+	 * @param paramTypes the parameter types for the pointcut
+	 */
+	public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes) {
+		this.pointcutDeclarationScope = declarationScope;
+		if (paramNames.length != paramTypes.length) {
+			throw new IllegalStateException(
+					"Number of pointcut parameter names must match number of pointcut parameter types");
+		}
+		this.pointcutParameterNames = paramNames;
+		this.pointcutParameterTypes = paramTypes;
+	}
+
+
+	/**
+	 * Set the declaration scope for the pointcut.
+	 */
+	public void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope) {
+		this.pointcutDeclarationScope = pointcutDeclarationScope;
+	}
+
+	/**
+	 * Set the parameter names for the pointcut.
+	 */
+	public void setParameterNames(String... names) {
+		this.pointcutParameterNames = names;
+	}
+
+	/**
+	 * Set the parameter types for the pointcut.
+	 */
+	public void setParameterTypes(Class<?>... types) {
+		this.pointcutParameterTypes = types;
+	}
+
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.beanFactory = beanFactory;
+	}
+
+
+	@Override
+	public ClassFilter getClassFilter() {
+		obtainPointcutExpression();
+		return this;
+	}
+
+	@Override
+	public MethodMatcher getMethodMatcher() {
+		obtainPointcutExpression();
+		return this;
+	}
+
+
+	/**
+	 * Check whether this pointcut is ready to match,
+	 * lazily building the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression obtainPointcutExpression() {
+		if (getExpression() == null) {
+			throw new IllegalStateException("Must set property 'expression' before attempting to match");
+		}
+		if (this.pointcutExpression == null) {
+			this.pointcutClassLoader = determinePointcutClassLoader();
+			this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
+		}
+		return this.pointcutExpression;
+	}
+
+	/**
+	 * Determine the ClassLoader to use for pointcut evaluation.
+	 */
+	@Nullable
+	private ClassLoader determinePointcutClassLoader() {
+		if (this.beanFactory instanceof ConfigurableBeanFactory) {
+			return ((ConfigurableBeanFactory) this.beanFactory).getBeanClassLoader();
+		}
+		if (this.pointcutDeclarationScope != null) {
+			return this.pointcutDeclarationScope.getClassLoader();
+		}
+		return ClassUtils.getDefaultClassLoader();
+	}
+
+	/**
+	 * Build the underlying AspectJ pointcut expression.
+	 */
+	private PointcutExpression buildPointcutExpression(@Nullable ClassLoader classLoader) {
+		PointcutParser parser = initializePointcutParser(classLoader);
+		PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];
+		for (int i = 0; i < pointcutParameters.length; i++) {
+			pointcutParameters[i] = parser.createPointcutParameter(
+					this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);
+		}
+		return parser.parsePointcutExpression(replaceBooleanOperators(resolveExpression()),
+				this.pointcutDeclarationScope, pointcutParameters);
+	}
+
+	private String resolveExpression() {
+		String expression = getExpression();
+		Assert.state(expression != null, "No expression set");
+		return expression;
+	}
+
+	/**
+	 * Initialize the underlying AspectJ pointcut parser.
+	 */
+	private PointcutParser initializePointcutParser(@Nullable ClassLoader classLoader) {
+		PointcutParser parser = PointcutParser
+				.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
+						SUPPORTED_PRIMITIVES, classLoader);
+		parser.registerPointcutDesignatorHandler(new BeanPointcutDesignatorHandler());
+		return parser;
+	}
+
+
+	/**
+	 * If a pointcut expression has been specified in XML, the user cannot
+	 * write {@code and} as "&&" (though &amp;&amp; will work).
+	 * We also allow {@code and} between two pointcut sub-expressions.
+	 * <p>This method converts back to {@code &&} for the AspectJ pointcut parser.
+	 */
+	private String replaceBooleanOperators(String pcExpr) {
+		String result = StringUtils.replace(pcExpr, " and ", " && ");
+		result = StringUtils.replace(result, " or ", " || ");
+		result = StringUtils.replace(result, " not ", " ! ");
+		return result;
+	}
+
+
+	/**
+	 * Return the underlying AspectJ pointcut expression.
+	 */
+	public PointcutExpression getPointcutExpression() {
+		return obtainPointcutExpression();
+	}
+
+	@Override
+	public boolean matches(Class<?> targetClass) {
+		PointcutExpression pointcutExpression = obtainPointcutExpression();
+		try {
+			try {
+				return 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 (Throwable ex) {
+			logger.debug("PointcutExpression matching rejected target class", ex);
+		}
+		return false;
+	}
+
+	@Override
+	public boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions) {
+		obtainPointcutExpression();
+		ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);
+
+		// Special handling for this, target, @this, @target, @annotation
+		// in Spring - we can optimize since we know we have exactly this class,
+		// and there will never be matching subclass at runtime.
+		if (shadowMatch.alwaysMatches()) {
+			return true;
+		}
+		else if (shadowMatch.neverMatches()) {
+			return false;
+		}
+		else {
+			// the maybe case
+			if (hasIntroductions) {
+				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));
+		}
+	}
+
+	@Override
+	public boolean matches(Method method, Class<?> targetClass) {
+		return matches(method, targetClass, false);
+	}
+
+	@Override
+	public boolean isRuntime() {
+		return obtainPointcutExpression().mayNeedDynamicTest();
+	}
+
+	@Override
+	public boolean matches(Method method, Class<?> targetClass, Object... args) {
+		obtainPointcutExpression();
+		ShadowMatch shadowMatch = getTargetShadowMatch(method, targetClass);
+
+		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
+		// consistent with return of MethodInvocationProceedingJoinPoint
+		ProxyMethodInvocation pmi = null;
+		Object targetObject = null;
+		Object thisObject = null;
+		try {
+			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
+			targetObject = mi.getThis();
+			if (!(mi instanceof ProxyMethodInvocation)) {
+				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
+			}
+			pmi = (ProxyMethodInvocation) mi;
+			thisObject = pmi.getProxy();
+		}
+		catch (IllegalStateException ex) {
+			// No current invocation...
+			if (logger.isDebugEnabled()) {
+				logger.debug("Could not access current invocation - matching with limited context: " + ex);
+			}
+		}
+
+		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 && thisObject != null) {  // there is a current invocation
+				RuntimeTestWalker originalMethodResidueTest = getRuntimeTestWalker(getShadowMatch(method, method));
+				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;
+		}
+	}
+
+	@Nullable
+	protected String getCurrentProxiedBeanName() {
+		return ProxyCreationContext.getCurrentProxiedBeanName();
+	}
+
+
+	/**
+	 * Get a new pointcut expression based on a target class's loader rather than the default.
+	 */
+	@Nullable
+	private PointcutExpression getFallbackPointcutExpression(Class<?> targetClass) {
+		try {
+			ClassLoader classLoader = targetClass.getClassLoader();
+			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(shadowMatch);
+	}
+
+	private void bindParameters(ProxyMethodInvocation invocation, JoinPointMatch jpm) {
+		// Note: Can't use JoinPointMatch.getClass().getName() as the key, since
+		// Spring AOP does all the matching at a join point, and then all the invocations
+		// under this scenario, if we just use JoinPointMatch as the key, then
+		// 'last man wins' which is not what we want at all.
+		// Using the expression is guaranteed to be safe, since 2 identical expressions
+		// are guaranteed to bind in exactly the same way.
+		invocation.setUserAttribute(resolveExpression(), jpm);
+	}
+
+	private ShadowMatch getTargetShadowMatch(Method method, Class<?> targetClass) {
+		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
+		if (targetMethod.getDeclaringClass().isInterface()) {
+			// Try to build the most specific interface possible for inherited methods to be
+			// considered for sub-interface matches as well, in particular for proxy classes.
+			// Note: AspectJ is only going to take Method.getDeclaringClass() into account.
+			Set<Class<?>> ifcs = ClassUtils.getAllInterfacesForClassAsSet(targetClass);
+			if (ifcs.size() > 1) {
+				try {
+					Class<?> compositeInterface = ClassUtils.createCompositeInterface(
+							ClassUtils.toClassArray(ifcs), targetClass.getClassLoader());
+					targetMethod = ClassUtils.getMostSpecificMethod(targetMethod, compositeInterface);
+				}
+				catch (IllegalArgumentException ex) {
+					// Implemented interfaces probably expose conflicting method signatures...
+					// Proceed with original target method.
+				}
+			}
+		}
+		return getShadowMatch(targetMethod, method);
+	}
+
+	private ShadowMatch getShadowMatch(Method targetMethod, Method originalMethod) {
+		// Avoid lock contention for known Methods through concurrent access...
+		ShadowMatch shadowMatch = this.shadowMatchCache.get(targetMethod);
+		if (shadowMatch == null) {
+			synchronized (this.shadowMatchCache) {
+				// Not found - now check again with full lock...
+				PointcutExpression fallbackExpression = null;
+				shadowMatch = this.shadowMatchCache.get(targetMethod);
+				if (shadowMatch == null) {
+					Method methodToMatch = targetMethod;
+					try {
+						try {
+							shadowMatch = obtainPointcutExpression().matchesMethodExecution(methodToMatch);
+						}
+						catch (ReflectionWorldException ex) {
+							// Failed to introspect target method, probably because it has been loaded
+							// in a special ClassLoader. Let's try the declaring ClassLoader instead...
+							try {
+								fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+								if (fallbackExpression != null) {
+									shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
+								}
+							}
+							catch (ReflectionWorldException ex2) {
+								fallbackExpression = null;
+							}
+						}
+						if (targetMethod != originalMethod && (shadowMatch == null ||
+								(shadowMatch.neverMatches() && Proxy.isProxyClass(targetMethod.getDeclaringClass())))) {
+							// Fall back to the plain original method in case of no resolvable match or a
+							// negative match on a proxy class (which doesn't carry any annotations on its
+							// redeclared methods).
+							methodToMatch = originalMethod;
+							try {
+								shadowMatch = obtainPointcutExpression().matchesMethodExecution(methodToMatch);
+							}
+							catch (ReflectionWorldException ex) {
+								// Could neither introspect the target class nor the proxy class ->
+								// let's try the original method's declaring class before we give up...
+								try {
+									fallbackExpression = getFallbackPointcutExpression(methodToMatch.getDeclaringClass());
+									if (fallbackExpression != null) {
+										shadowMatch = fallbackExpression.matchesMethodExecution(methodToMatch);
+									}
+								}
+								catch (ReflectionWorldException ex2) {
+									fallbackExpression = null;
+								}
+							}
+						}
+					}
+					catch (Throwable ex) {
+						// Possibly AspectJ 1.8.10 encountering an invalid signature
+						logger.debug("PointcutExpression matching rejected target method", ex);
+						fallbackExpression = null;
+					}
+					if (shadowMatch == null) {
+						shadowMatch = new ShadowMatchImpl(org.aspectj.util.FuzzyBoolean.NO, null, null, null);
+					}
+					else if (shadowMatch.maybeMatches() && fallbackExpression != null) {
+						shadowMatch = new DefensiveShadowMatch(shadowMatch,
+								fallbackExpression.matchesMethodExecution(methodToMatch));
+					}
+					this.shadowMatchCache.put(targetMethod, shadowMatch);
+				}
+			}
+		}
+		return shadowMatch;
+	}
+
+
+	@Override
+	public boolean equals(@Nullable Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AspectJExpressionPointcut)) {
+			return false;
+		}
+		AspectJExpressionPointcut otherPc = (AspectJExpressionPointcut) other;
+		return ObjectUtils.nullSafeEquals(this.getExpression(), otherPc.getExpression()) &&
+				ObjectUtils.nullSafeEquals(this.pointcutDeclarationScope, otherPc.pointcutDeclarationScope) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterNames, otherPc.pointcutParameterNames) &&
+				ObjectUtils.nullSafeEquals(this.pointcutParameterTypes, otherPc.pointcutParameterTypes);
+	}
+
+	@Override
+	public int hashCode() {
+		int hashCode = ObjectUtils.nullSafeHashCode(this.getExpression());
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutDeclarationScope);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterNames);
+		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterTypes);
+		return hashCode;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder("AspectJExpressionPointcut: (");
+		for (int i = 0; i < this.pointcutParameterTypes.length; i++) {
+			sb.append(this.pointcutParameterTypes[i].getName());
+			sb.append(" ");
+			sb.append(this.pointcutParameterNames[i]);
+			if ((i+1) < this.pointcutParameterTypes.length) {
+				sb.append(", ");
+			}
+		}
+		sb.append(") ");
+		if (getExpression() != null) {
+			sb.append(getExpression());
+		}
+		else {
+			sb.append("<pointcut expression not set>");
+		}
+		return sb.toString();
+	}
+
+	//---------------------------------------------------------------------
+	// Serialization support
+	//---------------------------------------------------------------------
+
+	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+		// Rely on default serialization, just initialize state after deserialization.
+		ois.defaultReadObject();
+
+		// Initialize transient fields.
+		// pointcutExpression will be initialized lazily by checkReadyToMatch()
+		this.shadowMatchCache = new ConcurrentHashMap<>(32);
+	}
+
+
+	/**
+	 * Handler for the Spring-specific {@code bean()} pointcut designator
+	 * extension to AspectJ.
+	 * <p>This handler must be added to each pointcut object that needs to
+	 * handle the {@code bean()} PCD. Matching context is obtained
+	 * automatically by examining a thread local variable and therefore a matching
+	 * context need not be set on the pointcut.
+	 */
+	private class BeanPointcutDesignatorHandler implements PointcutDesignatorHandler {
+
+		private static final String BEAN_DESIGNATOR_NAME = "bean";
+
+		@Override
+		public String getDesignatorName() {
+			return BEAN_DESIGNATOR_NAME;
+		}
+
+		@Override
+		public ContextBasedMatcher parse(String expression) {
+			return new BeanContextMatcher(expression);
+		}
+	}
+
+
+	/**
+	 * Matcher class for the BeanNamePointcutDesignatorHandler.
+	 * <p>Dynamic match tests for this matcher always return true,
+	 * since the matching decision is made at the proxy creation time.
+	 * For static match tests, this matcher abstains to allow the overall
+	 * pointcut to match even when negation is used with the bean() pointcut.
+	 */
+	private class BeanContextMatcher implements ContextBasedMatcher {
+
+		private final NamePattern expressionPattern;
+
+		public BeanContextMatcher(String expression) {
+			this.expressionPattern = new NamePattern(expression);
+		}
+
+		@Override
+		@SuppressWarnings("rawtypes")
+		@Deprecated
+		public boolean couldMatchJoinPointsInType(Class someClass) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		@Override
+		@SuppressWarnings("rawtypes")
+		@Deprecated
+		public boolean couldMatchJoinPointsInType(Class someClass, MatchingContext context) {
+			return (contextMatch(someClass) == FuzzyBoolean.YES);
+		}
+
+		@Override
+		public boolean matchesDynamically(MatchingContext context) {
+			return true;
+		}
+
+		@Override
+		public FuzzyBoolean matchesStatically(MatchingContext context) {
+			return contextMatch(null);
+		}
+
+		@Override
+		public boolean mayNeedDynamicTest() {
+			return false;
+		}
+
+		private FuzzyBoolean contextMatch(@Nullable Class<?> targetType) {
+			String advisedBeanName = getCurrentProxiedBeanName();
+			if (advisedBeanName == null) {  // no proxy creation in progress
+				// abstain; can't return YES, since that will make pointcut with negation fail
+				return FuzzyBoolean.MAYBE;
+			}
+			if (BeanFactoryUtils.isGeneratedBeanName(advisedBeanName)) {
+				return FuzzyBoolean.NO;
+			}
+			if (targetType != null) {
+				boolean isFactory = FactoryBean.class.isAssignableFrom(targetType);
+				return FuzzyBoolean.fromBoolean(
+						matchesBean(isFactory ? BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName : advisedBeanName));
+			}
+			else {
+				return FuzzyBoolean.fromBoolean(matchesBean(advisedBeanName) ||
+						matchesBean(BeanFactory.FACTORY_BEAN_PREFIX + advisedBeanName));
+			}
+		}
+
+		private boolean matchesBean(String advisedBeanName) {
+			return BeanFactoryAnnotationUtils.isQualifierMatch(
+					this.expressionPattern::matches, advisedBeanName, beanFactory);
+		}
+	}
+
+
+	private static class DefensiveShadowMatch implements ShadowMatch {
+
+		private final ShadowMatch primary;
+
+		private final ShadowMatch other;
+
+		public DefensiveShadowMatch(ShadowMatch primary, ShadowMatch other) {
+			this.primary = primary;
+			this.other = other;
+		}
+
+		@Override
+		public boolean alwaysMatches() {
+			return this.primary.alwaysMatches();
+		}
+
+		@Override
+		public boolean maybeMatches() {
+			return this.primary.maybeMatches();
+		}
+
+		@Override
+		public boolean neverMatches() {
+			return this.primary.neverMatches();
+		}
+
+		@Override
+		public JoinPointMatch matchesJoinPoint(Object thisObject, Object targetObject, Object[] args) {
+			try {
+				return this.primary.matchesJoinPoint(thisObject, targetObject, args);
+			}
+			catch (ReflectionWorldException ex) {
+				return this.other.matchesJoinPoint(thisObject, targetObject, args);
+			}
+		}
+
+		@Override
+		public void setMatchingContext(MatchingContext aMatchContext) {
+			this.primary.setMatchingContext(aMatchContext);
+			this.other.setMatchingContext(aMatchContext);
+		}
+	}
+
+}

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.support.AbstractGenericPointcutAdvisor;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.lang.Nullable;
+
+/**
+ * Spring AOP Advisor that can be used for any AspectJ pointcut expression.
+ *
+ * @author Rob Harrop
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJExpressionPointcutAdvisor extends AbstractGenericPointcutAdvisor implements BeanFactoryAware {
+
+	private final AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
+
+
+	public void setExpression(@Nullable String expression) {
+		this.pointcut.setExpression(expression);
+	}
+
+	@Nullable
+	public String getExpression() {
+		return this.pointcut.getExpression();
+	}
+
+	public void setLocation(@Nullable String location) {
+		this.pointcut.setLocation(location);
+	}
+
+	@Nullable
+	public String getLocation() {
+		return this.pointcut.getLocation();
+	}
+
+	public void setParameterNames(String... names) {
+		this.pointcut.setParameterNames(names);
+	}
+
+	public void setParameterTypes(Class<?>... types) {
+		this.pointcut.setParameterTypes(types);
+	}
+
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) {
+		this.pointcut.setBeanFactory(beanFactory);
+	}
+
+	@Override
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
+}

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import org.springframework.aop.MethodBeforeAdvice;
+import org.springframework.lang.Nullable;
+
+/**
+ * Spring AOP advice that wraps an AspectJ before method.
+ *
+ * @author Rod Johnson
+ * @author Adrian Colyer
+ * @since 2.0
+ */
+@SuppressWarnings("serial")
+public class AspectJMethodBeforeAdvice extends AbstractAspectJAdvice implements MethodBeforeAdvice, Serializable {
+
+	public AspectJMethodBeforeAdvice(
+			Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
+
+		super(aspectJBeforeAdviceMethod, pointcut, aif);
+	}
+
+
+	@Override
+	public void before(Method method, Object[] args, @Nullable Object target) throws Throwable {
+		invokeAdviceMethod(getJoinPointMatch(), null, null);
+	}
+
+	@Override
+	public boolean isBeforeAdvice() {
+		return true;
+	}
+
+	@Override
+	public boolean isAfterAdvice() {
+		return false;
+	}
+
+}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.PointcutAdvisor;
+import org.springframework.core.Ordered;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * AspectJPointcutAdvisor that adapts an {@link AbstractAspectJAdvice}
+ * to the {@link org.springframework.aop.PointcutAdvisor} interface.
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJPointcutAdvisor implements PointcutAdvisor, Ordered {
+
+	private final AbstractAspectJAdvice advice;
+
+	private final Pointcut pointcut;
+
+	@Nullable
+	private Integer order;
+
+
+	/**
+	 * Create a new AspectJPointcutAdvisor for the given advice.
+	 * @param advice the AbstractAspectJAdvice to wrap
+	 */
+	public AspectJPointcutAdvisor(AbstractAspectJAdvice advice) {
+		Assert.notNull(advice, "Advice must not be null");
+		this.advice = advice;
+		this.pointcut = advice.buildSafePointcut();
+	}
+
+
+	public void setOrder(int order) {
+		this.order = order;
+	}
+
+	@Override
+	public int getOrder() {
+		if (this.order != null) {
+			return this.order;
+		}
+		else {
+			return this.advice.getOrder();
+		}
+	}
+
+	@Override
+	public boolean isPerInstance() {
+		return true;
+	}
+
+	@Override
+	public Advice getAdvice() {
+		return this.advice;
+	}
+
+	@Override
+	public Pointcut getPointcut() {
+		return this.pointcut;
+	}
+
+	/**
+	 * Return the name of the aspect (bean) in which the advice was declared.
+	 * @since 4.3.15
+	 * @see AbstractAspectJAdvice#getAspectName()
+	 */
+	public String getAspectName() {
+		return this.advice.getAspectName();
+	}
+
+
+	@Override
+	public boolean equals(@Nullable Object other) {
+		if (this == other) {
+			return true;
+		}
+		if (!(other instanceof AspectJPointcutAdvisor)) {
+			return false;
+		}
+		AspectJPointcutAdvisor otherAdvisor = (AspectJPointcutAdvisor) other;
+		return this.advice.equals(otherAdvisor.advice);
+	}
+
+	@Override
+	public int hashCode() {
+		return AspectJPointcutAdvisor.class.hashCode() * 29 + this.advice.hashCode();
+	}
+
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.springframework.core.Ordered;
+
+/**
+ * Interface to be implemented by types that can supply the information
+ * needed to sort advice/advisors by AspectJ's precedence rules.
+ *
+ * @author Adrian Colyer
+ * @since 2.0
+ * @see org.springframework.aop.aspectj.autoproxy.AspectJPrecedenceComparator
+ */
+public interface AspectJPrecedenceInformation extends Ordered {
+
+	// Implementation note:
+	// We need the level of indirection this interface provides as otherwise the
+	// AspectJPrecedenceComparator must ask an Advisor for its Advice in all cases
+	// in order to sort advisors. This causes problems with the
+	// InstantiationModelAwarePointcutAdvisor which needs to delay creating
+	// its advice for aspects with non-singleton instantiation models.
+
+	/**
+	 * Return the name of the aspect (bean) in which the advice was declared.
+	 */
+	String getAspectName();
+
+	/**
+	 * Return the declaration order of the advice member within the aspect.
+	 */
+	int getDeclarationOrder();
+
+	/**
+	 * Return whether this is a before advice.
+	 */
+	boolean isBeforeAdvice();
+
+	/**
+	 * Return whether this is an after advice.
+	 */
+	boolean isAfterAdvice();
+
+}

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

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.util.List;
+
+import org.springframework.aop.Advisor;
+import org.springframework.aop.PointcutAdvisor;
+import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
+
+/**
+ * Utility methods for working with AspectJ proxies.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public abstract class AspectJProxyUtils {
+
+	/**
+	 * Add special advisors if necessary to work with a proxy chain that contains AspectJ advisors:
+	 * concretely, {@link ExposeInvocationInterceptor} at the beginning of the list.
+	 * <p>This will expose the current Spring AOP invocation (necessary for some AspectJ pointcut
+	 * matching) and make available the current AspectJ JoinPoint. The call will have no effect
+	 * if there are no AspectJ advisors in the advisor chain.
+	 * @param advisors the advisors available
+	 * @return {@code true} if an {@link ExposeInvocationInterceptor} was added to the list,
+	 * otherwise {@code false}
+	 */
+	public static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {
+		// Don't add advisors to an empty list; may indicate that proxying is just not required
+		if (!advisors.isEmpty()) {
+			boolean foundAspectJAdvice = false;
+			for (Advisor advisor : advisors) {
+				// Be careful not to get the Advice without a guard, as this might eagerly
+				// instantiate a non-singleton AspectJ aspect...
+				if (isAspectJAdvice(advisor)) {
+					foundAspectJAdvice = true;
+					break;
+				}
+			}
+			if (foundAspectJAdvice && !advisors.contains(ExposeInvocationInterceptor.ADVISOR)) {
+				advisors.add(0, ExposeInvocationInterceptor.ADVISOR);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Determine whether the given Advisor contains an AspectJ advice.
+	 * @param advisor the Advisor to check
+	 */
+	private static boolean isAspectJAdvice(Advisor advisor) {
+		return (advisor instanceof InstantiationModelAwarePointcutAdvisor ||
+				advisor.getAdvice() instanceof AbstractAspectJAdvice ||
+				(advisor instanceof PointcutAdvisor &&
+						((PointcutAdvisor) advisor).getPointcut() instanceof AspectJExpressionPointcut));
+	}
+
+	static boolean isVariableName(@Nullable String name) {
+		if (!StringUtils.hasLength(name)) {
+			return false;
+		}
+		if (!Character.isJavaIdentifierStart(name.charAt(0))) {
+			return false;
+		}
+		for (int i = 1; i < name.length(); i++) {
+			if (!Character.isJavaIdentifierPart(name.charAt(i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+}

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

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2002-2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.bridge.AbortException;
+import org.aspectj.bridge.IMessage;
+import org.aspectj.bridge.IMessage.Kind;
+import org.aspectj.bridge.IMessageHandler;
+
+/**
+ * Implementation of AspectJ's {@link IMessageHandler} interface that
+ * routes AspectJ weaving messages through the same logging system as the
+ * regular Spring messages.
+ *
+ * <p>Pass the option...
+ *
+ * <p><code class="code">-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler</code>
+ *
+ * <p>to the weaver; for example, specifying the following in a
+ * "{@code META-INF/aop.xml} file:
+ *
+ * <p><code class="code">&lt;weaver options="..."/&gt;</code>
+ *
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public class AspectJWeaverMessageHandler implements IMessageHandler {
+
+	private static final String AJ_ID = "[AspectJ] ";
+
+	private static final Log logger = LogFactory.getLog("AspectJ Weaver");
+
+
+	@Override
+	public boolean handleMessage(IMessage message) throws AbortException {
+		Kind messageKind = message.getKind();
+		if (messageKind == IMessage.DEBUG) {
+			if (logger.isDebugEnabled()) {
+				logger.debug(makeMessageFor(message));
+				return true;
+			}
+		}
+		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));
+				return true;
+			}
+		}
+		else if (messageKind == IMessage.ERROR) {
+			if (logger.isErrorEnabled()) {
+				logger.error(makeMessageFor(message));
+				return true;
+			}
+		}
+		else if (messageKind == IMessage.ABORT) {
+			if (logger.isFatalEnabled()) {
+				logger.fatal(makeMessageFor(message));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private String makeMessageFor(IMessage aMessage) {
+		return AJ_ID + aMessage.getMessage();
+	}
+
+	@Override
+	public boolean isIgnoring(Kind messageKind) {
+		// We want to see everything, and allow configuration of log levels dynamically.
+		return false;
+	}
+
+	@Override
+	public void dontIgnore(Kind messageKind) {
+		// We weren't ignoring anything anyway...
+	}
+
+	@Override
+	public void ignore(Kind kind) {
+		// We weren't ignoring anything anyway...
+	}
+
+}

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

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.aopalliance.aop.Advice;
+
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.IntroductionAdvisor;
+import org.springframework.aop.IntroductionInterceptor;
+import org.springframework.aop.support.ClassFilters;
+import org.springframework.aop.support.DelegatePerTargetObjectIntroductionInterceptor;
+import org.springframework.aop.support.DelegatingIntroductionInterceptor;
+
+/**
+ * Introduction advisor delegating to the given object.
+ * Implements AspectJ annotation-style behavior for the DeclareParents annotation.
+ *
+ * @author Rod Johnson
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class DeclareParentsAdvisor implements IntroductionAdvisor {
+
+	private final Advice advice;
+
+	private final Class<?> introducedInterface;
+
+	private final ClassFilter typePatternClassFilter;
+
+
+	/**
+	 * Create a new advisor for this DeclareParents field.
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param defaultImpl the default implementation class
+	 */
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> defaultImpl) {
+		this(interfaceType, typePattern,
+				new DelegatePerTargetObjectIntroductionInterceptor(defaultImpl, interfaceType));
+	}
+
+	/**
+	 * Create a new advisor for this DeclareParents field.
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param delegateRef the delegate implementation object
+	 */
+	public DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Object delegateRef) {
+		this(interfaceType, typePattern, new DelegatingIntroductionInterceptor(delegateRef));
+	}
+
+	/**
+	 * Private constructor to share common code between impl-based delegate and reference-based delegate
+	 * (cannot use method such as init() to share common code, due the use of final fields).
+	 * @param interfaceType static field defining the introduction
+	 * @param typePattern type pattern the introduction is restricted to
+	 * @param interceptor the delegation advice as {@link IntroductionInterceptor}
+	 */
+	private DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, IntroductionInterceptor interceptor) {
+		this.advice = interceptor;
+		this.introducedInterface = interfaceType;
+
+		// Excludes methods implemented.
+		ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);
+		ClassFilter exclusion = (clazz -> !this.introducedInterface.isAssignableFrom(clazz));
+		this.typePatternClassFilter = ClassFilters.intersection(typePatternFilter, exclusion);
+	}
+
+
+	@Override
+	public ClassFilter getClassFilter() {
+		return this.typePatternClassFilter;
+	}
+
+	@Override
+	public void validateInterfaces() throws IllegalArgumentException {
+		// Do nothing
+	}
+
+	@Override
+	public boolean isPerInstance() {
+		return true;
+	}
+
+	@Override
+	public Advice getAdvice() {
+		return this.advice;
+	}
+
+	@Override
+	public Class<?>[] getInterfaces() {
+		return new Class<?>[] {this.introducedInterface};
+	}
+
+}

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2002-2006 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.springframework.aop.PointcutAdvisor;
+
+/**
+ * Interface to be implemented by Spring AOP Advisors wrapping AspectJ
+ * aspects that may have a lazy initialization strategy. For example,
+ * a perThis instantiation model would mean lazy initialization of the advice.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public interface InstantiationModelAwarePointcutAdvisor extends PointcutAdvisor {
+
+	/**
+	 * Return whether this advisor is lazily initializing its underlying advice.
+	 */
+	boolean isLazy();
+
+	/**
+	 * Return whether this advisor has already instantiated its advice.
+	 */
+	boolean isAdviceInstantiated();
+
+}

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

@@ -0,0 +1,334 @@
+/*
+ * Copyright 2002-2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.Signature;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.aspectj.lang.reflect.SourceLocation;
+import org.aspectj.runtime.internal.AroundClosure;
+
+import org.springframework.aop.ProxyMethodInvocation;
+import org.springframework.core.DefaultParameterNameDiscoverer;
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * An implementation of the AspectJ {@link ProceedingJoinPoint} interface
+ * wrapping an AOP Alliance {@link org.aopalliance.intercept.MethodInvocation}.
+ *
+ * <p><b>Note</b>: The {@code getThis()} method returns the current Spring AOP proxy.
+ * The {@code getTarget()} method returns the current Spring AOP target (which may be
+ * {@code null} if there is no target instance) as a plain POJO without any advice.
+ * <b>If you want to call the object and have the advice take effect, use {@code getThis()}.</b>
+ * A common example is casting the object to an introduced interface in the implementation of
+ * an introduction. There is no such distinction between target and proxy in AspectJ itself.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Adrian Colyer
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+public class MethodInvocationProceedingJoinPoint implements ProceedingJoinPoint, JoinPoint.StaticPart {
+
+	private static final ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
+
+	private final ProxyMethodInvocation methodInvocation;
+
+	@Nullable
+	private Object[] args;
+
+	/** Lazily initialized signature object. */
+	@Nullable
+	private Signature signature;
+
+	/** Lazily initialized source location object. */
+	@Nullable
+	private SourceLocation sourceLocation;
+
+
+	/**
+	 * Create a new MethodInvocationProceedingJoinPoint, wrapping the given
+	 * Spring ProxyMethodInvocation object.
+	 * @param methodInvocation the Spring ProxyMethodInvocation object
+	 */
+	public MethodInvocationProceedingJoinPoint(ProxyMethodInvocation methodInvocation) {
+		Assert.notNull(methodInvocation, "MethodInvocation must not be null");
+		this.methodInvocation = methodInvocation;
+	}
+
+
+	@Override
+	public void set$AroundClosure(AroundClosure aroundClosure) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	@Nullable
+	public Object proceed() throws Throwable {
+		return this.methodInvocation.invocableClone().proceed();
+	}
+
+	@Override
+	@Nullable
+	public Object proceed(Object[] arguments) throws Throwable {
+		Assert.notNull(arguments, "Argument array passed to proceed cannot be null");
+		if (arguments.length != this.methodInvocation.getArguments().length) {
+			throw new IllegalArgumentException("Expecting " +
+					this.methodInvocation.getArguments().length + " arguments to proceed, " +
+					"but was passed " + arguments.length + " arguments");
+		}
+		this.methodInvocation.setArguments(arguments);
+		return this.methodInvocation.invocableClone(arguments).proceed();
+	}
+
+	/**
+	 * Returns the Spring AOP proxy. Cannot be {@code null}.
+	 */
+	@Override
+	public Object getThis() {
+		return this.methodInvocation.getProxy();
+	}
+
+	/**
+	 * Returns the Spring AOP target. May be {@code null} if there is no target.
+	 */
+	@Override
+	@Nullable
+	public Object getTarget() {
+		return this.methodInvocation.getThis();
+	}
+
+	@Override
+	public Object[] getArgs() {
+		if (this.args == null) {
+			this.args = this.methodInvocation.getArguments().clone();
+		}
+		return this.args;
+	}
+
+	@Override
+	public Signature getSignature() {
+		if (this.signature == null) {
+			this.signature = new MethodSignatureImpl();
+		}
+		return this.signature;
+	}
+
+	@Override
+	public SourceLocation getSourceLocation() {
+		if (this.sourceLocation == null) {
+			this.sourceLocation = new SourceLocationImpl();
+		}
+		return this.sourceLocation;
+	}
+
+	@Override
+	public String getKind() {
+		return ProceedingJoinPoint.METHOD_EXECUTION;
+	}
+
+	@Override
+	public int getId() {
+		// TODO: It's just an adapter but returning 0 might still have side effects...
+		return 0;
+	}
+
+	@Override
+	public JoinPoint.StaticPart getStaticPart() {
+		return this;
+	}
+
+	@Override
+	public String toShortString() {
+		return "execution(" + getSignature().toShortString() + ")";
+	}
+
+	@Override
+	public String toLongString() {
+		return "execution(" + getSignature().toLongString() + ")";
+	}
+
+	@Override
+	public String toString() {
+		return "execution(" + getSignature().toString() + ")";
+	}
+
+
+	/**
+	 * Lazily initialized MethodSignature.
+	 */
+	private class MethodSignatureImpl implements MethodSignature {
+
+		@Nullable
+		private volatile String[] parameterNames;
+
+		@Override
+		public String getName() {
+			return methodInvocation.getMethod().getName();
+		}
+
+		@Override
+		public int getModifiers() {
+			return methodInvocation.getMethod().getModifiers();
+		}
+
+		@Override
+		public Class<?> getDeclaringType() {
+			return methodInvocation.getMethod().getDeclaringClass();
+		}
+
+		@Override
+		public String getDeclaringTypeName() {
+			return methodInvocation.getMethod().getDeclaringClass().getName();
+		}
+
+		@Override
+		public Class<?> getReturnType() {
+			return methodInvocation.getMethod().getReturnType();
+		}
+
+		@Override
+		public Method getMethod() {
+			return methodInvocation.getMethod();
+		}
+
+		@Override
+		public Class<?>[] getParameterTypes() {
+			return methodInvocation.getMethod().getParameterTypes();
+		}
+
+		@Override
+		@Nullable
+		public String[] getParameterNames() {
+			String[] parameterNames = this.parameterNames;
+			if (parameterNames == null) {
+				parameterNames = parameterNameDiscoverer.getParameterNames(getMethod());
+				this.parameterNames = parameterNames;
+			}
+			return parameterNames;
+		}
+
+		@Override
+		public Class<?>[] getExceptionTypes() {
+			return methodInvocation.getMethod().getExceptionTypes();
+		}
+
+		@Override
+		public String toShortString() {
+			return toString(false, false, false, false);
+		}
+
+		@Override
+		public String toLongString() {
+			return toString(true, true, true, true);
+		}
+
+		@Override
+		public String toString() {
+			return toString(false, true, false, true);
+		}
+
+		private String toString(boolean includeModifier, boolean includeReturnTypeAndArgs,
+				boolean useLongReturnAndArgumentTypeName, boolean useLongTypeName) {
+
+			StringBuilder sb = new StringBuilder();
+			if (includeModifier) {
+				sb.append(Modifier.toString(getModifiers()));
+				sb.append(" ");
+			}
+			if (includeReturnTypeAndArgs) {
+				appendType(sb, getReturnType(), useLongReturnAndArgumentTypeName);
+				sb.append(" ");
+			}
+			appendType(sb, getDeclaringType(), useLongTypeName);
+			sb.append(".");
+			sb.append(getMethod().getName());
+			sb.append("(");
+			Class<?>[] parametersTypes = getParameterTypes();
+			appendTypes(sb, parametersTypes, includeReturnTypeAndArgs, useLongReturnAndArgumentTypeName);
+			sb.append(")");
+			return sb.toString();
+		}
+
+		private void appendTypes(StringBuilder sb, Class<?>[] types, boolean includeArgs,
+				boolean useLongReturnAndArgumentTypeName) {
+
+			if (includeArgs) {
+				for (int size = types.length, i = 0; i < size; i++) {
+					appendType(sb, types[i], useLongReturnAndArgumentTypeName);
+					if (i < size - 1) {
+						sb.append(",");
+					}
+				}
+			}
+			else {
+				if (types.length != 0) {
+					sb.append("..");
+				}
+			}
+		}
+
+		private void appendType(StringBuilder sb, Class<?> type, boolean useLongTypeName) {
+			if (type.isArray()) {
+				appendType(sb, type.getComponentType(), useLongTypeName);
+				sb.append("[]");
+			}
+			else {
+				sb.append(useLongTypeName ? type.getName() : type.getSimpleName());
+			}
+		}
+	}
+
+
+	/**
+	 * Lazily initialized SourceLocation.
+	 */
+	private class SourceLocationImpl implements SourceLocation {
+
+		@Override
+		public Class<?> getWithinType() {
+			if (methodInvocation.getThis() == null) {
+				throw new UnsupportedOperationException("No source location joinpoint available: target is null");
+			}
+			return methodInvocation.getThis().getClass();
+		}
+
+		@Override
+		public String getFileName() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public int getLine() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		@Deprecated
+		public int getColumn() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+}

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

@@ -0,0 +1,297 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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;
+import org.aspectj.weaver.ast.FieldGetCall;
+import org.aspectj.weaver.ast.HasAnnotation;
+import org.aspectj.weaver.ast.ITestVisitor;
+import org.aspectj.weaver.ast.Instanceof;
+import org.aspectj.weaver.ast.Literal;
+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;
+
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * This class encapsulates some AspectJ internal knowledge that should be
+ * pushed back into the AspectJ project in a future release.
+ *
+ * <p>It relies on implementation specific knowledge in AspectJ to break
+ * encapsulation and do something AspectJ was not designed to do: query
+ * the types of runtime tests that will be performed. The code here should
+ * migrate to {@code ShadowMatch.getVariablesInvolvedInRuntimeTest()}
+ * or some similar operation.
+ *
+ * <p>See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=151593">Bug 151593</a>
+ *
+ * @author Adrian Colyer
+ * @author Ramnivas Laddad
+ * @since 2.0
+ */
+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);
+		}
+	}
+
+
+	@Nullable
+	private final Test runtimeTest;
+
+
+	public RuntimeTestWalker(ShadowMatch shadowMatch) {
+		try {
+			ReflectionUtils.makeAccessible(residualTestField);
+			this.runtimeTest = (Test) residualTestField.get(shadowMatch);
+		}
+		catch (IllegalAccessException ex) {
+			throw new IllegalStateException(ex);
+		}
+	}
+
+
+	/**
+	 * If the test uses any of the this, target, at_this, at_target, and at_annotation vars,
+	 * then it tests subtype sensitive vars.
+	 */
+	public boolean testsSubtypeSensitiveVars() {
+		return (this.runtimeTest != null &&
+				new SubtypeSensitiveVarTypeTestVisitor().testsSubtypeSensitiveVars(this.runtimeTest));
+	}
+
+	public boolean testThisInstanceOfResidue(Class<?> thisClass) {
+		return (this.runtimeTest != null &&
+				new ThisInstanceOfResidueTestVisitor(thisClass).thisInstanceOfMatches(this.runtimeTest));
+	}
+
+	public boolean testTargetInstanceOfResidue(Class<?> targetClass) {
+		return (this.runtimeTest != null &&
+				new TargetInstanceOfResidueTestVisitor(targetClass).targetInstanceOfMatches(this.runtimeTest));
+	}
+
+
+	private static class TestVisitorAdapter implements ITestVisitor {
+
+		protected static final int THIS_VAR = 0;
+		protected static final int TARGET_VAR = 1;
+		protected static final int AT_THIS_VAR = 3;
+		protected static final int AT_TARGET_VAR = 4;
+		protected static final int AT_ANNOTATION_VAR = 8;
+
+		@Override
+		public void visit(And e) {
+			e.getLeft().accept(this);
+			e.getRight().accept(this);
+		}
+
+		@Override
+		public void visit(Or e) {
+			e.getLeft().accept(this);
+			e.getRight().accept(this);
+		}
+
+		@Override
+		public void visit(Not e) {
+			e.getBody().accept(this);
+		}
+
+		@Override
+		public void visit(Instanceof i) {
+		}
+
+		@Override
+		public void visit(Literal literal) {
+		}
+
+		@Override
+		public void visit(Call call) {
+		}
+
+		@Override
+		public void visit(FieldGetCall fieldGetCall) {
+		}
+
+		@Override
+		public void visit(HasAnnotation hasAnnotation) {
+		}
+
+		@Override
+		public void visit(MatchingContextBasedTest matchingContextTest) {
+		}
+
+		protected int getVarType(ReflectionVar v) {
+			try {
+				ReflectionUtils.makeAccessible(varTypeField);
+				return (Integer) varTypeField.get(v);
+			}
+			catch (IllegalAccessException ex) {
+				throw new IllegalStateException(ex);
+			}
+		}
+	}
+
+
+	private abstract static class InstanceOfResidueTestVisitor extends TestVisitorAdapter {
+
+		private final Class<?> matchClass;
+
+		private boolean matches;
+
+		private final int matchVarType;
+
+		public InstanceOfResidueTestVisitor(Class<?> matchClass, boolean defaultMatches, int matchVarType) {
+			this.matchClass = matchClass;
+			this.matches = defaultMatches;
+			this.matchVarType = matchVarType;
+		}
+
+		public boolean instanceOfMatches(Test test) {
+			test.accept(this);
+			return this.matches;
+		}
+
+		@Override
+		public void visit(Instanceof i) {
+			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 {
+				// 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) {
+				this.matches = false;
+			}
+		}
+	}
+
+
+	/**
+	 * Check if residue of target(TYPE) kind. See SPR-3783 for more details.
+	 */
+	private static class TargetInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
+
+		public TargetInstanceOfResidueTestVisitor(Class<?> targetClass) {
+			super(targetClass, false, TARGET_VAR);
+		}
+
+		public boolean targetInstanceOfMatches(Test test) {
+			return instanceOfMatches(test);
+		}
+	}
+
+
+	/**
+	 * Check if residue of this(TYPE) kind. See SPR-2979 for more details.
+	 */
+	private static class ThisInstanceOfResidueTestVisitor extends InstanceOfResidueTestVisitor {
+
+		public ThisInstanceOfResidueTestVisitor(Class<?> thisClass) {
+			super(thisClass, true, THIS_VAR);
+		}
+
+		// TODO: Optimization: Process only if this() specifies a type and not an identifier.
+		public boolean thisInstanceOfMatches(Test test) {
+			return instanceOfMatches(test);
+		}
+	}
+
+
+	private static class SubtypeSensitiveVarTypeTestVisitor extends TestVisitorAdapter {
+
+		private final Object thisObj = new Object();
+
+		private final Object targetObj = new Object();
+
+		private final Object[] argsObjs = new Object[0];
+
+		private boolean testsSubtypeSensitiveVars = false;
+
+		public boolean testsSubtypeSensitiveVars(Test aTest) {
+			aTest.accept(this);
+			return this.testsSubtypeSensitiveVars;
+		}
+
+		@Override
+		public void visit(Instanceof i) {
+			ReflectionVar v = (ReflectionVar) i.getVar();
+			Object varUnderTest = v.getBindingAtJoinPoint(this.thisObj, this.targetObj, this.argsObjs);
+			if (varUnderTest == this.thisObj || varUnderTest == this.targetObj) {
+				this.testsSubtypeSensitiveVars = true;
+			}
+		}
+
+		@Override
+		public void visit(HasAnnotation hasAnn) {
+			// 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) {
+				this.testsSubtypeSensitiveVars = true;
+			}
+		}
+	}
+
+}

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

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.lang.reflect.InvocationTargetException;
+
+import org.springframework.aop.framework.AopConfigException;
+import org.springframework.core.Ordered;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ReflectionUtils;
+
+/**
+ * Implementation of {@link AspectInstanceFactory} that creates a new instance
+ * of the specified aspect class for every {@link #getAspectInstance()} call.
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.4
+ */
+public class SimpleAspectInstanceFactory implements AspectInstanceFactory {
+
+	private final Class<?> aspectClass;
+
+
+	/**
+	 * Create a new SimpleAspectInstanceFactory for the given aspect class.
+	 * @param aspectClass the aspect class
+	 */
+	public SimpleAspectInstanceFactory(Class<?> aspectClass) {
+		Assert.notNull(aspectClass, "Aspect class must not be null");
+		this.aspectClass = aspectClass;
+	}
+
+
+	/**
+	 * Return the specified aspect class (never {@code null}).
+	 */
+	public final Class<?> getAspectClass() {
+		return this.aspectClass;
+	}
+
+	@Override
+	public final Object getAspectInstance() {
+		try {
+			return ReflectionUtils.accessibleConstructor(this.aspectClass).newInstance();
+		}
+		catch (NoSuchMethodException ex) {
+			throw new AopConfigException(
+					"No default constructor on aspect class: " + this.aspectClass.getName(), ex);
+		}
+		catch (InstantiationException ex) {
+			throw new AopConfigException(
+					"Unable to instantiate aspect class: " + this.aspectClass.getName(), ex);
+		}
+		catch (IllegalAccessException ex) {
+			throw new AopConfigException(
+					"Could not access aspect constructor: " + this.aspectClass.getName(), ex);
+		}
+		catch (InvocationTargetException ex) {
+			throw new AopConfigException(
+					"Failed to invoke aspect constructor: " + this.aspectClass.getName(), ex.getTargetException());
+		}
+	}
+
+	@Override
+	@Nullable
+	public ClassLoader getAspectClassLoader() {
+		return this.aspectClass.getClassLoader();
+	}
+
+	/**
+	 * Determine the order for this factory's aspect instance,
+	 * either an instance-specific order expressed through implementing
+	 * the {@link org.springframework.core.Ordered} interface,
+	 * or a fallback order.
+	 * @see org.springframework.core.Ordered
+	 * @see #getOrderForAspectClass
+	 */
+	@Override
+	public int getOrder() {
+		return getOrderForAspectClass(this.aspectClass);
+	}
+
+	/**
+	 * Determine a fallback order for the case that the aspect instance
+	 * does not express an instance-specific order through implementing
+	 * the {@link org.springframework.core.Ordered} interface.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
+	 * @param aspectClass the aspect class
+	 */
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
+		return Ordered.LOWEST_PRECEDENCE;
+	}
+
+}

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2002-2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import java.io.Serializable;
+
+import org.springframework.core.Ordered;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link AspectInstanceFactory} that is backed by a
+ * specified singleton object, returning the same instance for every
+ * {@link #getAspectInstance()} call.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @since 2.0
+ * @see SimpleAspectInstanceFactory
+ */
+@SuppressWarnings("serial")
+public class SingletonAspectInstanceFactory implements AspectInstanceFactory, Serializable {
+
+	private final Object aspectInstance;
+
+
+	/**
+	 * Create a new SingletonAspectInstanceFactory for the given aspect instance.
+	 * @param aspectInstance the singleton aspect instance
+	 */
+	public SingletonAspectInstanceFactory(Object aspectInstance) {
+		Assert.notNull(aspectInstance, "Aspect instance must not be null");
+		this.aspectInstance = aspectInstance;
+	}
+
+
+	@Override
+	public final Object getAspectInstance() {
+		return this.aspectInstance;
+	}
+
+	@Override
+	@Nullable
+	public ClassLoader getAspectClassLoader() {
+		return this.aspectInstance.getClass().getClassLoader();
+	}
+
+	/**
+	 * Determine the order for this factory's aspect instance,
+	 * either an instance-specific order expressed through implementing
+	 * the {@link org.springframework.core.Ordered} interface,
+	 * or a fallback order.
+	 * @see org.springframework.core.Ordered
+	 * @see #getOrderForAspectClass
+	 */
+	@Override
+	public int getOrder() {
+		if (this.aspectInstance instanceof Ordered) {
+			return ((Ordered) this.aspectInstance).getOrder();
+		}
+		return getOrderForAspectClass(this.aspectInstance.getClass());
+	}
+
+	/**
+	 * Determine a fallback order for the case that the aspect instance
+	 * does not express an instance-specific order through implementing
+	 * the {@link org.springframework.core.Ordered} interface.
+	 * <p>The default implementation simply returns {@code Ordered.LOWEST_PRECEDENCE}.
+	 * @param aspectClass the aspect class
+	 */
+	protected int getOrderForAspectClass(Class<?> aspectClass) {
+		return Ordered.LOWEST_PRECEDENCE;
+	}
+
+}

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

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2002-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj;
+
+import org.aspectj.weaver.tools.PointcutParser;
+import org.aspectj.weaver.tools.TypePatternMatcher;
+
+import org.springframework.aop.ClassFilter;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * Spring AOP {@link ClassFilter} implementation using AspectJ type matching.
+ *
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Sam Brannen
+ * @since 2.0
+ */
+public class TypePatternClassFilter implements ClassFilter {
+
+	private String typePattern = "";
+
+	@Nullable
+	private TypePatternMatcher aspectJTypePatternMatcher;
+
+
+	/**
+	 * Creates a new instance of the {@link TypePatternClassFilter} class.
+	 * <p>This is the JavaBean constructor; be sure to set the
+	 * {@link #setTypePattern(String) typePattern} property, else a
+	 * no doubt fatal {@link IllegalStateException} will be thrown
+	 * when the {@link #matches(Class)} method is first invoked.
+	 */
+	public TypePatternClassFilter() {
+	}
+
+	/**
+	 * Create a fully configured {@link TypePatternClassFilter} using the
+	 * given type pattern.
+	 * @param typePattern the type pattern that AspectJ weaver should parse
+	 */
+	public TypePatternClassFilter(String typePattern) {
+		setTypePattern(typePattern);
+	}
+
+
+	/**
+	 * Set the AspectJ type pattern to match.
+	 * <p>Examples include:
+	 * <code class="code">
+	 * org.springframework.beans.*
+	 * </code>
+	 * This will match any class or interface in the given package.
+	 * <code class="code">
+	 * org.springframework.beans.ITestBean+
+	 * </code>
+	 * This will match the {@code ITestBean} interface and any class
+	 * that implements it.
+	 * <p>These conventions are established by AspectJ, not Spring AOP.
+	 * @param typePattern the type pattern that AspectJ weaver should parse
+	 */
+	public void setTypePattern(String typePattern) {
+		Assert.notNull(typePattern, "Type pattern must not be null");
+		this.typePattern = typePattern;
+		this.aspectJTypePatternMatcher =
+				PointcutParser.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution().
+				parseTypePattern(replaceBooleanOperators(typePattern));
+	}
+
+	/**
+	 * Return the AspectJ type pattern to match.
+	 */
+	public String getTypePattern() {
+		return this.typePattern;
+	}
+
+
+	/**
+	 * Should the pointcut apply to the given interface or target class?
+	 * @param clazz candidate target class
+	 * @return whether the advice should apply to this candidate target class
+	 * @throws IllegalStateException if no {@link #setTypePattern(String)} has been set
+	 */
+	@Override
+	public boolean matches(Class<?> clazz) {
+		Assert.state(this.aspectJTypePatternMatcher != null, "No type pattern has been set");
+		return this.aspectJTypePatternMatcher.matches(clazz);
+	}
+
+	/**
+	 * If a type pattern has been specified in XML, the user cannot
+	 * write {@code and} as "&&" (though &amp;&amp; will work).
+	 * We also allow {@code and} between two sub-expressions.
+	 * <p>This method converts back to {@code &&} for the AspectJ pointcut parser.
+	 */
+	private String replaceBooleanOperators(String pcExpr) {
+		String result = StringUtils.replace(pcExpr," and "," && ");
+		result = StringUtils.replace(result, " or ", " || ");
+		return StringUtils.replace(result, " not ", " ! ");
+	}
+
+	@Override
+	public boolean equals(Object other) {
+		return (this == other || (other instanceof TypePatternClassFilter &&
+				ObjectUtils.nullSafeEquals(this.typePattern, ((TypePatternClassFilter) other).typePattern)));
+	}
+
+	@Override
+	public int hashCode() {
+		return ObjectUtils.nullSafeHashCode(this.typePattern);
+	}
+
+	@Override
+	public String toString() {
+		return getClass().getName() + ": " + this.typePattern;
+	}
+
+}

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

@@ -0,0 +1,285 @@
+/*
+ * Copyright 2002-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.aop.aspectj.annotation;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.AfterThrowing;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.aspectj.lang.reflect.AjType;
+import org.aspectj.lang.reflect.AjTypeSystem;
+import org.aspectj.lang.reflect.PerClauseKind;
+
+import org.springframework.aop.framework.AopConfigException;
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.lang.Nullable;
+
+/**
+ * Abstract base class for factories that can create Spring AOP Advisors
+ * given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.
+ *
+ * <p>This class handles annotation parsing and validation functionality.
+ * It does not actually generate Spring AOP Advisors, which is deferred to subclasses.
+ *
+ * @author Rod Johnson
+ * @author Adrian Colyer
+ * @author Juergen Hoeller
+ * @since 2.0
+ */
+public abstract class AbstractAspectJAdvisorFactory implements AspectJAdvisorFactory {
+
+	private static final String AJC_MAGIC = "ajc$";
+
+	private static final Class<?>[] ASPECTJ_ANNOTATION_CLASSES = new Class<?>[] {
+			Pointcut.class, Around.class, Before.class, After.class, AfterReturning.class, AfterThrowing.class};
+
+
+	/** Logger available to subclasses. */
+	protected final Log logger = LogFactory.getLog(getClass());
+
+	protected final ParameterNameDiscoverer parameterNameDiscoverer = new AspectJAnnotationParameterNameDiscoverer();
+
+
+	/**
+	 * We consider something to be an AspectJ aspect suitable for use by the Spring AOP system
+	 * if it has the @Aspect annotation, and was not compiled by ajc. The reason for this latter test
+	 * is that aspects written in the code-style (AspectJ language) also have the annotation present
+	 * when compiled by ajc with the -1.5 flag, yet they cannot be consumed by Spring AOP.
+	 */
+	@Override
+	public boolean isAspect(Class<?> clazz) {
+		return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
+	}
+
+	private boolean hasAspectAnnotation(Class<?> clazz) {
+		return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
+	}
+
+	/**
+	 * We need to detect this as "code-style" AspectJ aspects should not be
+	 * interpreted by Spring AOP.
+	 */
+	private boolean compiledByAjc(Class<?> clazz) {
+		// The AJTypeSystem goes to great lengths to provide a uniform appearance between code-style and
+		// annotation-style aspects. Therefore there is no 'clean' way to tell them apart. Here we rely on
+		// an implementation detail of the AspectJ compiler.
+		for (Field field : clazz.getDeclaredFields()) {
+			if (field.getName().startsWith(AJC_MAGIC)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public void validate(Class<?> aspectClass) throws AopConfigException {
+		// If the parent has the annotation and isn't abstract it's an error
+		if (aspectClass.getSuperclass().getAnnotation(Aspect.class) != null &&
+				!Modifier.isAbstract(aspectClass.getSuperclass().getModifiers())) {
+			throw new AopConfigException("[" + aspectClass.getName() + "] cannot extend concrete aspect [" +
+					aspectClass.getSuperclass().getName() + "]");
+		}
+
+		AjType<?> ajType = AjTypeSystem.getAjType(aspectClass);
+		if (!ajType.isAspect()) {
+			throw new NotAnAtAspectException(aspectClass);
+		}
+		if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOW) {
+			throw new AopConfigException(aspectClass.getName() + " uses percflow instantiation model: " +
+					"This is not supported in Spring AOP.");
+		}
+		if (ajType.getPerClause().getKind() == PerClauseKind.PERCFLOWBELOW) {
+			throw new AopConfigException(aspectClass.getName() + " uses percflowbelow instantiation model: " +
+					"This is not supported in Spring AOP.");
+		}
+	}
+
+	/**
+	 * Find and return the first AspectJ annotation on the given method
+	 * (there <i>should</i> only be one anyway...).
+	 */
+	@SuppressWarnings("unchecked")
+	@Nullable
+	protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
+		for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
+			AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
+			if (foundAnnotation != null) {
+				return foundAnnotation;
+			}
+		}
+		return null;
+	}
+
+	@Nullable
+	private static <A extends Annotation> AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
+		A result = AnnotationUtils.findAnnotation(method, toLookFor);
+		if (result != null) {
+			return new AspectJAnnotation<>(result);
+		}
+		else {
+			return null;
+		}
+	}
+
+
+	/**
+	 * Enum for AspectJ annotation types.
+	 * @see AspectJAnnotation#getAnnotationType()
+	 */
+	protected enum AspectJAnnotationType {
+
+		AtPointcut, AtAround, AtBefore, AtAfter, AtAfterReturning, AtAfterThrowing
+	}
+
+
+	/**
+	 * Class modelling an AspectJ annotation, exposing its type enumeration and
+	 * pointcut String.
+	 * @param <A> the annotation type
+	 */
+	protected static class AspectJAnnotation<A extends Annotation> {
+
+		private static final String[] EXPRESSION_ATTRIBUTES = new String[] {"pointcut", "value"};
+
+		private static Map<Class<?>, AspectJAnnotationType> annotationTypeMap = new HashMap<>(8);
+
+		static {
+			annotationTypeMap.put(Pointcut.class, AspectJAnnotationType.AtPointcut);
+			annotationTypeMap.put(Around.class, AspectJAnnotationType.AtAround);
+			annotationTypeMap.put(Before.class, AspectJAnnotationType.AtBefore);
+			annotationTypeMap.put(After.class, AspectJAnnotationType.AtAfter);
+			annotationTypeMap.put(AfterReturning.class, AspectJAnnotationType.AtAfterReturning);
+			annotationTypeMap.put(AfterThrowing.class, AspectJAnnotationType.AtAfterThrowing);
+		}
+
+		private final A annotation;
+
+		private final AspectJAnnotationType annotationType;
+
+		private final String pointcutExpression;
+
+		private final String argumentNames;
+
+		public AspectJAnnotation(A annotation) {
+			this.annotation = annotation;
+			this.annotationType = determineAnnotationType(annotation);
+			try {
+				this.pointcutExpression = resolveExpression(annotation);
+				Object argNames = AnnotationUtils.getValue(annotation, "argNames");
+				this.argumentNames = (argNames instanceof String ? (String) argNames : "");
+			}
+			catch (Exception ex) {
+				throw new IllegalArgumentException(annotation + " is not a valid AspectJ annotation", ex);
+			}
+		}
+
+		private AspectJAnnotationType determineAnnotationType(A annotation) {
+			AspectJAnnotationType type = annotationTypeMap.get(annotation.annotationType());
+			if (type != null) {
+				return type;
+			}
+			throw new IllegalStateException("Unknown annotation type: " + annotation);
+		}
+
+		private String resolveExpression(A annotation) {
+			for (String attributeName : EXPRESSION_ATTRIBUTES) {
+				Object val = AnnotationUtils.getValue(annotation, attributeName);
+				if (val instanceof String) {
+					String str = (String) val;
+					if (!str.isEmpty()) {
+						return str;
+					}
+				}
+			}
+			throw new IllegalStateException("Failed to resolve expression: " + annotation);
+		}
+
+		public AspectJAnnotationType getAnnotationType() {
+			return this.annotationType;
+		}
+
+		public A getAnnotation() {
+			return this.annotation;
+		}
+
+		public String getPointcutExpression() {
+			return this.pointcutExpression;
+		}
+
+		public String getArgumentNames() {
+			return this.argumentNames;
+		}
+
+		@Override
+		public String toString() {
+			return this.annotation.toString();
+		}
+	}
+
+
+	/**
+	 * ParameterNameDiscoverer implementation that analyzes the arg names
+	 * specified at the AspectJ annotation level.
+	 */
+	private static class AspectJAnnotationParameterNameDiscoverer implements ParameterNameDiscoverer {
+
+		@Override
+		@Nullable
+		public String[] getParameterNames(Method method) {
+			if (method.getParameterCount() == 0) {
+				return new String[0];
+			}
+			AspectJAnnotation<?> annotation = findAspectJAnnotationOnMethod(method);
+			if (annotation == null) {
+				return null;
+			}
+			StringTokenizer nameTokens = new StringTokenizer(annotation.getArgumentNames(), ",");
+			if (nameTokens.countTokens() > 0) {
+				String[] names = new String[nameTokens.countTokens()];
+				for (int i = 0; i < names.length; i++) {
+					names[i] = nameTokens.nextToken();
+				}
+				return names;
+			}
+			else {
+				return null;
+			}
+		}
+
+		@Override
+		@Nullable
+		public String[] getParameterNames(Constructor<?> ctor) {
+			throw new UnsupportedOperationException("Spring AOP cannot handle constructor advice");
+		}
+	}
+
+}