org.springframework.context.annotation

## 注释类型 EnableAspectJAutoProxy

-     @Target(value=TYPE)
       @Retention(value=RUNTIME)
       @Documented
       @Import(value=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, 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.

  从以下版本开始:
    3.1
  作者:
    Chris Beams, Juergen Hoeller
  另请参阅:
    `Aspect`

- - ### 可选元素概要

    可选元素
    限定符和类型 | 可选元素和说明
    --- | ---
    `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.

- - ### 元素详细资料

    - #### proxyTargetClass

          public abstract boolean proxyTargetClass

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

  - - #### exposeProxy

          public abstract 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.
      从以下版本开始:
        4.3.1
      默认值:
        false