筆記-spring aop 原理學習2

阿新 • • 發佈：2018-12-07

InstantiationAwareBeanPostProcessor
AnnotationAwareAspectJAutoProxyCreator
https://blog.csdn.net/qq_27529917/article/details/78454912
/**

擴充套件原理：
BeanPostProcessor：bean後置處理器，bean建立物件初始化前後進行攔截工作的
1、BeanFactoryPostProcessor：beanFactory的後置處理器；

 在BeanFactory標準初始化之後呼叫，來定製和修改BeanFactory的內容；

 所有的bean定義已經儲存載入到beanFactory，但是bean的例項還未建立

BeanFactoryPostProcessor原理:
1)、ioc容器建立物件
2)、invokeBeanFactoryPostProcessors(beanFactory);

 如何找到所有的BeanFactoryPostProcessor並執行他們的方法；

     1）、直接在BeanFactory中找到所有型別是BeanFactoryPostProcessor的元件，並執行他們的方法

     2）、在初始化建立其他元件前面執行

2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor

```
 postProcessBeanDefinitionRegistry();
```

 在所有bean定義資訊將要被載入，bean例項還未建立的；

 優先於BeanFactoryPostProcessor執行；

 利用BeanDefinitionRegistryPostProcessor給容器中再額外新增一些元件；

原理：
```
 1）、ioc建立物件
```

 2）、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);

 3）、從容器中獲取到所有的BeanDefinitionRegistryPostProcessor元件。

     1、依次觸發所有的postProcessBeanDefinitionRegistry()方法

     2、再來觸發postProcessBeanFactory()方法BeanFactoryPostProcessor； 為什麼先執行postProcessBeanDefinitionRegistry()方法？兩方法打斷點，debug棧

 4）、再來從容器中找到BeanFactoryPostProcessor元件；然後依次觸發postProcessBeanFactory()方法

**/

＝＝＝＝＝IOC流程＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
Spring容器的refresh()【建立重新整理】;
1、prepareRefresh()重新整理前的預處理;
1）、initPropertySources()初始化一些屬性設定;子類自定義個性化的屬性設定方法；
2）、getEnvironment().validateRequiredProperties();檢驗屬性的合法等
3）、earlyApplicationEvents= new LinkedHashSet

3、prepareBeanFactory(beanFactory);BeanFactory的預準備工作（以上建立了beanFactory,現在對BeanFactory物件進行一些設定屬性）；
1）、設定BeanFactory的類載入器、支援表示式解析器...
2）、新增部分BeanPostProcessor【ApplicationContextAwareProcessor】
3）、設定忽略的自動裝配的介面EnvironmentAware、EmbeddedValueResolverAware、xxx；
4）、註冊可以解析的自動裝配；我們能直接在任何元件中自動注入：
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
5）、新增BeanPostProcessor【ApplicationListenerDetector】
6）、新增編譯時的AspectJ；
7）、給BeanFactory中註冊一些能用的元件；
environment【ConfigurableEnvironment】、
systemProperties【Map<String, Object>】、
systemEnvironment【Map<String, Object>】
4、postProcessBeanFactory(beanFactory);BeanFactory準備工作完成後進行的後置處理工作；
1）、子類通過重寫這個方法來在BeanFactory建立並預準備完成以後做進一步的設定
======================以上是BeanFactory的建立及預準備工作==================================

5、invokeBeanFactoryPostProcessors(beanFactory)，執行BeanFactoryPostProcessor的方法；【處理BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor】
BeanFactoryPostProcessor：BeanFactory的後置處理器。在BeanFactory標準初始化之後執行的；
兩個介面：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
先執行BeanDefinitionRegistryPostProcessor
1）、83行：獲取所有的BeanDefinitionRegistryPostProcessor；
2）、93行：看先執行實現了PriorityOrdered優先順序介面的BeanDefinitionRegistryPostProcessor，
postProcessor.postProcessBeanDefinitionRegistry(registry)
3）、106行：在執行實現了Ordered順序介面的BeanDefinitionRegistryPostProcessor，
postProcessor.postProcessBeanDefinitionRegistry(registry)
4）、128行：最後執行沒有實現任何優先順序或者是順序介面的BeanDefinitionRegistryPostProcessors，
postProcessor.postProcessBeanDefinitionRegistry(registry)
5）、129行：執行普通的PostProcessors的方法：
postProcessor.postProcessBeanDefinitionRegistry(registry)

    再執行BeanFactoryPostProcessor的方法
    1）、139行：獲取所有的BeanFactoryPostProcessor
    2）、164行：看先執行實現了PriorityOrdered優先順序介面的BeanFactoryPostProcessor、
        postProcessor.postProcessBeanFactory()
    3）、172行：在執行實現了Ordered順序介面的BeanFactoryPostProcessor；
        postProcessor.postProcessBeanFactory()
    4）、179行：最後執行沒有實現任何優先順序或者是順序介面的BeanFactoryPostProcessor；
        postProcessor.postProcessBeanFactory()

6、registerBeanPostProcessors(beanFactory)，註冊BeanPostProcessor（Bean的後置處理器）【處理BeanPostProcessor】
【 intercept bean creation】
不同介面型別的BeanPostProcessor；在Bean建立前後的執行時機是不一樣的
BeanPostProcessor、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】、

    1）、189行：獲取所有的 BeanPostProcessor;後置處理器都預設可以通過PriorityOrdered、Ordered介面來執行優先順序
    2）、204行：先註冊PriorityOrdered優先順序介面的BeanPostProcessor；
        其實就是把每一個BeanPostProcessor新增到BeanFactory中：
        beanFactory.addBeanPostProcessor(postProcessor);
    3）、224行：再註冊Ordered介面的，同上
    4）、236行：最後註冊沒有實現任何優先順序介面的，同上
    5）、最終註冊MergedBeanDefinitionPostProcessor，也是把beanpostProcessor新增到beanFactory中。
    6）、註冊一個ApplicationListenerDetector；來在Bean建立完成後檢查是否是ApplicationListener，如果是
        applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7、initMessageSource();初始化MessageSource元件（做國際化功能；訊息繫結，訊息解析）；
1）、718行：獲取BeanFactory
2）、719行：看容器中是否有id為messageSource的，型別是MessageSource的元件
如果有賦值給messageSource，如果沒有自己建立一個DelegatingMessageSource；
MessageSource：取出國際化配置檔案中的某個key的值；能按照區域資訊獲取；
3）、739行：把建立好的MessageSource註冊在容器中，以後獲取國際化配置檔案的值的時候，可以自動注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);以後可通過getMessage獲取

8、initApplicationEventMulticaster();初始化事件派發器；
1）、753行：獲取BeanFactory
2）、754行：從BeanFactory中獲取applicationEventMulticaster的ApplicationEventMulticaster；
3）、762行：如果上一步沒有配置；建立一個SimpleApplicationEventMulticaster
4）、763行：將建立的ApplicationEventMulticaster新增到BeanFactory中，以後其他元件直接自動注入

9、onRefresh();留給子容器（子類）
1、子類重寫這個方法，在容器重新整理的時候可以自定義邏輯；

10、registerListeners();給容器中將所有專案裡面的ApplicationListener註冊進來；
1、822行：從容器中拿到所有的ApplicationListener
2、824行：將每個監聽器新增到事件派發器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3、832行：派發之前步驟產生的事件；

11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的單例項bean；
1、867行：beanFactory.preInstantiateSingletons();初始化後剩下的單例項bean，跟進
1）、734行：獲取容器中的所有Bean，依次進行初始化和建立物件
2）、738行：獲取Bean的定義資訊；RootBeanDefinition
3）、739行：Bean不是抽象的，是單例項的，是懶載入；
1）、740行：判斷是否是FactoryBean；是否是實現FactoryBean介面的Bean；
2）、760行：不是工廠Bean。利用getBean(beanName);建立物件
0、199行：getBean(beanName)； ioc.getBean();
1、doGetBean(name, null, null, false);
2、246行： getSingleton(beanName)先獲取快取中儲存的單例項Bean《跟進去其實就是從MAP中拿》。如果能獲取到說明這個Bean之前被建立過（所有建立過的單例項Bean都會被快取起來）
從private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);獲取的
3、快取中獲取不到，開始Bean的建立物件流程；
4、287行：標記當前bean已經被建立（防止多執行緒同時建立，使用synchronized）
5、291行:獲取Bean的定義資訊；
6、295行：getDependsOn()，bean.xml裡建立person時，加depend-on="jeep,moon"是先把jeep和moon創建出來
【獲取當前Bean依賴的其他Bean;如果有按照getBean()把依賴的Bean先創建出來；】
7、啟動單例項Bean的建立流程；
1）、462行：createBean(beanName, mbd, args);
2）、490行：Object bean = resolveBeforeInstantiation(beanName, mbdToUse);讓BeanPostProcessor先攔截返回代理物件；
【InstantiationAwareBeanPostProcessor】：提前執行；
先觸發：postProcessBeforeInstantiation()；
如果有返回值：觸發postProcessAfterInitialization()；
3）、如果前面的InstantiationAwareBeanPostProcessor沒有返回代理物件；呼叫4）
4）、501行：Object beanInstance = doCreateBean(beanName, mbdToUse, args);建立Bean
1）、541行：【建立Bean例項】；createBeanInstance(beanName, mbd, args);
利用工廠方法或者物件的構造器創建出Bean例項；
2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
呼叫MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
3）、578行：【Bean屬性賦值】populateBean(beanName, mbd, instanceWrapper);
賦值之前：
1）、拿到InstantiationAwareBeanPostProcessor後置處理器；
1305行：postProcessAfterInstantiation()；
2）、拿到InstantiationAwareBeanPostProcessor後置處理器；
1348行：postProcessPropertyValues()；
=====賦值之前：===
3）、應用Bean屬性的值；為屬性利用setter方法等進行賦值；
applyPropertyValues(beanName, mbd, bw, pvs);
4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
1）、1693行：【執行Aware介面方法】invokeAwareMethods(beanName, bean);執行xxxAware介面的方法
BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
2）、1698行：【執行後置處理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization（）;
3）、1702行：【執行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
1）、是否是InitializingBean介面的實現；執行介面規定的初始化；
2）、是否自定義初始化方法；
4）、1710行：【執行後置處理器初始化之後】applyBeanPostProcessorsAfterInitialization
BeanPostProcessor.postProcessAfterInitialization()；

                5）、將建立的Bean新增到快取中singletonObjects；sharedInstance = getSingleton(beanName, ()跟進去
                     254行：addSingleton（），放到MAP中
            ioc容器就是這些Map；很多的Map裡面儲存了單例項Bean，環境資訊。。。。；
    所有Bean都利用getBean建立完成以後；
        檢查所有的Bean是否是SmartInitializingSingleton介面的；如果是；就執行afterSingletonsInstantiated()；

12、finishRefresh();完成BeanFactory的初始化建立工作；IOC容器就建立完成；
1）、882行：initLifecycleProcessor();初始化和生命週期有關的後置處理器；LifecycleProcessor
預設從容器中找是否有lifecycleProcessor的元件【LifecycleProcessor】；如果沒有new DefaultLifecycleProcessor();
加入到容器；

        自己也可以嘗試寫一個LifecycleProcessor的實現類，可以在BeanFactory
            void onRefresh();
            void onClose(); 
    2）、 885行：getLifecycleProcessor().onRefresh();
        拿到前面定義的生命週期處理器（BeanFactory）；回撥onRefresh()；
    3）、888行：publishEvent(new ContextRefreshedEvent(this));釋出容器重新整理完成事件；
    4）、891行：liveBeansView.registerApplicationContext(this);

======總結===========
1）、Spring容器在啟動的時候，先會儲存所有註冊進來的Bean的定義資訊；
    1）、xml註冊bean；<bean>
    2）、註解註冊Bean；@Service、@Component、@Bean、xxx
2）、Spring容器會合適的時機建立這些Bean
    1）、用到這個bean的時候；利用getBean建立bean；建立好以後儲存在容器中；
    2）、統一建立剩下所有的bean的時候；finishBeanFactoryInitialization()；
3）、後置處理器；BeanPostProcessor
    1）、每一個bean建立完成，都會使用各種後置處理器進行處理；來增強bean的功能；
        AutowiredAnnotationBeanPostProcessor:處理自動注入
        AnnotationAwareAspectJAutoProxyCreator:來做AOP功能；
        xxx....
        增強的功能註解：
        AsyncAnnotationBeanPostProcessor
        ....
4）、事件驅動模型；
    ApplicationListener；事件監聽；
    ApplicationEventMulticaster；事件派發：

筆記-spring aop 原理學習2

筆記-spring aop 原理學習2

spring aop 原理學習

spring security原理-學習筆記2-核心元件

Spring原理學習系列之三：Spring AOP原理(從原始碼層面分析)-------上部

spring security原理-學習筆記1-整體概覽

spring-AOP原理與應用

面試必問的Spring AOP原理、SpringMVC過程

面試問爛的 Spring AOP 原理、SpringMVC 過程

二、Spring AOP原理

（京東面試題）java動態代理主要怎麼實現的，spring aop 原理如下類

Spring AOP 原理原始碼深度剖析

spring aop原理和實現

關於Spring AOP 原理解析和舉例！

Spring Security原理學習--許可權校驗(四)

三大框架之Spring （初級學習 2）

Spring Security原理學習--簡介與示例（一）

Java AOP & Spring AOP 原理和實現

Spring Security原理學習--核心過濾器Filter(二)

SpringBoot2 | Spring AOP 原理原始碼深度剖析（八）

spring aop原理 JDK動態代理和CGLIB動態代理

筆記-spring aop 原理學習2

相關推薦