文章概要
- 起因和概述
- 常用注解解析
- 控制反轉(zhuǎn)IOC，容器的作用
- 依賴注入DI，獲取對象的作用
- 面象切面AOP
- 聲明式事務(wù)Tx
- 擴展原理
- 源碼分析，分析為什么有這些注解
- web開發(fā) servlet3.0和SpringMvc注解
起因
從來沒學過spring，也沒看過源碼，但是并不耽誤我開發(fā)，別問我為什么 :) 我都是面向Google編程，手動狗頭，so 今天來補一下sb（SpringBoot）基礎(chǔ)知識
附帶視頻講解百度云地址：
鏈接：https://pan.baidu.com/s/1YOPRjBl_25VnuWLnV3lrQA
提取碼：ybx4
QQ群：317896269 點擊鏈接加入群聊【數(shù)據(jù)爬取技術(shù)群】：https://jq.qq.com/?_wv=1027&k=5H2Y1Tg
群文件有很多分享的數(shù)據(jù)，需要的可以去下載，另外入群費2元，老有人來發(fā)廣告，沒辦法了，收費。
特殊說明：雖然我不懂spring的源碼和原理，但是不影響我開發(fā)，這可能就是spring做的偉大的地方。但是，我看過spring原理后開發(fā)會更高效、優(yōu)質(zhì)。
為什么說上邊兩句話，因為有這個前提，所以我學習spring原理的途徑是找一個好的視頻，簡明扼要，快速精煉的了解一遍，然后在實踐。
在看了官方文檔之后，我選擇了找個視頻，文檔說的太全了，簡直浪費生命。
所以我google了這段視頻，并簡單整理后發(fā)到了百度云，視頻來源是某培訓機構(gòu)的，網(wǎng)上隨便搜的，使用開發(fā)工具eclipse，比較老舊，但是不影響觀看思想，總的來說講的很好，講師水平很高，建議1.5倍速度播放視頻觀看，我用了1天半，總計大概8個小時的時間觀看視頻、做筆記、coding部分代碼加這篇文章整理。受益良多。
加這段廢話的原因是：告訴你怎么快速掌握這段知識，and，少走彎路。
感謝原視頻作者，感謝spring框架，感謝google
起頭
SpringBoot起源于Spring，意在簡化Spring的配置和使用，Spring源于EJB，其源遠流長，更古不變的兩點核心，DI和IOC，即依賴注入和控制反轉(zhuǎn)
先看容器Spring首先是容器。
- 海納百川，有容奶大，對，奶大！
容器的配置一開始是使用xml配置文件的，現(xiàn)在用注解更方便了。故對照著來看，如下：
配置容器 @Configuration
標記一個類為配置類，這個類等同于配置文件beans.xml
注入組件 @Bean
標記配置類中的某個方法為注入的bean對象，被標記的方法等同于beans.xml 文件中的 <bean>標簽
Bean的生命周期
指定初始化和銷毀方法
1. @Bean(initMethod="初始化方法名",destroyMethod="銷毀方法名")
2. 讓Bean實現(xiàn)InitializingBean接口（定義初始化邏輯），DisposableBean（定義銷毀邏輯）
3. 可以使用JSR250；
* @PostConstruct：在bean創(chuàng)建完成并且屬性賦值完成；來執(zhí)行初始化方法
* @PreDestroy：在容器銷毀bean之前通知我們進行清理工作
-- 備注：JCP（Java Community Process）成立于1998年，是使有興趣的各方參與定義Java的特征和未來版本的正式過程。
4. BeanPostProcessor【interface】：bean的后置處理器；在bean初始化前后進行一些處理工作；
* postProcessBeforeInitialization:在初始化之前工作
* postProcessAfterInitialization:在初始化之后工作
包掃描 @ComponentScans
標記在配置類上，指明要掃描的包。等同于xml配置文件中的 <context:component-scan>標簽
包掃描時的過濾規(guī)則 @Filter
包掃描時@ComponentScans需要一些過濾規(guī)則，由注解@Filter標注。
組件的作用域 @Scope
用在@Bean注解的方法上，標注bean的作用域，Srping的bean默認是單例的，如果更改作用域使用這個注解
- singleton：單實例的（默認值）：ioc容器啟動會調(diào)用方法創(chuàng)建對象放到ioc容器中。以后每次獲取就是直接從容器中取（map.get()）
- prototype：多實例的：ioc容器啟動并不會去調(diào)用方法創(chuàng)建對象放在容器中。每次獲取的時候才會調(diào)用方法創(chuàng)建對象；
- request：同一次請求創(chuàng)建一個實例
- session：同一個session創(chuàng)建一個實例
組件懶加載 @Lazy
用在@Bean標注的方法上，指定bean懶加載，或者說延時加載，啟動的時候不加載，bean被第一次調(diào)用的時候加載。
組件按條件注入 @Conditional
注入bean時，指定一些條件@Conditional，標記在配置類或bean方法上
給容器快速導入一個組件 @Import
給容器導入組件的方式：
- 包掃描+內(nèi)置注解 （@Controller/@Service/@Repository/@Component）[自己寫的類]
- 導入第三方組件 @Bean[導入的第三方包里面的組件]
- @Import[快速給容器中導入一個組件]
*1）、@Import(要導入到容器中的組件)；容器中就會自動注冊這個組件，id默認是全類名
*2）、ImportSelector:返回需要導入的組件的全類名數(shù)組；
*3）、ImportBeanDefinitionRegistrar:手動注冊bean到容器中
4.使用Spring提供的 FactoryBean（工廠Bean）;- 1）、默認獲取到的是工廠bean調(diào)用getObject創(chuàng)建的對象
- 2）、要獲取工廠Bean本身，我們需要給id前面加一個& &colorFactoryBean
屬性注入 @Value
給屬性賦值，等同于xml中的 <bean>的 <property name="age" value="${}"></property>
- 1、基本數(shù)值
- 2、可以寫SpEL； #{}
- 3、可以寫${}；取出配置文件【properties】中的值（在運行環(huán)境變量里面的值）
加載配置文件@PropertySource
使用@PropertySource讀取外部配置文件中的k/v保存到運行的環(huán)境變量中;加載完外部的配置文件以后使用${}取出配置文件的值@PropertySource(value={"classpath:/person.properties"})
- 多個配置文件可以適用多個@PropertySource或者適用@PropertySources
再看自動注入
@Autowired注入
默認優(yōu)先按照類型去容器中找bean，applicationContext.getBean(BookDao.class)，找到就賦值，找不到時再按id去容器中找applicationContext.getBean("bookDao")，還找不到就報錯了。自動裝配默認一定要將屬性賦值好，沒有就會報錯；可以使用@Autowired(required=false)標注為找不到時注入null并不報錯;
1）、默認優(yōu)先按照類型去容器中找對應(yīng)的組件:applicationContext.getBean(BookDao.class);找到就賦值
2）、如果找到多個相同類型的組件，再將屬性的名稱作為組件的id去容器中查找applicationContext.getBean("bookDao")
3）、@Qualifier("bookDao")：使用@Qualifier指定需要裝配的組件的id，而不是使用屬性名
4）、自動裝配默認一定要將屬性賦值好，沒有就會報錯；可以使用@Autowired(required=false);
5）、@Primary：讓Spring進行自動裝配的時候，默認使用首選的bean；
也可以繼續(xù)使用@Qualifier指定需要裝配的bean的名字
Spring還支持使用@Resource(JSR250)和@Inject(JSR330)[java規(guī)范的注解]
- @Autowired:Spring定義的； @Resource、@Inject都是java規(guī)范
- @Resource:可以和@Autowired一樣實現(xiàn)自動裝配功能；默認是按照組件名稱進行裝配的；沒有能支持@Primary功能；沒有支持@Autowired（reqiured=false）;
- @Inject:需要導入javax.inject的包，和Autowired的功能一樣。沒有required=false的功能；
- 源碼使用后置處理器實現(xiàn)自動注入的，工作原理看下邊源碼分析：AutowiredAnnotationBeanPostProcessor:解析完成自動裝配功能；
自動注入注意事項
- @Autowired:可以標注在 造器，參數(shù)，方法，屬性；都是從容器中獲取參數(shù)組件的值
* 1）、[標注在方法位置]：@Bean+方法參數(shù)；參數(shù)從容器中獲取;默認不寫@Autowired效果是一樣的；都能自動裝配
* 2）、[標在構(gòu)造器上]：如果組件只有一個有參構(gòu)造器，這個有參構(gòu)造器的@Autowired可以省略，參數(shù)位置的組件還是可以自動從容器中獲取
* 3）、放在參數(shù)位置：
- 自定義組件想要使用Spring容器底層的一些組件（ApplicationContext，BeanFactory，xxx）；
* 自定義組件實現(xiàn)xxxAware；在創(chuàng)建對象的時候，會調(diào)用接口規(guī)定的方法注入相關(guān)組件；Aware；
* 把Spring底層一些組件注入到自定義的Bean中；
* xxxAware：功能使用xxxProcessor；
* ApplicationContextAware==》ApplicationContextAwareProcessor；
不同環(huán)境注入不同組件@Profile
指定組件在哪個環(huán)境的情況下才能被注冊到容器中，不指定，任何環(huán)境下都能注冊這個組件
- 1）、加了環(huán)境標識的bean，只有這個環(huán)境被激活的時候才能注冊到容器中。默認是default環(huán)境
- 2）、寫在配置類上，只有是指定的環(huán)境的時候，整個配置類里面的所有配置才能開始生效
- 3）、沒有標注環(huán)境標識的bean在，任何環(huán)境下都是加載的；
切換環(huán)境的方式
- //1、使用命令行動態(tài)參數(shù): 在虛擬機參數(shù)位置加載 -Dspring.profiles.active=test
- //2、代碼的方式激活某種環(huán)境；
AOP面象切面編程
面象切面編程：指在程序運行期間動態(tài)的將某段代碼切入到指定方法指定位置進行運行的編程方式；底層使用動態(tài)代理實現(xiàn)。
AOP：【動態(tài)代理】
指在程序運行期間動態(tài)的將某段代碼切入到指定方法指定位置進行運行的編程方式；
1、導入aop模塊；Spring AOP：(spring-aspects)
2、定義一個業(yè)務(wù)邏輯類（MathCalculator）；在業(yè)務(wù)邏輯運行的時候?qū)⑷罩具M行打印（方法之前、方法運行結(jié)束、方法出現(xiàn)異常，xxx）
3、定義一個日志切面類（LogAspects）：切面類里面的方法需要動態(tài)感知MathCalculator.div運行到哪里然后執(zhí)行；
通知方法：
前置通知(@Before)：logStart：在目標方法(div)運行之前運行
后置通知(@After)：logEnd：在目標方法(div)運行結(jié)束之后運行（無論方法正常結(jié)束還是異常結(jié)束）
返回通知(@AfterReturning)：logReturn：在目標方法(div)正常返回之后運行
異常通知(@AfterThrowing)：logException：在目標方法(div)出現(xiàn)異常以后運行
環(huán)繞通知(@Around)：動態(tài)代理，手動推進目標方法運行（joinPoint.procced()）
4、給切面類的目標方法標注何時何地運行（通知注解）；
5、將切面類和業(yè)務(wù)邏輯類（目標方法所在類）都加入到容器中;
6、必須告訴Spring哪個類是切面類(給切面類上加一個注解：@Aspect)
[7]、給配置類中加 @EnableAspectJAutoProxy 【開啟基于注解的aop模式】
在Spring中很多的 @EnableXXX;
AOP總結(jié) 三步：
- 1）、將業(yè)務(wù)邏輯組件和切面類都加入到容器中；告訴Spring哪個是切面類（@Aspect）
- 2）、在切面類上的每一個通知方法上標注通知注解，告訴Spring何時何地運行（切入點表達式）
- 3）、開啟基于注解的aop模式；@EnableAspectJAutoProxy
AOP原理
看給容器中注冊了什么組件，這個組件什么時候工作，這個組件的功能是什么？
AOP原理：【看給容器中注冊了什么組件，這個組件什么時候工作，這個組件的功能是什么？】
@EnableAspectJAutoProxy；
1、@EnableAspectJAutoProxy是什么？
@Import(AspectJAutoProxyRegistrar.class)：給容器中導入AspectJAutoProxyRegistrar
利用AspectJAutoProxyRegistrar自定義給容器中注冊bean；BeanDefinetion
internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
給容器中注冊一個AnnotationAwareAspectJAutoProxyCreator；
2、 AnnotationAwareAspectJAutoProxyCreator：
AnnotationAwareAspectJAutoProxyCreator
->AspectJAwareAdvisorAutoProxyCreator
->AbstractAdvisorAutoProxyCreator
->AbstractAutoProxyCreator
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
關(guān)注后置處理器（在bean初始化完成前后做事情）、自動裝配BeanFactory
AbstractAutoProxyCreator.setBeanFactory()
AbstractAutoProxyCreator.有后置處理器的邏輯；
AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
*
*
流程：
1）、傳入配置類，創(chuàng)建ioc容器
2）、注冊配置類，調(diào)用refresh（）刷新容器；
3）、registerBeanPostProcessors(beanFactory);注冊bean的后置處理器來方便攔截bean的創(chuàng)建；
1）、先獲取ioc容器已經(jīng)定義了的需要創(chuàng)建對象的所有BeanPostProcessor
2）、給容器中加別的BeanPostProcessor
3）、優(yōu)先注冊實現(xiàn)了PriorityOrdered接口的BeanPostProcessor；
4）、再給容器中注冊實現(xiàn)了Ordered接口的BeanPostProcessor；
5）、注冊沒實現(xiàn)優(yōu)先級接口的BeanPostProcessor；
6）、注冊BeanPostProcessor，實際上就是創(chuàng)建BeanPostProcessor對象，保存在容器中；
創(chuàng)建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
1）、創(chuàng)建Bean的實例
2）、populateBean；給bean的各種屬性賦值
3）、initializeBean：初始化bean；
1）、invokeAwareMethods()：處理Aware接口的方法回調(diào)
2）、applyBeanPostProcessorsBeforeInitialization()：應(yīng)用后置處理器的postProcessBeforeInitialization（）
3）、invokeInitMethods()；執(zhí)行自定義的初始化方法
4）、applyBeanPostProcessorsAfterInitialization()；執(zhí)行后置處理器的postProcessAfterInitialization（）；
4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)創(chuàng)建成功；--》aspectJAdvisorsBuilder
7）、把BeanPostProcessor注冊到BeanFactory中；
beanFactory.addBeanPostProcessor(postProcessor);
=======以上是創(chuàng)建和注冊AnnotationAwareAspectJAutoProxyCreator的過程========
AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；創(chuàng)建剩下的單實例bean
1）、遍歷獲取容器中所有的Bean，依次創(chuàng)建對象getBean(beanName);
getBean->doGetBean()->getSingleton()->
2）、創(chuàng)建bean
【AnnotationAwareAspectJAutoProxyCreator在所有bean創(chuàng)建之前會有一個攔截，InstantiationAwareBeanPostProcessor，會調(diào)用postProcessBeforeInstantiation()】
1）、先從緩存中獲取當前bean，如果能獲取到，說明bean是之前被創(chuàng)建過的，直接使用，否則再創(chuàng)建；
只要創(chuàng)建好的Bean都會被緩存起來
2）、createBean（）;創(chuàng)建bean；
AnnotationAwareAspectJAutoProxyCreator 會在任何bean創(chuàng)建之前先嘗試返回bean的實例
【BeanPostProcessor是在Bean對象創(chuàng)建完成初始化前后調(diào)用的】
【InstantiationAwareBeanPostProcessor是在創(chuàng)建Bean實例之前先嘗試用后置處理器返回對象的】
1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
希望后置處理器在此能返回一個代理對象；如果能返回代理對象就使用，如果不能就繼續(xù)
1）、后置處理器先嘗試返回對象；
bean = applyBeanPostProcessorsBeforeInstantiation（）：
拿到所有后置處理器，如果是InstantiationAwareBeanPostProcessor;
就執(zhí)行postProcessBeforeInstantiation
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
2）、doCreateBean(beanName, mbdToUse, args);真正的去創(chuàng)建一個bean實例；和3.6流程一樣；
3）、
AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】 的作用：
1）、每一個bean創(chuàng)建之前，調(diào)用postProcessBeforeInstantiation()；
關(guān)心MathCalculator和LogAspect的創(chuàng)建
1）、判斷當前bean是否在advisedBeans中（保存了所有需要增強bean）
2）、判斷當前bean是否是基礎(chǔ)類型的Advice、Pointcut、Advisor、AopInfrastructureBean，
或者是否是切面（@Aspect）
3）、是否需要跳過
1）、獲取候選的增強器（切面里面的通知方法）【List<Advisor> candidateAdvisors】
每一個封裝的通知方法的增強器是 InstantiationModelAwarePointcutAdvisor；
判斷每一個增強器是否是 AspectJPointcutAdvisor 類型的；返回true
2）、永遠返回false
2）、創(chuàng)建對象
postProcessAfterInitialization；
return wrapIfNecessary(bean, beanName, cacheKey);//包裝如果需要的情況下
1）、獲取當前bean的所有增強器（通知方法） Object[] specificInterceptors
1、找到候選的所有的增強器（找哪些通知方法是需要切入當前bean方法的）
2、獲取到能在bean使用的增強器。
3、給增強器排序
2）、保存當前bean在advisedBeans中；
3）、如果當前bean需要增強，創(chuàng)建當前bean的代理對象；
1）、獲取所有增強器（通知方法）
2）、保存到proxyFactory
3）、創(chuàng)建代理對象：Spring自動決定
JdkDynamicAopProxy(config);jdk動態(tài)代理；
ObjenesisCglibAopProxy(config);cglib的動態(tài)代理；
4）、給容器中返回當前組件使用cglib增強了的代理對象；
5）、以后容器中獲取到的就是這個組件的代理對象，執(zhí)行目標方法的時候，代理對象就會執(zhí)行通知方法的流程；
3）、目標方法執(zhí)行 ；
容器中保存了組件的代理對象（cglib增強后的對象），這個對象里面保存了詳細信息（比如增強器，目標對象，xxx）；
1）、CglibAopProxy.intercept();攔截目標方法的執(zhí)行
2）、根據(jù)ProxyFactory對象獲取將要執(zhí)行的目標方法攔截器鏈；
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
1）、List<Object> interceptorList保存所有攔截器 5
一個默認的ExposeInvocationInterceptor 和 4個增強器；
2）、遍歷所有的增強器，將其轉(zhuǎn)為Interceptor；
registry.getInterceptors(advisor);
3）、將增強器轉(zhuǎn)為List<MethodInterceptor>；
如果是MethodInterceptor，直接加入到集合中
如果不是，使用AdvisorAdapter將增強器轉(zhuǎn)為MethodInterceptor；
轉(zhuǎn)換完成返回MethodInterceptor數(shù)組；
3）、如果沒有攔截器鏈，直接執(zhí)行目標方法;
攔截器鏈（每一個通知方法又被包裝為方法攔截器，利用MethodInterceptor機制）
4）、如果有攔截器鏈，把需要執(zhí)行的目標對象，目標方法，
攔截器鏈等信息傳入創(chuàng)建一個 CglibMethodInvocation 對象，
并調(diào)用 Object retVal = mi.proceed();
5）、攔截器鏈的觸發(fā)過程;
1)、如果沒有攔截器執(zhí)行執(zhí)行目標方法，或者攔截器的索引和攔截器數(shù)組-1大小一樣（指定到了最后一個攔截器）執(zhí)行目標方法；
2)、鏈式獲取每一個攔截器，攔截器執(zhí)行invoke方法，每一個攔截器等待下一個攔截器執(zhí)行完成返回以后再來執(zhí)行；
攔截器鏈的機制，保證通知方法與目標方法的執(zhí)行順序；
總結(jié)：
1）、 @EnableAspectJAutoProxy 開啟AOP功能
2）、 @EnableAspectJAutoProxy 會給容器中注冊一個組件 AnnotationAwareAspectJAutoProxyCreator
3）、AnnotationAwareAspectJAutoProxyCreator是一個后置處理器；
4）、容器的創(chuàng)建流程：
1）、registerBeanPostProcessors（）注冊后置處理器；創(chuàng)建AnnotationAwareAspectJAutoProxyCreator對象
2）、finishBeanFactoryInitialization（）初始化剩下的單實例bean
1）、創(chuàng)建業(yè)務(wù)邏輯組件和切面組件
2）、AnnotationAwareAspectJAutoProxyCreator攔截組件的創(chuàng)建過程
3）、組件創(chuàng)建完之后，判斷組件是否需要增強
是：切面的通知方法，包裝成增強器（Advisor）;給業(yè)務(wù)邏輯組件創(chuàng)建一個代理對象（cglib）；
5）、執(zhí)行目標方法：
1）、代理對象執(zhí)行目標方法
2）、CglibAopProxy.intercept()；
1）、得到目標方法的攔截器鏈（增強器包裝成攔截器MethodInterceptor）
2）、利用攔截器的鏈式機制，依次進入每一個攔截器進行執(zhí)行；
3）、效果：
正常執(zhí)行：前置通知-》目標方法-》后置通知-》返回通知
出現(xiàn)異常：前置通知-》目標方法-》后置通知-》異常通知
聲明式事務(wù)
@EnableTransactionManagement 啟用事務(wù)
@Transactional 聲明式事務(wù)
Spring源碼分析
啟動流程分析
- 創(chuàng)建BeanFactory的預處理工作
- 創(chuàng)建BeanFactory
- 執(zhí)行BeanFactoryPostProcessor后續(xù)處理工作
- 注冊Bean
- 執(zhí)行BeanPostProcessor后續(xù)處理工作
- 初始化MessageSource消息綁定
- 初始化initApplicationEventMulticaster事件派發(fā)器
- 留給子容器自定義處理onRefresh
- 注冊監(jiān)聽器registerListeners
- 初始化剩下的單例組件 finishBeanFactoryInitialization
- ioc容器完成finishRefresh
源碼大體如下：
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
詳細代碼debug記錄如下：
Spring容器的refresh()【創(chuàng)建刷新】;
1、prepareRefresh()刷新前的預處理;
1）、initPropertySources()初始化一些屬性設(shè)置;子類自定義個性化的屬性設(shè)置方法；
2）、getEnvironment().validateRequiredProperties();檢驗屬性的合法等
3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；
2、obtainFreshBeanFactory();獲取BeanFactory；
1）、refreshBeanFactory();刷新【創(chuàng)建】BeanFactory；
創(chuàng)建了一個this.beanFactory = new DefaultListableBeanFactory();
設(shè)置id；
2）、getBeanFactory();返回剛才GenericApplicationContext創(chuàng)建的BeanFactory對象；
3）、將創(chuàng)建的BeanFactory【DefaultListableBeanFactory】返回；
3、prepareBeanFactory(beanFactory);BeanFactory的預準備工作（BeanFactory進行一些設(shè)置）；
1）、設(shè)置BeanFactory的類加載器、支持表達式解析器...
2）、添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
3）、設(shè)置忽略的自動裝配的接口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創(chuàng)建并預準備完成以后做進一步的設(shè)置
======================以上是BeanFactory的創(chuàng)建及預準備工作==================================
5、invokeBeanFactoryPostProcessors(beanFactory);執(zhí)行BeanFactoryPostProcessor的方法；
BeanFactoryPostProcessor：BeanFactory的后置處理器。在BeanFactory標準初始化之后執(zhí)行的；
兩個接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
1）、執(zhí)行BeanFactoryPostProcessor的方法；
先執(zhí)行BeanDefinitionRegistryPostProcessor
1）、獲取所有的BeanDefinitionRegistryPostProcessor；
2）、看先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanDefinitionRegistryPostProcessor、
postProcessor.postProcessBeanDefinitionRegistry(registry)
3）、在執(zhí)行實現(xiàn)了Ordered順序接口的BeanDefinitionRegistryPostProcessor；
postProcessor.postProcessBeanDefinitionRegistry(registry)
4）、最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanDefinitionRegistryPostProcessors；
postProcessor.postProcessBeanDefinitionRegistry(registry)
再執(zhí)行BeanFactoryPostProcessor的方法
1）、獲取所有的BeanFactoryPostProcessor
2）、看先執(zhí)行實現(xiàn)了PriorityOrdered優(yōu)先級接口的BeanFactoryPostProcessor、
postProcessor.postProcessBeanFactory()
3）、在執(zhí)行實現(xiàn)了Ordered順序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
4）、最后執(zhí)行沒有實現(xiàn)任何優(yōu)先級或者是順序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
6、registerBeanPostProcessors(beanFactory);注冊BeanPostProcessor（Bean的后置處理器）【 intercept bean creation】
不同接口類型的BeanPostProcessor；在Bean創(chuàng)建前后的執(zhí)行時機是不一樣的
BeanPostProcessor、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】、
1）、獲取所有的 BeanPostProcessor;后置處理器都默認可以通過PriorityOrdered、Ordered接口來執(zhí)行優(yōu)先級
2）、先注冊PriorityOrdered優(yōu)先級接口的BeanPostProcessor；
把每一個BeanPostProcessor；添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
3）、再注冊O(shè)rdered接口的
4）、最后注冊沒有實現(xiàn)任何優(yōu)先級接口的
5）、最終注冊MergedBeanDefinitionPostProcessor；
6）、注冊一個ApplicationListenerDetector；來在Bean創(chuàng)建完成后檢查是否是ApplicationListener，如果是
applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7、initMessageSource();初始化MessageSource組件（做國際化功能；消息綁定，消息解析）；
1）、獲取BeanFactory
2）、看容器中是否有id為messageSource的，類型是MessageSource的組件
如果有賦值給messageSource，如果沒有自己創(chuàng)建一個DelegatingMessageSource；
MessageSource：取出國際化配置文件中的某個key的值；能按照區(qū)域信息獲??；
3）、把創(chuàng)建好的MessageSource注冊在容器中，以后獲取國際化配置文件的值的時候，可以自動注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();初始化事件派發(fā)器；
1）、獲取BeanFactory
2）、從BeanFactory中獲取applicationEventMulticaster的ApplicationEventMulticaster；
3）、如果上一步?jīng)]有配置；創(chuàng)建一個SimpleApplicationEventMulticaster
4）、將創(chuàng)建的ApplicationEventMulticaster添加到BeanFactory中，以后其他組件直接自動注入
9、onRefresh();留給子容器（子類）
1、子類重寫這個方法，在容器刷新的時候可以自定義邏輯；
10、registerListeners();給容器中將所有項目里面的ApplicationListener注冊進來；
1、從容器中拿到所有的ApplicationListener
2、將每個監(jiān)聽器添加到事件派發(fā)器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3、派發(fā)之前步驟產(chǎn)生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的單實例bean；
1、beanFactory.preInstantiateSingletons();初始化后剩下的單實例bean
1）、獲取容器中的所有Bean，依次進行初始化和創(chuàng)建對象
2）、獲取Bean的定義信息；RootBeanDefinition
3）、Bean不是抽象的，是單實例的，是懶加載；
1）、判斷是否是FactoryBean；是否是實現(xiàn)FactoryBean接口的Bean；
2）、不是工廠Bean。利用getBean(beanName);創(chuàng)建對象
0、getBean(beanName)； ioc.getBean();
1、doGetBean(name, null, null, false);
2、先獲取緩存中保存的單實例Bean。如果能獲取到說明這個Bean之前被創(chuàng)建過（所有創(chuàng)建過的單實例Bean都會被緩存起來）
從private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);獲取的
3、緩存中獲取不到，開始Bean的創(chuàng)建對象流程；
4、標記當前bean已經(jīng)被創(chuàng)建
5、獲取Bean的定義信息；
6、【獲取當前Bean依賴的其他Bean;如果有按照getBean()把依賴的Bean先創(chuàng)建出來；】
7、啟動單實例Bean的創(chuàng)建流程；
1）、createBean(beanName, mbd, args);
2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);讓BeanPostProcessor先攔截返回代理對象；
【InstantiationAwareBeanPostProcessor】：提前執(zhí)行；
先觸發(fā)：postProcessBeforeInstantiation()；
如果有返回值：觸發(fā)postProcessAfterInitialization()；
3）、如果前面的InstantiationAwareBeanPostProcessor沒有返回代理對象；調(diào)用4）
4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);創(chuàng)建Bean
1）、【創(chuàng)建Bean實例】；createBeanInstance(beanName, mbd, args);
利用工廠方法或者對象的構(gòu)造器創(chuàng)建出Bean實例；
2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
調(diào)用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
3）、【Bean屬性賦值】populateBean(beanName, mbd, instanceWrapper);
賦值之前：
1）、拿到InstantiationAwareBeanPostProcessor后置處理器；
postProcessAfterInstantiation()；
2）、拿到InstantiationAwareBeanPostProcessor后置處理器；
postProcessPropertyValues()；
=====賦值之前：===
3）、應(yīng)用Bean屬性的值；為屬性利用setter方法等進行賦值；
applyPropertyValues(beanName, mbd, bw, pvs);
4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
1）、【執(zhí)行Aware接口方法】invokeAwareMethods(beanName, bean);執(zhí)行xxxAware接口的方法
BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
2）、【執(zhí)行后置處理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization（）;
3）、【執(zhí)行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
1）、是否是InitializingBean接口的實現(xiàn)；執(zhí)行接口規(guī)定的初始化；
2）、是否自定義初始化方法；
4）、【執(zhí)行后置處理器初始化之后】applyBeanPostProcessorsAfterInitialization
BeanPostProcessor.postProcessAfterInitialization()；
5）、注冊Bean的銷毀方法；
5）、將創(chuàng)建的Bean添加到緩存中singletonObjects；
ioc容器就是這些Map；很多的Map里面保存了單實例Bean，環(huán)境信息。。。。；
所有Bean都利用getBean創(chuàng)建完成以后；
檢查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就執(zhí)行afterSingletonsInstantiated()；
12、finishRefresh();完成BeanFactory的初始化創(chuàng)建工作；IOC容器就創(chuàng)建完成；
1）、initLifecycleProcessor();初始化和生命周期有關(guān)的后置處理器；LifecycleProcessor
默認從容器中找是否有l(wèi)ifecycleProcessor的組件【LifecycleProcessor】；如果沒有new DefaultLifecycleProcessor();
加入到容器；
寫一個LifecycleProcessor的實現(xiàn)類，可以在BeanFactory
void onRefresh();
void onClose();
2）、 getLifecycleProcessor().onRefresh();
拿到前面定義的生命周期處理器（BeanFactory）；回調(diào)onRefresh()；
3）、publishEvent(new ContextRefreshedEvent(this));發(fā)布容器刷新完成事件；
4）、liveBeansView.registerApplicationContext(this);
簡單總結(jié)
1）、Spring容器在啟動的時候，先會保存所有注冊進來的Bean的定義信息；
1）、xml注冊bean；<bean>
2）、注解注冊Bean；@Service、@Component、@Bean、xxx
2）、Spring容器會合適的時機創(chuàng)建這些Bean
1）、用到這個bean的時候；利用getBean創(chuàng)建bean；創(chuàng)建好以后保存在容器中；
2）、統(tǒng)一創(chuàng)建剩下所有的bean的時候；finishBeanFactoryInitialization()；
3）、后置處理器；BeanPostProcessor
1）、每一個bean創(chuàng)建完成，都會使用各種后置處理器進行處理；來增強bean的功能；
AutowiredAnnotationBeanPostProcessor:處理自動注入
AnnotationAwareAspectJAutoProxyCreator:來做AOP功能；
xxx....
增強的功能注解：
AsyncAnnotationBeanPostProcessor
....
4）、事件驅(qū)動模型；
ApplicationListener；事件監(jiān)聽；
ApplicationEventMulticaster；事件派發(fā)：
Web開發(fā)
servlet3.0注解和插件
注解
- 注冊servlet @WebServlet("/路由")
- 注冊filter @WebFilter
Shared libraries（共享庫） / runtimes pluggability（運行時插件能力）
1、Servlet容器啟動會掃描，當前應(yīng)用里面每一個jar包的
ServletContainerInitializer的實現(xiàn)
2、提供ServletContainerInitializer的實現(xiàn)類；
必須綁定在，META-INF/services/javax.servlet.ServletContainerInitializer
文件的內(nèi)容就是ServletContainerInitializer實現(xiàn)類的全類名；
總結(jié)：容器在啟動應(yīng)用的時候，會掃描當前應(yīng)用每一個jar包里面
META-INF/services/javax.servlet.ServletContainerInitializer
指定的實現(xiàn)類，啟動并運行這個實現(xiàn)類的方法；傳入感興趣的類型；
ServletContainerInitializer；
@HandlesTypes；
我沒關(guān)注過servlet3標準，這地方看看就算了，以后用到在Google，做個記錄，粘貼一個例子
//容器啟動的時候會將@HandlesTypes指定的這個類型下面的子類（實現(xiàn)類，子接口等）傳遞過來；
//傳入感興趣的類型；
@HandlesTypes(value={HelloService.class})
public class MyServletContainerInitializer implements ServletContainerInitializer {
/**
* 應(yīng)用啟動的時候，會運行onStartup方法；
*
* Set<Class<?>> arg0：感興趣的類型的所有子類型；
* ServletContext arg1:代表當前Web應(yīng)用的ServletContext；一個Web應(yīng)用一個ServletContext；
*
* 1）、使用ServletContext注冊Web組件（Servlet、Filter、Listener）
* 2）、使用編碼的方式，在項目啟動的時候給ServletContext里面添加組件；
* 必須在項目啟動的時候來添加；
* 1）、ServletContainerInitializer得到的ServletContext；
* 2）、ServletContextListener得到的ServletContext；
*/
@Override
public void onStartup(Set<Class<?>> arg0, ServletContext sc) throws ServletException {
// TODO Auto-generated method stub
System.out.println("感興趣的類型：");
for (Class<?> claz : arg0) {
System.out.println(claz);
}
//注冊組件 ServletRegistration
ServletRegistration.Dynamic servlet = sc.addServlet("userServlet", new UserServlet());
//配置servlet的映射信息
servlet.addMapping("/user");
//注冊Listener
sc.addListener(UserListener.class);
//注冊Filter FilterRegistration
FilterRegistration.Dynamic filter = sc.addFilter("userFilter", UserFilter.class);
//配置Filter的映射信息
filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*");
}
SpringMVC注解
- 1、web容器在啟動的時候，會掃描每個jar包下的META-INF/services/javax.servlet.ServletContainerInitializer
- 2、加載這個文件指定的類SpringServletContainerInitializer
- 3、spring的應(yīng)用一啟動會加載感興趣的WebApplicationInitializer接口的下的所有組件；
- 4、并且為WebApplicationInitializer組件創(chuàng)建對象（組件不是接口，不是抽象類）
- 1）、AbstractContextLoaderInitializer：創(chuàng)建根容器；createRootApplicationContext()；
- 2）、AbstractDispatcherServletInitializer：
創(chuàng)建一個web的ioc容器；createServletApplicationContext();
創(chuàng)建了DispatcherServlet；createDispatcherServlet()；
將創(chuàng)建的DispatcherServlet添加到ServletContext中；
getServletMappings(); - 3）、AbstractAnnotationConfigDispatcherServletInitializer：注解方式配置的DispatcherServlet初始化器
創(chuàng)建根容器：createRootApplicationContext()
getRootConfigClasses();傳入一個配置類
創(chuàng)建web的ioc容器： createServletApplicationContext();
獲取配置類；getServletConfigClasses();
總結(jié)：
以注解方式來啟動SpringMVC；繼承AbstractAnnotationConfigDispatcherServletInitializer；
實現(xiàn)抽象方法指定DispatcherServlet的配置信息；
定制SpringMVC；
1）、@EnableWebMvc:開啟SpringMVC定制配置功能；相當于原來的xml配置<mvc:annotation-driven/>；
2）、配置組件（視圖解析器、視圖映射、靜態(tài)資源映射、攔截器。。。）
extends WebMvcConfigurerAdapter
異步支持
servlet3.0 異步請求支持
接收到請求后，啟動新的線程處理業(yè)務(wù)，立即返回響應(yīng)。
servlet 的doGet方法類似如下代碼：
@WebServlet(value="/async",asyncSupported=true)
public class HelloAsyncServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//1、支持異步處理asyncSupported=true
//2、開啟異步模式
System.out.println("主線程開始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
AsyncContext startAsync = req.startAsync();
//3、業(yè)務(wù)邏輯進行異步處理;開始異步處理
startAsync.start(new Runnable() {
@Override
public void run() {
try {
System.out.println("副線程開始。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
sayHello();
startAsync.complete();
//獲取到異步上下文
AsyncContext asyncContext = req.getAsyncContext();
//4、獲取響應(yīng)
ServletResponse response = asyncContext.getResponse();
response.getWriter().write("hello async...");
System.out.println("副線程結(jié)束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
} catch (Exception e) {
}
}
});
System.out.println("主線程結(jié)束。。。"+Thread.currentThread()+"==>"+System.currentTimeMillis());
}
public void sayHello() throws Exception{
System.out.println(Thread.currentThread()+" processing...");
Thread.sleep(3000);
}
}
SpringMVC異步處理
/**
* 1、控制器返回Callable
* 2、Spring異步處理，將Callable 提交到 TaskExecutor 使用一個隔離的線程進行執(zhí)行
* 3、DispatcherServlet和所有的Filter退出web容器的線程，但是response 保持打開狀態(tài)；
* 4、Callable返回結(jié)果，SpringMVC將請求重新派發(fā)給容器，恢復之前的處理；
* 5、根據(jù)Callable返回的結(jié)果。SpringMVC繼續(xù)進行視圖渲染流程等（從收請求-視圖渲染）。
*
* preHandle.../springmvc-annotation/async01
主線程開始...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
主線程結(jié)束...Thread[http-bio-8081-exec-3,5,main]==>1513932494700
=========DispatcherServlet及所有的Filter退出線程============================
================等待Callable執(zhí)行==========
副線程開始...Thread[MvcAsync1,5,main]==>1513932494707
副線程開始...Thread[MvcAsync1,5,main]==>1513932496708
================Callable執(zhí)行完成==========
================再次收到之前重發(fā)過來的請求========
preHandle.../springmvc-annotation/async01
postHandle...（Callable的之前的返回值就是目標方法的返回值）
afterCompletion...
異步的攔截器:
1）、原生API的AsyncListener
2）、SpringMVC：實現(xiàn)AsyncHandlerInterceptor；
* @return
*/
@ResponseBody
@RequestMapping("/async01")
public Callable<String> async01(){
System.out.println("主線程開始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
Callable<String> callable = new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("副線程開始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
Thread.sleep(2000);
System.out.println("副線程開始..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
return "Callable<String> async01()";
}
};
System.out.println("主線程結(jié)束..."+Thread.currentThread()+"==>"+System.currentTimeMillis());
return callable;
}
