Introduce @EnableAspectJAutoProxy

Issue: SPR-8138

org.springframework.context/src/main/java/org/springframework/context/annotation/AspectJAutoProxyConfigurationSelector.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2002-2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.context.annotation;
+
+import java.util.Map;
+
+import org.springframework.aop.config.AopConfigUtils;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.core.type.AnnotationMetadata;
+
+/**
+ * Registers an {@link org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
+ * AnnotationAwareAspectJAutoProxyCreator} against the current {@link BeanDefinitionRegistry}
+ * as appropriate based on a given @{@link EnableAspectJAutoProxy} annotation.
+ *
+ * @author Chris Beams
+ * @see EnableAspectJAutoProxy
+ * @since 3.1
+ */
+public class AspectJAutoProxyConfigurationSelector implements ImportSelector {
+
+	/**
+	 * Register, escalate, and configure the AspectJ auto proxy creator. Always return
+	 * an empty array, as no actual {@code @Configuration} classes are required.
+	 */
+	public String[] selectImports(ImportSelectorContext context) {
+		BeanDefinitionRegistry registry = context.getBeanDefinitionRegistry();
+		AnnotationMetadata importingClassMetadata = context.getImportingClassMetadata();
+
+		Map<String, Object> enableAJAutoProxy =
+			importingClassMetadata.getAnnotationAttributes(EnableAspectJAutoProxy.class.getName());
+
+		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
+
+		if ((Boolean)enableAJAutoProxy.get("proxyTargetClass")) {
+			AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
+		}
+
+		return new String[] { };
+	}
+
+}

org.springframework.context/src/main/java/org/springframework/context/annotation/Configuration.java

@@ -299,8 +299,9 @@ import org.springframework.stereotype.Component;
  * classes using their respective "{@code @Enable}" annotations. See
  * {@link org.springframework.scheduling.annotation.EnableAsync @EnableAsync},
  * {@link org.springframework.scheduling.annotation.EnableScheduling @EnableScheduling},
- * {@link org.springframework.transaction.annotation.EnableTransactionManagement @EnableTransactionManagement}, and
- * {@link org.springframework.web.servlet.config.annotation.EnableWebMvc @EnableWebMvc}
+ * {@link org.springframework.transaction.annotation.EnableTransactionManagement @EnableTransactionManagement},
+ * {@link org.springframework.context.annotation.EnableAspectJAutoProxy @EnableAspectJAutoProxy},
+ * and {@link org.springframework.web.servlet.config.annotation.EnableWebMvc @EnableWebMvc}
  * for details.
  *
  * <h2>Constraints when authoring {@code @Configuration} classes</h2>

org.springframework.context/src/main/java/org/springframework/context/annotation/EnableAspectJAutoProxy.java

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2002-2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.context.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Enables support for handling components marked with AspectJ's {@code @Aspect} annotation,
+ * similar to functionality found in Spring's {@code <aop:aspectj-autoproxy>} XML element.
+ * To be used on @{@link Configuration} classes as follows:
+ *
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableAspectJAutoProxy
+ * public class AppConfig {
+ *     &#064;Bean
+ *     public FooService fooService() {
+ *         return new FooService();
+ *     }
+ *
+ *     &#064;Bean
+ *     public MyAspect myAspect() {
+ *         return new MyAspect();
+ *     }
+ * }</pre>
+ *
+ * Where {@code FooService} is a typical POJO component and {@code MyAspect} is an
+ * {@code @Aspect}-style aspect:
+ *
+ * <pre class="code">
+ * public class FooService {
+ *     // various methods
+ * }</pre>
+ *
+ * <pre class="code">
+ * &#064;Aspect
+ * public class MyAspect {
+ *     &#064;Before("execution(* FooService+.*(..))")
+ *     public void advice() {
+ *         // advise FooService methods as appropriate
+ *     }
+ * }</pre>
+ *
+ * In the scenario above, {@code @EnableAspectJAutoProxy} ensures that {@code MyAspect}
+ * will be properly processed and that {@code FooService} will be proxied mixing in the
+ * advice that it contributes.
+ *
+ * <p>Users can control the type of proxy that gets created for {@code FooService} using
+ * the {@link #proxyTargetClass()} attribute. The following enables CGLIB-style 'subclass'
+ * proxies as opposed to the default interface-based JDK proxy approach.
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;EnableAspectJAutoProxy(proxyTargetClass=true)
+ * public class AppConfig {
+ *     // ...
+ * }</pre>
+ *
+ * <p>Note that {@code @Aspect} beans may be component-scanned like any other. Simply
+ * mark the aspect with both {@code @Aspect} and {@code @Component}:
+ * <pre class="code">
+ * package com.foo;
+ *
+ * &#064;Component
+ * public class FooService { ... }
+ *
+ * &#064;Aspect
+ * &#064;Component
+ * public class MyAspect { ... }</pre>
+ *
+ * Then use the @{@link ComponentScan} annotation to pick both up:
+ * <pre class="code">
+ * &#064;Configuration
+ * &#064;ComponentScan("com.foo")
+ * &#064;EnableAspectJAutoProxy
+ * public class AppConfig {
+ *     // no explicit &#064Bean definitions required
+ * }</pre>
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see org.aspectj.lang.annotation.Aspect
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Import(AspectJAutoProxyConfigurationSelector.class)
+@Documented
+public @interface EnableAspectJAutoProxy {
+
+	/**
+	 * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
+	 * to standard Java interface-based proxies. The default is {@code false}.
+	 */
+	boolean proxyTargetClass() default false;
+
+}