Package org.springframework.context.annotation

# Annotation Interface EnableAspectJAutoProxy

@Target(TYPE) @Retention(RUNTIME) @Documented @Import(org.springframework.context.annotation.AspectJAutoProxyRegistrar.class) public @interface EnableAspectJAutoProxy
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, for example, 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.

Since:
  3.1
Author:
  Chris Beams, Juergen Hoeller
See Also:
  - `Aspect`

## Optional Element Summary

Optional Elements
Modifier and Type
Optional Element
Description
`boolean`
`exposeProxy`
Indicate that the proxy should be exposed by the AOP framework as a `ThreadLocal` for retrieval via the `AopContext` class.
`boolean`
`proxyTargetClass`
Indicate whether subclass-based (CGLIB) proxies are to be created as opposed to standard Java interface-based proxies.

## Element Details

### proxyTargetClass

boolean proxyTargetClass
Indicate whether subclass-based (CGLIB) proxies are to be created as opposed to standard Java interface-based proxies. The default is `false`.

Default:
  false

### exposeProxy

boolean exposeProxy
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

Default:
  false