前言
前置知识
- 代理范式
- SpringAOP的理解
- Spring动态代理的实现
课程内容
- 一、动态代理的实现
- - 1.1 Cglib动态代理
  - 1.2 JDK动态代理
  - 1.3 ProxyFactory：Spring对两种代理的封装
- 二、AOP基础知识
- - AOP基础概念回顾
  - 通知Advice的分类
  - Advisor的理解
- 三、创建代理对象的方式
- - 3.1 ProxyFactoryBean：SpringAOP早期实现版本
  - 3.2 NameMatchMethodPointcutAdvisor：引入Advisor概念，改进拦截所有方法的问题
  - 3.3 BeanNameAutoProxyCreator：改进只能切一个Bean的问题
  - 3.4 DefaultAdvisorAutoProxyCreator：更强大的AutoProxy方案
- 四、AOP注解方案底层源码解析
- - 4.1 从 @EnableAspectJAutoProxy讲起
  - 4.2 AnnotationAwareAspectJAutoProxyCreator：简单介绍
  - 4.3 概念回顾
  - 4.4 方法详解
学习总结

前言

前置知识

代理范式

什么是代理模式？代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。
少年可曾听闻【代理范式】？它的伪代码一般如下：（Cglib动态代理采用的方案）

class 被代理类 {
	function 方法A();
}

class 代理类 <<继承>> 被代理类 {
	被代理类 targetObject;
	
	@Override
	function 方法A() {
		// 这里写被加强的逻辑
		targetObject.方法A();
		// 也可以在这里写
	}
}

或者用java代码表示如下：

// 被代理对象
public class ProxyTarget {
    public void run() {
        System.out.println("这是普通对象的run");
    }
}


// 代理对象
public class ProxyModel extends ProxyTarget {
    private ProxyTarget proxyTarget;

    public void setProxyTarget(ProxyTarget proxyTarget) {
        this.proxyTarget = proxyTarget;
    }

    @Override
    public void run() {
        System.out.println("我代理对象可以在这里做加强---1");
        super.run();
        System.out.println("我代理对象也可以在这里做加强---2");
    }
}

但是，代理模式的实现其实还有一种，但前提是被代理的类存在接口。它的代理范式伪代码如下：（JDK动态代理采用的方案）

class 被代理类 <<实现>> 接口A {
	function 实现自接口A的方法();
}

class 代理类 <<实现>> 接口A {
	被代理类 targetObject;
	
	@Override
	function 实现自接口A的方法() {
		// 这里写被加强的逻辑
		targetObject.方法A();
		// 也可以在这里写
	}
}

上面介绍的两种代理方式算是一个小细节。在后面提到的某个参数，会影响到代理方式的选择。

SpringAOP的理解

OOP表示面向对象编程，是一种编程思想，AOP表示面向切面编程，也是一种编程思想，而Spring为了让程序员更加方便的做到面向切面编程所提供的技术支持，于是提供了一套机制，可以让我们更加容易的来进行AOP，所以这套机制我们也可以称之为Spring AOP。

Spring动态代理的实现

我把它放到【课程内容】里面了，因为我怕大家不重视

课程内容

一、动态代理的实现

我相信有经验的朋友，应该都知道，我们Java里面通常使用的代理方式有两种，分别为：JDK动态代理，以及Cglib动态代理。下面就给大家简单演示一下，这两种动态代理的简单使用示例。
在言是两种代理之前，需要一个基础类。如下：

@Component
public class UserService {

    public void test() {
        System.out.println("这是UserService的一个普通方法");
    }
}

在开始代理之前，再次重申一下为什么需要代理？
代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。
就是，当我们需要增强某个方法的，又不想修改原有代码的时候（遵守设计原则里面的：开闭原则），一般就会考虑使用代理。在Spring里面就使用了下面两种方案来实现这个代理模式。

1.1 Cglib动态代理

在上面的UserService，如果我们new一个UserService对象，然后执行test()方法，结果是显而易见的。如果我们现在想在不修改UserService类的源码前提下，给test()增加额外逻辑，那么就可以使用Cglib动态代理机制来创建UserService对象了，比如：

 public static void main(String[] args) throws IOException {
        UserService target = new UserService();
        target.test();


        System.out.println("下面开始是cglib之后的逻辑了");

        // cglib
        {
            // 使用cglib增强类
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(UserService.class);

            // 定义额外的增强逻辑，增强对象
            enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    System.out.println("before...");
                    Object result = methodProxy.invoke(target, objects);
                    System.out.println("after...");
                    return result;
                }
            }});

            // 动态代理所创建出来的UserService对象
            UserService userService = (UserService) enhancer.create();

            // 执行这个userService的test方法时，就会额外会执行一些其他逻辑
            userService.test();
        }
    }

得到的都是UserService对象，但是执行test()方法时的效果却不一样了，这就是代理所带来的效果。
上面是通过cglib来实现的代理对象的创建，是基于父子类的，被代理类（UserService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由cglib创建的，对于程序员来说不用关心。

1.2 JDK动态代理

除开cglib技术，jdk本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象，比如：

public interface UserInterface {
    void test();
}

public class UserService implements UserInterface{

    @Override
    public void test() {
        System.out.println("这是UserService的一个普通方法");
    }
}

利用JDK动态代理来生成一个代理对象的示例如下：

 public static void main(String[] args) throws IOException {
        UserService target = new UserService();
        target.test();

        System.out.println("下面开始是cglib之后的逻辑了");

        // jdk代理
        {
            // UserInterface接口的代理对象
            Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {

                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("before...");
                    Object result = method.invoke(target, args);
                    System.out.println("after...");
                    return result;
                }
            });

            UserInterface userService = (UserInterface) proxy;
            userService.test();
        }
    }

如果你把new Class[]{UserInterface.class}，替换成new Class[]{UserService.class}，代码会直接报错：（这也证明了JDK采用的是第二种代理范式）

java.lang.IllegalArgumentException: UserService is not an interface

由于这个限制，所以产生的代理对象的类型是UserInterface，而不是UserService，这是需要注意的。

1.3 ProxyFactory：Spring对两种代理的封装

上面我们介绍了两种动态代理技术，那么在Spring中对它们进行了封装，封装出来的类叫做ProxyFactory，表示是创建代理对象的一个工厂，使用起来会比上面的更加方便，比如：

    public static void main(String[] args) throws IOException {
        UserService target = new UserService();

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvice(new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        });

        UserInterface userService = (UserInterface) proxyFactory.getProxy();
        userService.test();
    }

通过ProxyFactory，我们可以不再关心到底是用cglib还是jdk动态代理了，ProxyFactory会帮我们去判断，如果UserService实现了接口，那么ProxyFactory底层就会用jdk动态代理；如果没有实现接口，就会用cglib技术，上面的代码，就是由于UserService实现了UserInterface接口，所以最后产生的代理对象是UserInterface类型。

二、AOP基础知识

AOP基础概念回顾

SpringAOP大家都不陌生，但是在说AOP之前，我觉得再梳理一下其中的概念，对我们进一步研究有很大的帮助。而且，我相信，就算大家SpringAOP已经有过实际生产经验了，下面的一些概念也不一定懂。另外，有一些概念会出现在我们后面【发展历程】中，看似一字之差，但其实是两码事。

切面（AspectJ）：在Aop中切面指的就是【切面类】。切面类中管理着增强的公共行为代码【即：通知】和切入方式【即：切点】
通知（Advice）：在切面的某个特定的连接点上执行的【动作】。通知有多种类型，包括【around】、【before】和【after】等等。许多AOP框架，包括Spring在内，都是以【拦截器】做通知模型的，并维护着一个以连接点为中心的【拦截器链】
切点（PointCut）：匹配连接点的断言。【Advice通知】和【切点】表达式相关联，并在满足这个【切点】的【连接点】上运行(如，当执行某个特定名称的方法时)。切点表达式何和连接点匹配是AOP的核心:。Spring默认使用AspectJ切点语义
连接点（JoinPoint）：在Spring AOP中，一个连接点总是代表一个方法的执行，其实就代表被增强的【方法】
目标对象（Target）：目标对象指将要被增强的对象。即包含主业务逻辑的类的对象
顾问（Advisor）：顾问是Advice的一种包装体现。Advisor是Pointcut以及Advice的一个结合，用来管理Advice和Pointcut，应用无需关心（但是研究源码需要知道）
织入（Weaving）：将通知切入连接点的过程叫做织入
引入（Introductions）：可以将其他接口和实现动态引入到targetClass中

（PS：特别声明一下，根据我的经验，好多人会把【通知Advice】跟【顾问Advisor】给混淆，毕竟这俩的英文太像了）
（PS：特别声明一下，根据我的经验，好多人会把【通知Advice】跟【顾问Advisor】给混淆，毕竟这俩的英文太像了）
（PS：特别声明一下，根据我的经验，好多人会把【通知Advice】跟【顾问Advisor】给混淆，毕竟这俩的英文太像了。特别是在读源码的过程中，一下子就蒙查查了。为了让大家对这两个概念有个清晰的认知，这里单独讲一下这两个东西。）。

通知Advice的分类

相信大家看了上面的概念之后，油然升起一种熟悉的感觉，没错，他就是我们平时用的那些注解嘛。通常，它包含以下这些分类：

Before Advice：方法之前执行。对应SpringAOP的@Before注解。另外也有对应的API接口：MethodBeforeAdvice继承了接口BeforeAdvice
After returning advice：方法return后执行。对应SpringAOP的@AfterReturning注解。另外也有对应的API接口：AfterReturningAdvice
After throwing advice：方法抛异常后执行。对应SpringAOP的@AfterThrowing注解。另外也有对应的API接口：ThrowsAdvice
After (finally) advice：方法执行完finally之后执行，这是最后的，比return更后。对应SpringAOP的@After注解。另外也有对应的API接口：AfterAdvice
Around advice：这是功能最强大的Advice，可以自定义执行顺序。对应SpringAOP的@Around注解。另外也有对应的API接口：MethodInterceptor

Spring会把五个注解解析为对应的Advice类：

@Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
@AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
@AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
@After：AspectJAfterAdvice，实际上就是一个MethodInterceptor
@Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor

Advisor的理解

跟Advice类似的还有一个Advisor的概念，一个Advisor是有一个Pointcut和一个Advice组成的，通过Pointcut可以指定要需要被代理的逻辑。它的模型图，大概如下：
在这里插入图片描述
比如一个UserService类中有两个方法，按上面的例子，这两个方法都会被代理，被增强，那么我们现在可以通过Advisor，来控制到具体代理哪一个方法，比如：

	public static void main(String[] args) {
        PointcutAdvisor pointcutAdvisor = new PointcutAdvisor() {

            @Override
            public Pointcut getPointcut() {
                return new StaticMethodMatcherPointcut() {
                    @Override
                    public boolean matches(Method method, Class<?> targetClass) {
                        return method.getName().equals("test");
                    }
                };
            }

            @Override
            public Advice getAdvice() {
                return new MethodInterceptor() {
                    @Override
                    public Object invoke(MethodInvocation invocation) throws Throwable {
                        System.out.println("before...");
                        Object result = invocation.proceed();
                        System.out.println("after...");
                        return result;
                    }
                };
            }

            @Override
            public boolean isPerInstance() {
                return false;
            }
        };

        // 注入advisor
        UserService target = new UserService();
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(target);
        proxyFactory.addAdvisor(pointcutAdvisor);
        UserInterface userService = (UserInterface) proxyFactory.getProxy();
        userService.test();
    }

    // 系统输出如下：
    // before...
    // 这是UserService的一个普通方法
    // after...

上面代码表示，产生的代理对象，只有在执行test这个方法时才会被增强，会执行额外的逻辑，而在执行其他方法时是不会增强的。

三、创建代理对象的方式

上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的创建，但是我们在使用Spring时，我们并不会直接这么去使用ProxyFactory的。比如说，我们希望ProxyFactory所产生的代理对象能直接就是Bean，能直接从Spring容器中得到UserSerivce的代理对象，而这些，Spring都是支持的，只不过，作为开发者的我们肯定得告诉Spring，那些类需要被代理，代理逻辑是什么。

3.1 ProxyFactoryBean：SpringAOP早期实现版本

在Spring早期，要想实现AOP，比如创建一个UserService的代理bean，需要这么做：

    @Bean
    public ProxyFactoryBean userServiceProxy() {
        UserService userService = new UserService();

        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        proxyFactoryBean.setTarget(userService);
        proxyFactoryBean.addAdvice(new MethodInterceptor() {

            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...1111");
                Object result = invocation.proceed();
                System.out.println("after...1111");
                return result;
            }
        });
        return proxyFactoryBean;
    }

由上代码可以发现，早期实现AOP，你需要做这些事情：

强绑定一个被代理对象，如上：userService
新增一个通知。如上是一个匿名实现类new MethodInterceptor。MethodInterceptor是Advice接口的一个子接口
使用FactoryBean来获取代理对象

通过这种方法来定义一个UserService的Bean，并且是经过了AOP的。但显然，这种方式只能针对某一个Bean，并且只能控制到类级别，类中所有方法都被拦截了，意味着，如果我们想要切入更多的Bean，需要给每一个Bean都创建一个对应的FactoryBean。这是我们无法接受的。
ProxyFactoryBean还有额外的功能，比如可以把某个Advise或Advisor定义成为Bean，然后在ProxyFactoryBean中进行设置：

	@Bean
    public MethodInterceptor zhouyuAroundAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        };
    }

    @Bean
    public ProxyFactoryBean userService() {
        UserService userService = new UserService();

        ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
        proxyFactoryBean.setTarget(userService);
        proxyFactoryBean.setInterceptorNames("zhouyuAroundAdvise");
        return proxyFactoryBean;
    }

3.2 NameMatchMethodPointcutAdvisor：引入Advisor概念，改进拦截所有方法的问题

还记得我在前面说的Advisor是什么吗？Advisor是【Pointcut+Advice】的组合体。整体来说比较简单，在初始化的时候，它内部需要指定一个Advice，然后Advisor根据Pointcut决定该拦截哪些方法，拦截后需要完成的工作还是内部的Advice来做。

PS：有AOP经验的同学应该知道Pointcut其实粒度是在方法级别的吧…

NameMatchMethodPointcutAdvisor它是Advisor的一个子类，通过类名不难看出，它是根据方法名字匹配切入点的。当然还有好几种不同的子类，这里只是简单使用这个来演示一下。

@Bean
public MethodInterceptor zhouyuAroundAdvice() {
    return new MethodInterceptor() {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            System.out.println("before...");
            Object result = invocation.proceed();
            System.out.println("after...");
            return result;
        }
    };
}
	
@Bean
public NameMatchMethodPointcutAdvisor nameMethodAdvisor() {
    NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();

    // 通知(Advice)  ：是我们的通知类
    // 通知者(Advisor)：是经过包装后的细粒度控制方式。
    advisor.setAdvice(zhouyuAroundAdvice());
    advisor.setMappedNames("test");
    return  advisor;
}

/**
 * FactoryBean方式单个： ProxyFactoryBean
 *  控制粒度到方法
 * @return
 */
@Bean
public ProxyFactoryBean calculateProxy(){
	
	UserService userService = new UserService();
    ProxyFactoryBean userService=new ProxyFactoryBean();
    userService.setInterceptorNames("nameMethodAdvisor");   
    userService.setTarget(userService);
    return userService;
}

我们可以看到，tulingLogAspect这个 bean 配置了一个 advisor，advisor 内部有一个 advice。advisor 负责匹配方法，内部的 advice 负责实现方法包装。
注意，这里的 mappedNames 配置是可以指定多个的，用逗号分隔，可以是不同类中的方法。相比直接指定 advice，advisor 实现了更细粒度的控制，因为在这里配置 advice 的话，所有方法都会被拦截。

3.3 BeanNameAutoProxyCreator：改进只能切一个Bean的问题

为了改进上述AOP【类粒度】太小的问题，出现了一个叫做AutoProxy的接口方案。通过名字大家可以看出来，他是一个自动代理方案。我们这里使用一个它的实现类BeanNameAutoProxyCreator，给大家简单的演示一下。
ProxyFactoryBean得自己指定被代理的对象，那么我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字，来对该bean进行代理。

    @Bean
    public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
        BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
        beanNameAutoProxyCreator.setBeanNames("userSe*");
        beanNameAutoProxyCreator.setInterceptorNames("zhouyuAroundAdvice");
        beanNameAutoProxyCreator.setProxyTargetClass(true);
        return beanNameAutoProxyCreator;
    }

由上代码可以发现，使用AutoProxy实现AOP，你需要做这些事情：

指定被切对象的规则。这里是使用模糊匹配bean名字userSe*
跟上面一样，新增一个通知。这里是zhouyuAroundAdvice
不同于上面需要使用FactoryBean获取代理对象，这里既然说了是自动代理，那么在我们根据beanName获取bean的时候，若被检测到需要被代理，则会自动为其生成代理对象

显然，通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP，并且指定了代理逻辑，指定了一个InterceptorName，也就是一个Advice，前提条件是这个Advice也得是一个Bean，这样Spring才能找到的，但是BeanNameAutoProxyCreator的还是不够完善吗，它只能根据beanName来指定想要代理的Bean

3.4 DefaultAdvisorAutoProxyCreator：更强大的AutoProxy方案

到了这里，算是一个比较成熟的解决方案了。

   @Bean
    public DefaultPointcutAdvisor defaultPointcutAdvisor() {
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.addMethodName("test");

        DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
        defaultPointcutAdvisor.setPointcut(pointcut);
        defaultPointcutAdvisor.setAdvice(new ZhouyuAfterReturningAdvice());

        return defaultPointcutAdvisor;
    }

    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        return defaultAdvisorAutoProxyCreator;
    }

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，根据Advisor中的PointCut和Advice信息，确定要代理的Bean以及代理逻辑。不知道大家有没有感觉，这种方式已经非常接近我们当前使用的注解方式了。没错，可以提前告诉大家的是，在注解方式的AOP实现方案中，无非就是把所有切面类找出来，然后解析【切点Pointcut】与【通知Advice】，封装成一个个【顾问Advisor】，再经过一系列代理流程，创建出代理对象。

最后再贴上一个我们在项目中经常用的AOP示例：

@Aspect
@Component
public class MyAspect {

    @Pointcut("execution(* org.tuling.spring.aop..*(..))")
    public void pointCut() {

    }

    @Before("pointCut()")
    public void before() {
        System.out.println("方法执行之前，记录一下入口时间。" + System.currentTimeMillis());
    }

    @AfterReturning("pointCut()")
    public void afrer() {
        System.out.println("方法执行之后，记录一下出口时间。" + System.currentTimeMillis());
    }
}

通过上面这个类，我们就直接定义好了所要代理的方法(通过一个表达式)，以及代理逻辑（被@Before修饰的方法），简单明了，这样对于Spring来说，它要做的就是来解析这些注解了，解析之后得到对应的Pointcut对象、Advice对象，生成Advisor对象，扔进ProxyFactory中，进而产生对应的代理对象，具体怎么解析这些注解就是@EnableAspectJAutoProxy注解所要做的事情了，后面详细分析。

四、AOP注解方案底层源码解析

我们知道，Spring通过一个切面类，在他的类上加入@Aspect注解，定义一个Pointcut方法，最后定义一系列的增强方法Advice。这样就完成一个对象的切面操作。那么如果你是Spring作者，大伙思考一下，按照上述的基础，你觉得需要什么步骤呢？我的总结是如下：

找到所有的切面bean，即类上有@Aspect注解的bean
解析所有的advice，即：@Before、@After、@AfterReturning、@AfterThrowing、@Around这5个注解，将它们与作用的Pointcut封装起来，包装成一个个Advisor，然后保存起来
创建一个动态代理类
调用被代理类的方法时，找到他的所有增强器，并增强当前的方法

那下面，我们就尝试去研究下源码，看看是不是跟我们推理的一样。

4.1 从 @EnableAspectJAutoProxy讲起

现在都进入Springboot时代了，也许不少同学不知道，或者忘记了，我们想要引入SpringAOP的时候，会用到这个注解。那这个注解有什么用呢？我们点开看下源码，如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	/**
	 * 指示是否要创建基于子类(CGLIB)的代理，而不是基于标准Java接口的代理。默认为false。
	 */
	boolean proxyTargetClass() default false;

	/**
	 * 表明代理应该由AOP框架作为ThreadLocal公开，
	 * 以便通过org.springframework.aop.framework.AopContext类进行检索。
	 * 默认为关闭，即不保证AopContext访问将工作。
	 */
	boolean exposeProxy() default false;
}

从上面的源码我们可以发现，在注解类上面使用了@Import(AspectJAutoProxyRegistrar.class)，这个是什么意思呢？如下：

PS：关于@Import注解，如下：

如上所述，其实就是向我们的bean工厂中注册一个beanDefinition而已，我们点进去，看看这个类到底有啥作用。源码如下：

类全路径：org.springframework.context.annotation.AspectJAutoProxyRegistrar
类注释：根据给定的@EnableAspectJAutoProxy注释，在当前BeanDefinitionRegistry中注册一个AnnotationAwareAspectJAutoProxyCreator。

/**
* 根据给定的@EnableAspectJAutoProxy注释
* 在当前BeanDefinitionRegistry中注册一个AnnotationAwareAspectJAutoProxyCreator。
*/
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * 根据导入的@Configuration类上的@EnableAspectJAutoProxy.proxyTargetClass()
	 * 属性的值注册、升级和配置AspectJ自动代理创建器。
	 */
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

说实在，到了这里，我们基本上可以搞清楚了，SpringAOP最核心的类之一，就是上面注释提到的AnnotationAwareAspectJAutoProxyCreator类。至于方法里面的proxyTargetClass跟exposeProxy咱就不多说了，你用到的时候自己知道啥意思。他也不是我们核心研究对象。

简单提一嘴：
proxyTargetClass：是@EnableAspectJAutoProxy 注解的属性。指示是否要创建基于子类(CGLIB)的代理，而不是基于标准Java接口的JDK代理。默认为false。（我们上面提到过，Spring创建代理选择代理模式的大概流程。而这个参数的意思是，设置为true，则默认创建CGLIB代理，不会再去考虑JDK代理了。）
exposeProxy：是@EnableAspectJAutoProxy 注解的属性。表明代理应该由AOP框架作为ThreadLocal公开，以便通过org.springframework.aop.framework.AopContext类进行检索。默认为关闭，即不保证AopContext访问将工作。

4.2 AnnotationAwareAspectJAutoProxyCreator：简单介绍

这里我们就简单看一下这个类的继承图即类注释，以便我们对他有个基本的认识。先看类注释：

/**
 * AspectJAwareAdvisorAutoProxyCreator子类，它处理当前应用程序上下文中的所有AspectJ注释方面，以及Spring Advisors。
 * 任何AspectJ注释的类都会被自动识别，如果Spring AOP的基于代理的模型能够应用它们，那么它们的建议就会被应用。这涵盖了方法执行连接点。
 * 如果使用了<aop:include>元素，那么只有名称与include模式匹配的@AspectJ bean才会被认为是定义了用于Spring自动代理的方面。
 * Spring advisor的处理遵循org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator中建立的规则。
 */
public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {
}

从上面的接口注释我们可以看到几个关键的字眼：它处理当前应用程序上下文中的所有AspectJ注释方面，以及Spring Advisors。任何AspectJ注释的类都会被自动识别。哦豁，这不就是我一开始说的【大概步骤】里面的前两步嘛。再来看看继承图：
在这里插入图片描述
看看是不是有很多送曾相识的接口呢，比如：BeanPostProcessor及它2个子接口。
另外，我们前面也说过，AOP的实现就是在【初始化后】这个阶段。下面，我们就真正开始解剖AOP实现源码。

4.3 概念回顾

BeanPostProcessor：既然是【初始化】后完成的，那么SpringAOP的实现肯定离不开这个接口。不过，我们在实现的时候，用的是他其中一个实现类，AnnotationAwareAspectJAutoProxyCreator。然后，这个类的大部分实现都在AbstractAutoProxyCreator中。

4.4 方法详解

本次源码分析入口如下：

全路径：org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization
方法解释：执行BeanPostProcessor初始化后方法

	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}