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,對切點進行攔截加強處理。

 

原文出處：https://www.cnblogs.com/little-sheep/p/10103797.html