Introduce @EnableAspectJAutoProxy

Issue: SPR-8138

org.springframework.aop/src/main/resources/org/springframework/aop/config/spring-aop-3.1.xsd

@@ -72,6 +72,9 @@
 		<xsd:annotation>
 			<xsd:documentation source="java:org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"><![CDATA[
 	Enables the use of the @AspectJ style of Spring AOP.
+
+	See org.springframework.context.annotation.EnableAspectJAutoProxy Javadoc
+	for information on code-based alternatives to this XML element.
 			]]></xsd:documentation>
 		</xsd:annotation>
 		<xsd:complexType>

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

+/*
+ * 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

+/*
+ * 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;
+
+}

org.springframework.context/src/test/java/org/springframework/context/annotation/EnableAspectJAutoProxyTests.java

+/*
+ * 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
+ *
+import org.springframework.aop.aspectj.annotation.EnableAspectJAutoProxy;
+
+ *      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 static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.context.ApplicationContext;
+
+import example.scannable.FooService;
+import example.scannable.ServiceInvocationCounter;
+
+/**
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ */
+public class EnableAspectJAutoProxyTests {
+
+	@Configuration
+	@ComponentScan("example.scannable")
+	@EnableAspectJAutoProxy
+	static class Config_WithJDKProxy {
+	}
+
+	@Configuration
+	@ComponentScan("example.scannable")
+	@EnableAspectJAutoProxy(proxyTargetClass=true)
+	static class Config_WithCGLIBProxy {
+	}
+
+	@Test
+	public void withJDKProxy() throws Exception {
+		ApplicationContext ctx =
+				new AnnotationConfigApplicationContext(Config_WithJDKProxy.class);
+
+		aspectIsApplied(ctx);
+		assertThat(AopUtils.isJdkDynamicProxy(ctx.getBean(FooService.class)), is(true));
+	}
+
+	@Test
+	public void withCGLIBProxy() throws Exception {
+		ApplicationContext ctx =
+				new AnnotationConfigApplicationContext(Config_WithCGLIBProxy.class);
+
+		aspectIsApplied(ctx);
+		assertThat(AopUtils.isCglibProxy(ctx.getBean(FooService.class)), is(true));
+	}
+
+
+	private void aspectIsApplied(ApplicationContext ctx) throws Exception {
+		FooService fooService = ctx.getBean(FooService.class);
+		ServiceInvocationCounter counter = ctx.getBean(ServiceInvocationCounter.class);
+
+		assertEquals(0, counter.getCount());
+
+		assertTrue(fooService.isInitCalled());
+		assertEquals(1, counter.getCount());
+
+		String value = fooService.foo(1);
+		assertEquals("bar", value);
+		assertEquals(2, counter.getCount());
+
+		fooService.foo(1);
+		assertEquals(3, counter.getCount());
+	}
+}
\ No newline at end of file

spring-framework-reference/src/new-in-3.1.xml

@@ -128,6 +128,12 @@
           Javadoc</para>
         </listitem>
 
+        <listitem>
+          <para>See
+          org.springframework.context.annotation.EnableAspectJAutoProxy
+          Javadoc</para>
+        </listitem>
+
         <listitem>
           <para>See org.springframework.scheduling.annotation.EnableScheduling
           Javadoc</para>