Spring源码分析笔记--AOP

核心类&方法

BeanDefinition

Bean的定义信息，封装bean的基本信息，从中可以获取类名、是否是单例、是否被注入到其他bean中、是否懒加载、bean依赖的bean的名称等。

Aware

继承Aware的bean可以感知到他在容器中的一些属性，如获取bean在容器中的ID，甚至获取到容器等。

BeanPostProcessor

Bean的后置处理器，可在bean的创建、初始化等阶段的前后对bean进行增强处理等。

BeanFactory

以Factory结尾，表示它是一个工厂类(接口)，用于管理Bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

是访问容器的顶层接口，他的实现类中会有一个MAP，用于存储bean的BeanDefinition。

(与FactoryBean区别：实现FactoryBean接口也是在容器中注入bean的方式之一，但它不是一个普通的bean，而是生成指定bean的一个工厂)

AbstractAutowireCapableBeanFactory：： populateBean（..）

DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory

此方法用于给bean注入依赖的其他bean

BeanWrapper

将交于容器管理的bean装饰，屏蔽多样性，统一的set、get方法，方便统一操作

核心流程源码

AnnotationAwareAspectJAutoProxyCreator创建过程

AOP核心类：AnnotationAwareAspectJAutoProxyCreator，本质是一种BeanPostProcessor

容器启动时：

==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...)
　　register(annotatedClasses);//加载、注册配置类；配置类也是一个被容器管理的bean
　　refresh();//刷新容器，注册、创建相关bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh
  　// Register bean processors that intercept bean creation.
　　registerBeanPostProcessors(beanFactory);//注册容器需要的核心BeanPostProcessor
　　// Instantiate all remaining (non-lazy-init) singletons.
　　finishBeanFactoryInitialization(beanFactory);//创建并初始化其他非懒加载的bean，主要是业务类bean
==》 org.springframework.context.support.AbstractApplicationContext#registerBeanPostProcessors
==》 org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, org.springframework.context.support.AbstractApplicationContext)
　　// Separate between BeanPostProcessors that implement PriorityOrdered, Ordered, and the rest.
　　//根据继承的order等级，顺序创建BeanPostProcessor
　　//AnnotationAwareAspectJAutoProxyCreator实现了Order
　　//创建
　　BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
　　//添加到容器-FactoryBean中
　　org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanPostProcessor>)
==》 org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String, java.lang.Class<T>)
==》 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean//BeanPostProcessor和业务Bean都用此创建bean
　　//创建bean
　　return createBean(beanName, mbd, args);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
　　// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
　　//有一次通过代理直接返回对象的机会，但一般都不会走到此方法中
　　Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
　　//创建过程
　　Object beanInstance = doCreateBean(beanName, mbdToUse, args);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
　　//创建Bean，通过Wrapper装饰
　　if (instanceWrapper == null) {
　　　　instanceWrapper = createBeanInstance(beanName, mbd, args);
　　}
　　// Initialize the bean instance.
　　//填充bean后初始化bean
　　Object exposedObject = bean;
　　try {
    　　populateBean(beanName, mbd, instanceWrapper);
    　　if (exposedObject != null) {
        　　exposedObject = initializeBean(beanName, exposedObject, mbd);
    　　}
　　}
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
　　//初始化bean
　　//检查实现了哪些aware，并注入相应的值
　　invokeAwareMethods(beanName, bean);
　　//BeanPostProcessor初始化前置处理
　　wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
　　//调用bean的初始方法
　　invokeInitMethods(beanName, wrappedBean, mbd);
　　//BeanPostProcessor初始化后置处理
　　wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
　　//此类做Bean初始化的后置处理，若bean有advice则创建proxy bean，此bean无。

业务Bean（proxy）创建过程

容器启动时：

==》 org.springframework.context.annotation.AnnotationConfigApplicationContext#AnnotationConfigApplicationContext(java.lang.Class<?>...)
　　register(annotatedClasses);//加载、注册配置类；配置类也是一个被容器管理的bean
　　refresh();//刷新容器，注册、创建相关bean
==》 org.springframework.context.support.AbstractApplicationContext#refresh
  　// Register bean processors that intercept bean creation.
　　registerBeanPostProcessors(beanFactory);//注册容器需要的核心BeanPostProcessor
　　// Instantiate all remaining (non-lazy-init) singletons.
　　finishBeanFactoryInitialization(beanFactory);//创建并初始化其他非懒加载的bean，主要是业务类bean
==》  org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization
　　// Instantiate all remaining (non-lazy-init) singletons.
　　beanFactory.preInstantiateSingletons();
==》  org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
　　//getBean(beanName);
==》  org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
==》  org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
　　return createBean(beanName, mbd, args);
==》  org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
　　Object beanInstance = doCreateBean(beanName, mbdToUse, args);
　　//创建Bean，通过Wrapper装饰
　　if (instanceWrapper == null) {
　　　　instanceWrapper = createBeanInstance(beanName, mbd, args);
　　}
　　// Initialize the bean instance.
　　//填充bean后初始化bean
　　Object exposedObject = bean;
　　try {
    　　populateBean(beanName, mbd, instanceWrapper);
    　　if (exposedObject != null) {
        　　exposedObject = initializeBean(beanName, exposedObject, mbd);
    　　}
　　}
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
　　//初始化bean
　　//检查实现了哪些aware，并注入相应的值
　　invokeAwareMethods(beanName, bean);
　　//BeanPostProcessor初始化前置处理
　　wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
　　//调用bean的初始方法
　　invokeInitMethods(beanName, wrappedBean, mbd);
　　//BeanPostProcessor初始化后置处理
　　wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
==》 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
　　//此类做Bean初始化的后置处理，若bean有advice则创建proxy bean
　　//遍历bean的后置处理器，并做后置处理
　　//当后置处理器时AnnotationAwareAspectJAutoProxyCreator时进入方法，判断是否需要做代理
　　for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
    　　result = beanProcessor.postProcessAfterInitialization(result, beanName);
    　　if (result == null) {
        　　return result;
    　　}
　　}
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
　　// Create proxy if we have advice.
　　Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
　　if (specificInterceptors != DO_NOT_PROXY) {
    　　this.advisedBeans.put(cacheKey, Boolean.TRUE);
    　　Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
    　　this.proxyTypes.put(cacheKey, proxy.getClass());
    　　return proxy;
　　}
==》 org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy
　　//bean需要被aop做代理进行增强时进入此方法
　　//取得bean对应的advisors，advisors会被封装成链式Interceptors（责任链模式）供后期增强使用
　　Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
　　//使用代理工厂创建代理
　　return proxyFactory.getProxy(getProxyClassLoader());
==》 org.springframework.aop.framework.ProxyFactory#getProxy(java.lang.ClassLoader)
　　return createAopProxy().getProxy(classLoader);
==》 org.springframework.aop.framework.ProxyCreatorSupport#createAopProxy
　　return getAopProxyFactory().createAopProxy(this);
==》 org.springframework.aop.framework.DefaultAopProxyFactory#createAopProxy
　　//如果继承自接口使用JDK动态代理
　　if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    　　return new JdkDynamicAopProxy(config);
　　}
　　//否则使用CGLib动态代理
　　return new ObjenesisCglibAopProxy(config);

Bean的创建梳理

包括工具Bean、业务Bean

1、bean在缓存中（Map）是否存在，存在则直接返回，不存在进入创建流程

2、创建BeanPostProcessor后置处理器

是否实现Aware，实现则注入对应容器信息

3、创建自身bean

创建àpopulateBeanàInvoke InitMethod(若有advice此时创建proxy)

AOP advice过程

在业务方法中加断点，调试进入

==》 org.springframework.aop.framework.JdkDynamicAopProxy#invoke
　　//当被代理类实现了接口时使用jdk动态代理
　　// Get the interception chain for this method.
　　//获取通知封装成的链
    List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
　　// We need to create a method invocation...
　　invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
　　// Proceed to the joinpoint through the interceptor chain.
　　//容器在封装advisors成Interceptors时会进行排序，此顺序和实际执行顺序相反，因为Interceptors会以责任链的形式调用，因此实际执行时顺序是正常的
　　retVal = invocation.proceed();

AOP 方法增强梳理

1、创建AOP核心类：AnnotationAwareAspectJAutoProxyCreator

2、在注入时，CreateBean时，检查是否有Advice，如果有则创建bean的代理。

注意：代理类对象（proxy）会加入容器，但Context::BeanFactory::BeanDefinition中的定义信息仍是被代理类的，所以取到的name也是被代理类的。

代理类会在被代理类调用populateBean 、InitMethod后创建，

3、被增强的方法在调用时，会调用代理类的方法，方法中获取相应通知做增强处理。这些通知会被封装成MethodInterceptor,对切点进行拦截增强处理。