上一篇文章https://www.cnblogs.com/redwinter/p/16198942.html介紹了Spring的注解的決議程序以及Spring Boot自動裝配的原理，大概回顧下：Spring 決議注解是通過BeanFactoryPostProcessor的子介面BeanDefinitionRegistryPostProcessor的實作類ConfigurationClassPostProcessor進行實作的，主要決議了@Componenet、@ComponentScans、@ComponentScan、@PropertySources、@PropertySource、@Import、@ImportResource、@Bean，并且是按照這個順序進行決議的，由于Spring是基于注解開發，比如@Configuration、@Service、@Controller等注解都是在@Component注解之上定義的，因此這些注解也是在這里決議的，然后就是Spring Boot 自動裝配，他是通過@Import注解決議ImportSelector介面的selectorImports方法進行BeanDefinition的決議的，并且在這個方法中，Spring 默認掃描META-INF/spring.factories檔案，key為@AutoEnableConfiguration注解，value為需要注入的類，最終經過過濾去重得到真正需要注入的類的全類名陣列，最終通過loadBeanDefinitions注冊到Spring容器中，
接下來繼續解讀AbstractApplicationContext#refresh方法對BeanPostProcessor的注冊，
registerBeanPostProcessors 注冊BPP
上原始碼：
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 通過型別獲取beanNames
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 計算beanProcessor的數量
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 添加一個BeanPostProcessor,所有上面+1了
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// PriorityOrdered的bpp
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 內部的bpp
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// Ordered的BPP
List<String> orderedPostProcessorNames = new ArrayList<>();
// 沒有排序的Bpp
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 匹配是否是PriorityOrdered型別的bpp，是就加入進去
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 判斷是否是合并的mbdpp，這個類有點類似于BFPP的子類bdrpp
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 匹配是否是Ordered的bpp
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
// 沒有排序的bpp
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注冊bpp
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 將beanName轉換為BPP物件存放在list中
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注冊到容器中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 處理沒有排序的bpp
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 注冊到容器
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 對內部的bpp進行排序
sortPostProcessors(internalPostProcessors, beanFactory);
// 注冊內部的bpp
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 重新注冊ApplicationListenerDetector 的bpp，把它放在了鏈表的尾部
// 因為在準備BeanFactory時已經添加過這個bpp
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
前面的文章：https://www.cnblogs.com/redwinter/p/16196359.html BeanFactoryPostProcessor的執行和決議的話，這里就很相似了，基本套路都是一樣的，
- 通過
getBeanNamesByType獲取BPP的陣列 - 設定集合存盤
BPP - 決議
PriorityOrdered的BPP，排序，注冊，中間加入決議內部的BPP - 決議
Orderd的BPP，排序，注冊 - 決議沒有排序的，注冊，，中間加入決議內部的
BPP - 最后注冊內部的BPP
- 將
ApplicationListenerDetector注冊到容器的后面，這個類是之前添加過的（這里：prepareBeanFactory），這里移到了最后
注冊BPP都是呼叫的這個方法遍歷處理的:
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
// 加入到容器中
beanFactory.addBeanPostProcessor(postProcessor);
}
}
與BFPP 不同的是，BPP只是進行了注冊并沒有進行執行，BFPP是注冊并執行，
BeanPostProcessor 基本上就做了這些事，相對比較簡單，接下來解讀下AbstractApplicationContext#refresh中對國際化、事件多播器、事件監聽器的處理，
初始化國際化
在單純的Spring中設定國際化實際上是體現不出來的，需要用到Spring MVC 才能有所體現，我們看看Spring是怎么初始化的，上原始碼：
protected void initMessageSource() {
// 獲取beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果工廠中已經有這個bean，那就獲取出來設定到messageSource上
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
// 判斷父類是否存在，如果存在則將判斷父類是否設定了訊息源，沒有設定就設定給他
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
// 如果容器中沒有注冊bean，那么new一個
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 注冊到容器中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
邏輯很簡單，首先是從容器中獲取MessageSource介面的實作，如果存在則直接賦值給AbstractApplicationContext的messageSource屬性，用于決議國際化和引數化，如果沒有就直接new一個委派的實作類，然后賦值給messageSource屬性，并注冊到容器中，
在Spring中提供了兩個默認的實作：ResourceBundleMessageSource 和 ReloadableResourceBundleMessageSource
初始化多播器、重繪容器、注冊監聽器
initApplicationEventMulticaster初始化多播器，上原始碼：
protected void initApplicationEventMulticaster() {
// 獲取beanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 從容器中獲取bean，如果就拿出來
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 沒有事件多播器就new一個，多播器會創建一個監聽器的集合，用于存放監聽器
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
// 注冊到容器中
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
原始碼跟國際化的代碼基本邏輯一直，如果容器中有就拿出來賦值，沒有就創建一個SimpleApplicationEventMulticaster類作為默認的多播器，
onRefresh重繪蓉器這個方法是一個空方法，由子類實作，這里直接跳過了，
registerListeners注冊監聽器，上原始碼：
protected void registerListeners() {
// Register statically specified listeners first.
// 注冊靜態指定的監聽器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 根據型別獲取監聽器的beanName
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
// 遍歷bean，并加入到監聽器bean集合中
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
// 獲取早期的事件，這個事件是在準備重繪階段（第一個階段前戲階段）設定進來的，是一個空的集合
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
這里的邏輯也是比較簡單的：
-
先獲取靜態的監聽器，這里實際上就是在定制化
BeanFactory時可以手動添加的監聽器，如果有就添加到多播器的監聽器集合中@Override protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { // 擴展點 設定不去處理回圈依賴或者beanDefinition覆寫 super.setAllowBeanDefinitionOverriding(true); super.setAllowCircularReferences(true); super.customizeBeanFactory(beanFactory); // 添加一個自定義的屬性編輯器的注冊器 beanFactory.addPropertyEditorRegistrar(new AddressPropertyEditorRegistrar()); super.addBeanFactoryPostProcessor(new MyBeanDefinitionRegistryPostProcessor("new 創建的")); // 添加一個自定義的BeanPostProcessorr // beanFactory.addBeanPostProcessor(null); // 添加一個監聽器 super.addApplicationListener(new CustomApplicationListener()); } -
獲取定義為Bean的ApplicationListener，比如xml配置的，如果有就添加到多播器的監聽器集合中
-
獲取早期的事件，這里獲取到的是一個空集合
Spring的事件發布是如何設計的？
Spring的事件機制實際上是使用了觀察者模式進行設計的，觀察者模式分為兩大角色，觀察者和被觀察者，只是Spring更加的抽象，在Spring中分為事件ApplicationEvent、監聽器ApplicationListener、事件發布者ApplicationEventPublisher、事件的多播器ApplicationEventMulticaster，AbstractApplicationContext這個Spring 的BeanFactory容器就是實作了ApplicationEventPublisher,可以對事件進行發布，在Spring中內置了很多的事件，比如：ContextClosedEvent、ContextRefreshedEvent、ContextStartedEvent、ContextStopedEvent，而監聽器的話Spring內置不多，Spring還提供了注解方式的配置監聽器，注解為@EventListener，
觀察者模式與Spring事件驅動的對比：
在Spring 中如何使用事件，我們可以直接到官網 https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#context-functionality-events 可以找到事件的使用案例，
想了解的朋友可以直接點擊鏈接去查看，官網提供了兩種配置監聽器的方式，一種是實作ApplicationListener介面，一種是使用@EventLister注解配置，基于注解還可以配置異步的，排序的，
在自定義的事件發布時需要實作ApplicationEventPublisherAware 介面獲取到ApplicationEventPublisher 進行發布事件，
上代碼：
代碼是Spring官網提供的，功能就是如果郵箱被拉黑，那么就不發送訊息給郵箱，而是發布一個事件進行其他處理
定義一個事件源發布者：用來處理黑名單的郵箱
/**
* @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
* @since 1.0
**/
public class EmailService implements ApplicationEventPublisherAware {
private List<String> blackList;
public List<String> getBlackList() {
return blackList;
}
public void setBlackList(List<String> blackList) {
this.blackList = blackList;
}
private ApplicationEventPublisher applicationEventPublisher;
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
this.applicationEventPublisher = applicationEventPublisher;
}
public void sendEmail(String address,String context){
if (blackList.contains(address)){
// 在黑名單中，那么發布一個事件，但是不發送訊息到郵箱
applicationEventPublisher.publishEvent(new MyEvent(this,address,context));
return;
}
System.out.println("......發送郵箱........");
}
}
定義事件
/**
* @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
* @since 1.0
**/
public class MyEvent extends ApplicationEvent {
private final String address;
private final String context;
/**
* Create a new {@code ApplicationEvent}.
*
* @param source the object on which the event initially occurred or with
* which the event is associated (never {@code null})
*/
public MyEvent(Object source,String address,String context) {
super(source);
this.address = address;
this.context = context;
}
@Override
public String toString() {
return "MyEvent{" +
"address='" + address + '\'' +
", context='" + context + '\'' +
'}';
}
}
定義監聽器：
/**
* @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
* @since 1.0
**/
public class MyApplicationListener implements ApplicationListener<MyEvent> {
private String notifyAddress;
public String getNotifyAddress() {
return notifyAddress;
}
public void setNotifyAddress(String notifyAddress) {
this.notifyAddress = notifyAddress;
}
@Override
public void onApplicationEvent(MyEvent event) {
System.out.println("收到事件，開始發布");
System.out.println("發送訊息給" + notifyAddress + event.toString());
}
}
配置xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:redwinter="http://www.redwinter.com/schema/redwinter"
xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
http://www.redwinter.com/schema/redwinter http://www.redwinter.com/schema/redwinter.xsd
">
<!--配置事件監聽-->
<bean >
<property name="blackList">
<list>
<value>[email protected]</value>
<value>[email protected]</value>
<value>[email protected]</value>
</list>
</property>
</bean>
<bean >
<property name="notifyAddress" value="https://www.cnblogs.com/redwinter/archive/2022/05/06/[email protected]"/>
</bean>
</beans>
客戶端：
ClassPathXmlApplicationContext context = new MyClassPathXmlApplicationContext("classpath:spring-test.xml");
EmailService emailService = context.getBean(EmailService.class);
emailService.sendEmail("[email protected]","Spring原始碼學習中！");
我這里發送的郵箱在拉黑的組態檔中，所以就會觸發事件的發布并且將拉黑的郵箱資訊發送給[email protected]這個通知郵箱，如果設定成其他的郵箱，那么就能正常進行發送訊息，
輸出：
收到事件，開始發布
發送訊息給[email protected]{address='[email protected]', context='你好啊，Spring原始碼！'}
當然可有使用注解@EventListener進行配置：
/**
* @author <a href="https://www.cnblogs.com/redwinter/">redwinter</a>
* @since 1.0
**/
public class MyNotifier {
private String notifyAddress;
public String getNotifyAddress() {
return notifyAddress;
}
public void setNotifyAddress(String notifyAddress) {
this.notifyAddress = notifyAddress;
}
@EventListener
public void processMessage(MyEvent event){
System.out.println("收到事件，開始發布");
System.out.println("發送訊息給" + notifyAddress + event.toString());
}
}
xml增加一項配置：開啟掃描和新增一個Bean的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:redwinter="http://www.redwinter.com/schema/redwinter"
xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd
http://www.redwinter.com/schema/redwinter http://www.redwinter.com/schema/redwinter.xsd
">
<context:component-scan base-package="com.redwinter.test"/>
<!--配置事件監聽-->
<bean >
<property name="blackList">
<list>
<value>[email protected]</value>
<value>[email protected]</value>
<value>[email protected]</value>
</list>
</property>
</bean>
<bean >
<property name="notifyAddress" value="https://www.cnblogs.com/redwinter/archive/2022/05/06/[email protected]"/>
</bean>
<bean >
<property name="notifyAddress" value="https://www.cnblogs.com/redwinter/archive/2022/05/06/[email protected]"/>
</bean>
</beans>
輸出：
收到事件，開始發布
發送訊息給[email protected]{address='[email protected]', context='你好啊，Spring原始碼！'}
收到事件，開始發布
發送訊息給[email protected]{address='[email protected]', context='你好啊，Spring原始碼！'}
說明生效了，那么@EventListenter是如何決議的呢？
@EventListener注解如何決議的？
實際上在分析BFPP https://www.cnblogs.com/redwinter/p/16198942.html的時候，我們分析了Spring對注解的決議，提到了如果開啟了Spring的注解掃描，那么Spring默認會在容器中添加幾個內置的Bean，并且以internal開頭的Bean物件，這些Bean都是在AnnotationConfigUtils這個類中設定的：
//... 省略代碼....
// 創建一個 EventListenerMethodProcessor 的BeanDefinition
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 創建一個 DefaultEventListenerFactory 的BeanDefinition
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
//... 省略代碼....
可以看到設定了一個EventListenerMethodProcessor類還有一個DefaultEventListenerFactory，這兩個類分別用來決議@EvenListener和創建ApplicationListener介面的配接器，
EventListenerMethodProcessor 實作了BeanFactoryPostProcessor介面、SmartInitializingSingleton介面和ApplicationContextAware介面，BeanFactoryPostProcessor介面是用來對BeanDefinition進行個性化設定決議等操作，SmartInitializingSingleton介面是在初始化所有的單例Bean之后觸發的，也就是在preInstantiateSingletons方法中初始化Bean之后呼叫，ApplicationContextAware是用來獲取ApplicationContext的，
截取EventListenerMethodProcessor類中的的部分代碼：
// ... 省略代碼....
// 遍歷所有標有@EventListener注解的方法
for (Method method : annotatedMethods.keySet()) {
for (EventListenerFactory factory : factories) {
if (factory.supportsMethod(method)) {
Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
// 使用工廠創建一個監聽器，實際上創建的就是一個ApplicationListenerMethodAdapter
ApplicationListener<?> applicationListener =
factory.createApplicationListener(beanName, targetType, methodToUse);
if (applicationListener instanceof ApplicationListenerMethodAdapter) {
((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
}
// 添加到容器中，如果多播器不為空，則添加到多播器的監聽器集合中
context.addApplicationListener(applicationListener);
break;
}
}
}
// ... 省略代碼....
public ApplicationListener<?> createApplicationListener(String beanName, Class<?> type, Method method) {
return new ApplicationListenerMethodAdapter(beanName, type, method);
}
到這里Spring的AbstractApplicationContext#refresh方法中的10多個方法已經分析了10個了，接下來分析Bean的創建程序，應該是Spring原始碼中最重要的程序了，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/469810.html
標籤：其他
上一篇：完了，我的小網站圖片掛了！