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

一、 bean在緩存中（Map）是否存在，存在則直接返回，不存在進入建立流程

二、 建立BeanPostProcessor後置處理器

是否實現Aware，實現則注入對應容器信息

三、 建立自身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,對切點進行攔截加強處理。