文章目錄
1.擴展原理
* 擴展原理：
* 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；
*
* 4）、再來從容器中找到BeanFactoryPostProcessor組件；然後依次觸發postProcessBeanFactory()方法
*
* 3、ApplicationListener：監聽容器中發佈的事件。事件驅動模型開發；
* public interface ApplicationListener<E extends ApplicationEvent>
* 監聽 ApplicationEvent 及其下面的子事件；
*
* 步驟：
* 1）、寫一個監聽器（ApplicationListener實現類）來監聽某個事件（ApplicationEvent及其子類）
* @EventListener;
* 原理：使用EventListenerMethodProcessor處理器來解析方法上的@EventListener；
*
* 2）、把監聽器加入到容器；
* 3）、只要容器中有相關事件的發佈，我們就能監聽到這個事件；
* ContextRefreshedEvent：容器刷新完成（所有bean都完全創建）會發布這個事件；
* ContextClosedEvent：關閉容器會發布這個事件；
* 4）、發佈一個事件：
* applicationContext.publishEvent()；
*
* 原理：
* ContextRefreshedEvent、IOCTest_Ext$1[source=我發佈的時間]、ContextClosedEvent；
* 1）、ContextRefreshedEvent事件：
* 1）、容器創建對象：refresh()；
* 2）、finishRefresh();容器刷新完成會發布ContextRefreshedEvent事件
* 2）、自己發佈事件；
* 3）、容器關閉會發布ContextClosedEvent；
*
* 【事件發佈流程】：
* 3）、publishEvent(new ContextRefreshedEvent(this));
* 1）、獲取事件的多播器（派發器）：getApplicationEventMulticaster()
* 2）、multicastEvent派發事件：
* 3）、獲取到所有的ApplicationListener；
* for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
* 1）、如果有Executor，可以支持使用Executor進行異步派發；
* Executor executor = getTaskExecutor();
* 2）、否則，同步的方式直接執行listener方法；invokeListener(listener, event);
* 拿到listener回調onApplicationEvent方法；
*
* 【事件多播器（派發器）】
* 1）、容器創建對象：refresh();
* 2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
* 1）、先去容器中找有沒有id=“applicationEventMulticaster”的組件；
* 2）、如果沒有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
* 並且加入到容器中，我們就可以在其他組件要派發事件，自動注入這個applicationEventMulticaster；
*
* 【容器中有哪些監聽器】
* 1）、容器創建對象：refresh();
* 2）、registerListeners();
* 從容器中拿到所有的監聽器，把他們註冊到applicationEventMulticaster中；
* String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
* //將listener註冊到ApplicationEventMulticaster中
* getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
*
* SmartInitializingSingleton 原理：->afterSingletonsInstantiated();
* 1）、ioc容器創建對象並refresh()；
* 2）、finishBeanFactoryInitialization(beanFactory);初始化剩下的單實例bean；
* 1）、先創建所有的單實例bean；getBean();
* 2）、獲取所有創建好的單實例bean，判斷是否是SmartInitializingSingleton類型的；
* 如果是就調用afterSingletonsInstantiated();
*
*
*
1.1 BeanFactoryPostProcessor
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory...");
int count = beanFactory.getBeanDefinitionCount();
String[] names = beanFactory.getBeanDefinitionNames();
System.out.println("當前BeanFactory中有"+count+" 個Bean");
System.out.println(Arrays.asList(names));
}
}
public class Blue {
public Blue() {
System.out.println(" Blue構造方法執行.. ");
}
}
@ComponentScan("com.zy.ext")
@Configuration
public class ProConfig {
@Bean
public Blue blue(){
return new Blue();
}
}
@Test
public void testProc(){
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ProConfig.class);
applicationContext.close();
}
1.2 BeanDefinitionRegistryPostProcessor
在上一個代碼中，增加一個BeanDefinitionRegistryPostProcessor類
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
// TODO Auto-generated method stub
System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的數量："+beanFactory.getBeanDefinitionCount());
}
//BeanDefinitionRegistry Bean定義信息的保存中心，以後BeanFactory就是按照BeanDefinitionRegistry裏面保存的每一個bean定義信息創建bean實例；
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
// TODO Auto-generated method stub
System.out.println("postProcessBeanDefinitionRegistry...bean的數量："+registry.getBeanDefinitionCount());
//RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
registry.registerBeanDefinition("hello", beanDefinition);
}
}
1.3 ApplicationListener
@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {
//當容器中發佈此事件以後，方法觸發
@Override
public void onApplicationEvent(ApplicationEvent event) {
// TODO Auto-generated method stub
System.out.println("收到事件："+event);
}
}
1.4 @EventListener
@Service
public class ExtService {
@EventListener(classes={ApplicationEvent.class})
public void listen(ApplicationEvent event){
System.out.println("ExtService。。監聽到的事件："+event);
}
}
2.Spring容器創建原理
Spring容器的refresh()【創建刷新】;
1、prepareRefresh()刷新前的預處理;
1）、initPropertySources()初始化一些屬性設置;子類自定義個性化的屬性設置方法；
2）、getEnvironment().validateRequiredProperties();檢驗屬性的合法等
3）、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；
2、obtainFreshBeanFactory();獲取BeanFactory；
1）、refreshBeanFactory();刷新【創建】BeanFactory；
創建了一個this.beanFactory = new DefaultListableBeanFactory();
設置id；
2）、getBeanFactory();返回剛纔GenericApplicationContext創建的BeanFactory對象；
3）、將創建的BeanFactory【DefaultListableBeanFactory】返回；
3、prepareBeanFactory(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：BeanFactory的後置處理器。在BeanFactory標準初始化之後執行的；
兩個接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
1）、執行BeanFactoryPostProcessor的方法；
先執行BeanDefinitionRegistryPostProcessor
1）、獲取所有的BeanDefinitionRegistryPostProcessor；
2）、看先執行實現了PriorityOrdered優先級接口的BeanDefinitionRegistryPostProcessor、
postProcessor.postProcessBeanDefinitionRegistry(registry)
3）、在執行實現了Ordered順序接口的BeanDefinitionRegistryPostProcessor；
postProcessor.postProcessBeanDefinitionRegistry(registry)
4）、最後執行沒有實現任何優先級或者是順序接口的BeanDefinitionRegistryPostProcessors；
postProcessor.postProcessBeanDefinitionRegistry(registry)
再執行BeanFactoryPostProcessor的方法
1）、獲取所有的BeanFactoryPostProcessor
2）、看先執行實現了PriorityOrdered優先級接口的BeanFactoryPostProcessor、
postProcessor.postProcessBeanFactory()
3）、在執行實現了Ordered順序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
4）、最後執行沒有實現任何優先級或者是順序接口的BeanFactoryPostProcessor；
postProcessor.postProcessBeanFactory()
6、registerBeanPostProcessors(beanFactory);註冊BeanPostProcessor（Bean的後置處理器）【 intercept bean creation】
不同接口類型的BeanPostProcessor；在Bean創建前後的執行時機是不一樣的
BeanPostProcessor、
DestructionAwareBeanPostProcessor、
InstantiationAwareBeanPostProcessor、
SmartInstantiationAwareBeanPostProcessor、
MergedBeanDefinitionPostProcessor【internalPostProcessors】、
1）、獲取所有的 BeanPostProcessor;後置處理器都默認可以通過PriorityOrdered、Ordered接口來執行優先級
2）、先註冊PriorityOrdered優先級接口的BeanPostProcessor；
把每一個BeanPostProcessor；添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
3）、再註冊Ordered接口的
4）、最後註冊沒有實現任何優先級接口的
5）、最終註冊MergedBeanDefinitionPostProcessor；
6）、註冊一個ApplicationListenerDetector；來在Bean創建完成後檢查是否是ApplicationListener，如果是
applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7、initMessageSource();初始化MessageSource組件（做國際化功能；消息綁定，消息解析）；
1）、獲取BeanFactory
2）、看容器中是否有id爲messageSource的，類型是MessageSource的組件
如果有賦值給messageSource，如果沒有自己創建一個DelegatingMessageSource；
MessageSource：取出國際化配置文件中的某個key的值；能按照區域信息獲取；
3）、把創建好的MessageSource註冊在容器中，以後獲取國際化配置文件的值的時候，可以自動注入MessageSource；
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8、initApplicationEventMulticaster();初始化事件派發器；
1）、獲取BeanFactory
2）、從BeanFactory中獲取applicationEventMulticaster的ApplicationEventMulticaster；
3）、如果上一步沒有配置；創建一個SimpleApplicationEventMulticaster
4）、將創建的ApplicationEventMulticaster添加到BeanFactory中，以後其他組件直接自動注入
9、onRefresh();留給子容器（子類）
1、子類重寫這個方法，在容器刷新的時候可以自定義邏輯；
10、registerListeners();給容器中將所有項目裏面的ApplicationListener註冊進來；
1、從容器中拿到所有的ApplicationListener
2、將每個監聽器添加到事件派發器中；
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3、派發之前步驟產生的事件；
11、finishBeanFactoryInitialization(beanFactory);初始化所有剩下的單實例bean；
1、beanFactory.preInstantiateSingletons();初始化後剩下的單實例bean
1）、獲取容器中的所有Bean，依次進行初始化和創建對象
2）、獲取Bean的定義信息；RootBeanDefinition
3）、Bean不是抽象的，是單實例的，是懶加載；
1）、判斷是否是FactoryBean；是否是實現FactoryBean接口的Bean；
2）、不是工廠Bean。利用getBean(beanName);創建對象
0、getBean(beanName)； ioc.getBean();
1、doGetBean(name, null, null, false);
2、先獲取緩存中保存的單實例Bean。如果能獲取到說明這個Bean之前被創建過（所有創建過的單實例Bean都會被緩存起來）
從private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);獲取的
3、緩存中獲取不到，開始Bean的創建對象流程；
4、標記當前bean已經被創建
5、獲取Bean的定義信息；
6、【獲取當前Bean依賴的其他Bean;如果有按照getBean()把依賴的Bean先創建出來；】
7、啓動單實例Bean的創建流程；
1）、createBean(beanName, mbd, args);
2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);讓BeanPostProcessor先攔截返回代理對象；
【InstantiationAwareBeanPostProcessor】：提前執行；
先觸發：postProcessBeforeInstantiation()；
如果有返回值：觸發postProcessAfterInitialization()；
3）、如果前面的InstantiationAwareBeanPostProcessor沒有返回代理對象；調用4）
4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);創建Bean
1）、【創建Bean實例】；createBeanInstance(beanName, mbd, args);
利用工廠方法或者對象的構造器創建出Bean實例；
2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
調用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
3）、【Bean屬性賦值】populateBean(beanName, mbd, instanceWrapper);
賦值之前：
1）、拿到InstantiationAwareBeanPostProcessor後置處理器；
postProcessAfterInstantiation()；
2）、拿到InstantiationAwareBeanPostProcessor後置處理器；
postProcessPropertyValues()；
=====賦值之前：===
3）、應用Bean屬性的值；爲屬性利用setter方法等進行賦值；
applyPropertyValues(beanName, mbd, bw, pvs);
4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);
1）、【執行Aware接口方法】invokeAwareMethods(beanName, bean);執行xxxAware接口的方法
BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
2）、【執行後置處理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization（）;
3）、【執行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
1）、是否是InitializingBean接口的實現；執行接口規定的初始化；
2）、是否自定義初始化方法；
4）、【執行後置處理器初始化之後】applyBeanPostProcessorsAfterInitialization
BeanPostProcessor.postProcessAfterInitialization()；
5）、註冊Bean的銷燬方法；
5）、將創建的Bean添加到緩存中singletonObjects；
ioc容器就是這些Map；很多的Map裏面保存了單實例Bean，環境信息。。。。；
所有Bean都利用getBean創建完成以後；
檢查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就執行afterSingletonsInstantiated()；
12、finishRefresh();完成BeanFactory的初始化創建工作；IOC容器就創建完成；
1）、initLifecycleProcessor();初始化和生命週期有關的後置處理器；LifecycleProcessor
默認從容器中找是否有lifecycleProcessor的組件【LifecycleProcessor】；如果沒有new DefaultLifecycleProcessor();
加入到容器；
寫一個LifecycleProcessor的實現類，可以在BeanFactory
void onRefresh();
void onClose();
2）、 getLifecycleProcessor().onRefresh();
拿到前面定義的生命週期處理器（BeanFactory）；回調onRefresh()；
3）、publishEvent(new ContextRefreshedEvent(this));發佈容器刷新完成事件；
4）、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；事件派發：
3.servlet3.0
後續更新吧。。