0.AOP整体流程

1）@EnableAspectJAutoProxy 开启AOP功能
2）@EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3）AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
4）容器的创建流程：
4-1）registerBeanPostProcessors创建后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
4-2）finishBeanFactoryInitialization初始化剩下的单实例bean
4-2-1）创建业务逻辑组件和切面组件
4-2-2）AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
4-2-3）组件创建完之后，判断组件是否需要增强：如果需要，则结合切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
5）执行目标方法：
5-1）代理对象执行目标方法
5-2）CglibAopProxy.intercept()；
5-2-1）得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
5-2-2）利用拦截器的链式机制，依次进入每一个拦截器进行执行；
5-2-3）效果：
正常执行：前置通知->目标方法->后置通知->返回通知
出现异常：前置通知->目标方法->后置通知->异常通知

1.@EnableAspectJAutoProxy的分析（注册（非创建）AnnotationAwareAspectJAutoProxyCreator的流程）

1.1 EnableAspectJAutoProxy

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    //proxyTargetClass属性，默认false，采用JDK动态代理织入增强(实现接口的方式)；如果设为true，则采用CGLIB动态代理织入增强
    boolean proxyTargetClass() default false;
    //通过aop框架暴露该代理对象，aopContext能够访问
    boolean exposeProxy() default false;
}

1.2 AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar

前面也实现过ImportBeanDefinitionRegistrar接口，参考Spring组件添加（注册组件）
实现接口ImportBeanDefinitionRegistrar注册组件

public class JamesImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    /*
     *AnnotationMetadata:当前类的注解信息
     *BeanDefinitionRegistry:BeanDefinition注册类
     *    把所有需要添加到容器中的bean加入;
     *    @Scope
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean bean1 = registry.containsBeanDefinition("com.wangzhen.ch6.bean.Dog");
        boolean bean2 = registry.containsBeanDefinition("com.wangzhen.ch6.bean.Cat");
        //如果Dog和Cat同时存在于我们IOC容器中,那么创建Pig类, 加入到容器
        //对于我们要注册的bean, 给bean进行封装,
        if(bean1 && bean2){
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Pig.class);
            registry.registerBeanDefinition("pig", beanDefinition);
        }
    }
}

AspectJAutoProxyRegistrar给我们容器中注册一个名称为internalAutoProxyCreator的AnnotationAwareAspectJAutoProxyCreator组件。

注册AnnotationAwareAspectJAutoProxyCreator组件方式与JamesImportBeanDefinitionRegistrar相同：

1.3 AnnotationAwareAspectJAutoProxyCreator

SmartInstantiationAwareBeanPostProcessor: bean的后置处理器
BeanFactoryAware 能把beanFacotry bean工厂传进来
通过分析以上的bean继承关系我们发现，AnnotationAwareAspectJAutoProxyCreator具有BeanPostProcessor特点，也有Aware接口的特点，实现了BeanFactoryAware 接口。

关键：分析AnnotationAwareAspectJAutoProxyCreator作为beanPostProcessor后置处理器做了哪些工作，作为BeanFactoryAware又做了哪些工作？

2.创建（后置处理器）AnnotationAwareAspectJAutoProxyCreator的流程

1）register()传入配置类，准备创建ioc容器
2）注册配置类，调用refresh（）刷新创建容器；
3）registerBeanPostProcessors(beanFactory);注册bean的后置处理器来方便拦截bean的创建(主要是分析创建AnnotationAwareAspectJAutoProxyCreator)；
3-1）先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor
3-2）给容器中加别的BeanPostProcessor
3-3）优先注册实现了PriorityOrdered接口的BeanPostProcessor；
3-4）再给容器中注册实现了Ordered接口的BeanPostProcessor；
3-5）注册没实现优先级nonOrdered接口的BeanPostProcessor；
3-6）注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中；创建internalAutoProxyCreator的BeanPostProcessor【其实就是AnnotationAwareAspectJAutoProxyCreator】
3-6-1）创建Bean的实例
3-6-2）populateBean；给bean的各种属性赋值
3-6-3）initializeBean：初始化bean；
3-6-3-1）invokeAwareMethods()：处理Aware接口的方法回调
3-6-3-2）applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization（）
3-6-3-3）invokeInitMethods()；执行自定义的初始化方法
3-6-3-4）applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization（）；
3-6-4）BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功；-->aspectJAdvisorsBuilder
3-7）把BeanPostProcessor注册到BeanFactory中：beanFactory.addBeanPostProcessor(postProcessor);

创建该BeanPostProcessor的流程与Spring IOC源码分析是一致的。

3.创建（业务类bean）增强的Calculator的流程

finishBeanFactoryInitialization(beanFactory)完成BeanFactory初始化工作，创建剩下的单实例bean：
1）遍历获取容器中所有的Bean，依次创建对象getBean(beanName);
getBean->doGetBean()->getSingleton()->
2）创建bean【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】
2-1）先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建；只要创建好的Bean都会被缓存起来
2-2）createBean（）;创建bean AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】
2-2-1）resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation,如果能返回代理对象就使用，如果不能就继续,后置处理器先尝试返回对象；

            bean = applyBeanPostProcessorsBeforeInstantiation（）：
            拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor;
            就执行postProcessBeforeInstantiation 
            if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }

2-2-2）doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和单实例bean创建流程一样；

3.1 AnnotationAwareAspectJAutoProxyCreator作为InstantiationAwareBeanPostProcessor后置处理器的作用

所有后置处理器如下：

3.1.1 AnnotationAwareAspectJAutoProxyCreator调用postProcessBeforeInstantiation

注意：这个是在resolveBeforeInstantiation(beanName, mbdToUse)中调用的。但是仍然返回的是null。

每一个bean创建之前，如果有hasInstantiationAwareBeanPostProcessors()，则调用相应的postProcessBeforeInstantiation()：
关心MathCalculator和LogAspect的创建
1）判断当前bean是否在advisedBeans中（保存了所有需要增强bean）
2）判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，或者是否是切面（@Aspect）
3）是否需要跳过
3-1）获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
3-2）永远返回false

调用栈如下：

3.1.2 AnnotationAwareAspectJAutoProxyCreator调用postProcessAfterInitialization

wrapIfNecessary(bean, beanName, cacheKey)包装：
1）获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
1-1）找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
1-2）获取到能在bean使用的增强器。
1-3）给增强器排序
2）保存当前bean在advisedBeans中；
3）如果当前bean需要增强，创建当前bean的代理对象；
2-1）获取所有增强器（通知方法）
2-2）保存到proxyFactory
2-3）创建代理对象：Spring自动决定
JdkDynamicAopProxy(config);jdk动态代理；
ObjenesisCglibAopProxy(config);cglib的动态代理；

4）给容器中返回当前组件使用cglib增强了的代理对象；
5）以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程。

1）获取当前bean的所有增强方法（通知方法）

调用栈

2）创建增强的代理对象

createAopProxy调用栈
getProxy调用栈

4.Calculator.div()方法执行切面拦截

容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象等等）。

1）CglibAopProxy.intercept();拦截目标方法的执行
2）根据ProxyFactory对象获取将要执行的目标方法拦截器链；
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
2-1）List<Object> interceptorList保存所有拦截器有5个：一个默认的ExposeInvocationInterceptor 和 4个增强器；
2-2）遍历所有的增强器，将其转为Interceptor；registry.getInterceptors(advisor);
2-3）将增强器转为List<MethodInterceptor>；
如果是MethodInterceptor，直接加入到集合中
如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
转换完成返回MethodInterceptor数组；
3）如果没有拦截器链，直接执行目标方法;拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
4）如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();
5）拦截器链的触发过程;
5-1）如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
5-2）链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
拦截器链的机制，保证通知方法与目标方法的执行顺序。