/*
* 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
*
* 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 @Aspect annotation, similar to functionality found in Spring's <aop:aspectj-autoproxy> XML element. To be used on @Configuration classes as follows: @Configuration
@EnableAspectJAutoProxy
public class AppConfig {
@Bean
public FooService fooService() {
return new FooService();
}
@Bean
public MyAspect myAspect() {
return new MyAspect();
}
} Where FooService is a typical POJO component and MyAspect is an @Aspect-style aspect: public class FooService {
// various methods
}
@Aspect
public class MyAspect {
@Before("execution(* FooService+.*(..))")
public void advice() {
// advise FooService methods as appropriate
}
} In the scenario above, @EnableAspectJAutoProxy ensures that MyAspect will be properly processed and that FooService will be proxied mixing in the advice that it contributes. Users can control the type of proxy that gets created for FooService using the proxyTargetClass() attribute. The following enables CGLIB-style 'subclass' proxies as opposed to the default interface-based JDK proxy approach.
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AppConfig {
// ...
}
Note that @Aspect beans may be component-scanned like any other. Simply mark the aspect with both @Aspect and @Component:
package com.foo;
@Component
public class FooService { ... }
@Aspect
@Component
public class MyAspect { ... } Then use the @ComponentScan annotation to pick both up: @Configuration
@ComponentScan("com.foo")
@EnableAspectJAutoProxy
public class AppConfig {
// no explicit @Bean definitions required
}
Note: @EnableAspectJAutoProxy applies to its local application context only, allowing for selective proxying of beans at different levels. Please redeclare @EnableAspectJAutoProxy in each individual context, e.g. the common root web application context and any separate DispatcherServlet application contexts, if you need to apply its behavior at multiple levels. This feature requires the presence of aspectjweaver on the classpath. While that dependency is optional for spring-aop in general, it is required for @EnableAspectJAutoProxy and its underlying facilities.
Author: Chris Beams, Juergen Hoeller See Also: Since: 3.1
/**
* 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">
* @Configuration
* @EnableAspectJAutoProxy
* public class AppConfig {
*
* @Bean
* public FooService fooService() {
* return new FooService();
* }
*
* @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">
* @Aspect
* public class MyAspect {
*
* @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">
* @Configuration
* @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;
*
* @Component
* public class FooService { ... }
*
* @Aspect
* @Component
* public class MyAspect { ... }</pre>
*
* Then use the @{@link ComponentScan} annotation to pick both up:
*
* <pre class="code">
* @Configuration
* @ComponentScan("com.foo")
* @EnableAspectJAutoProxy
* public class AppConfig {
*
* // no explicit @Bean definitions required
* }</pre>
*
* <b>Note: {@code @EnableAspectJAutoProxy} applies to its local application context only,
* allowing for selective proxying of beans at different levels.</b> Please redeclare
* {@code @EnableAspectJAutoProxy} in each individual context, e.g. the common root web
* application context and any separate {@code DispatcherServlet} application contexts,
* if you need to apply its behavior at multiple levels.
*
* <p>This feature requires the presence of {@code aspectjweaver} on the classpath.
* While that dependency is optional for {@code spring-aop} in general, it is required
* for {@code @EnableAspectJAutoProxy} and its underlying facilities.
*
* @author Chris Beams
* @author Juergen Hoeller
* @since 3.1
* @see org.aspectj.lang.annotation.Aspect
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
Indicate whether subclass-based (CGLIB) proxies are to be created as opposed to standard Java interface-based proxies. The default is false. /**
* 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;
Indicate that the proxy should be exposed by the AOP framework as a ThreadLocal for retrieval via the AopContext class. Off by default, i.e. no guarantees that AopContext access will work. Since: 4.3.1
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}