Spring 源碼（8）Spring BeanPostProcessor的註冊、國際化及事件發佈機制

来源:https://www.cnblogs.com/redwinter/archive/2022/05/06/16229572.html
-Advertisement-
Play Games

上一篇文章https://www.cnblogs.com/redwinter/p/16198942.html介紹了Spring的註解的解析過程以及Spring Boot自動裝配的原理，大概回顧下：Spring 解析註解是通過BeanFactoryPostProcessor的子介面BeanDefini ...


上一篇文章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 class="com.redwinter.test.EmailService">
		<property name="blackList">
			<list>
				<value>[email protected]</value>
				<value>[email protected]</value>
				<value>[email protected]</value>
			</list>
		</property>
	</bean>
	<bean class="com.redwinter.test.MyApplicationListener">
		<property name="notifyAddress" value="[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 class="com.redwinter.test.selfevent.EmailService">
		<property name="blackList">
			<list>
				<value>[email protected]</value>
				<value>[email protected]</value>
				<value>[email protected]</value>
			</list>
		</property>
	</bean>
	<bean class="com.redwinter.test.selfevent.MyApplicationListener">
		<property name="notifyAddress" value="[email protected]"/>
	</bean>
	<bean class="com.redwinter.test.selfevent.MyNotifier">
		<property name="notifyAddress" value="[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源碼中最重要的過程了。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 戲說領域驅動設計（廿五）——領域事件
    SaaS賽道是一個超大賽道，足夠容納上萬家服務商，不太可能有哪個服務商能滿足所有場景，大部分SaaS服務商在某個垂直領域，提供差異化的產品和服務。SaaS產品大部分都是面向B端客戶，少部分面向C端客戶，本文主要講的B端SaaS產品。 B端SaaS產品的挑戰 B端SaaS產品為企業提供協同辦公的工具， ...
  • 設計模式七大原則—里氏替換原則
    1.基本介紹 裡斯科瓦（Barbara Liskov）使美國麻省理工學院電氣工程於電腦科學系資深教授，她是美國國家工程院院士，在程式語言、分散式計算、程式設計方法及軟體工程領域做出了卓越貢獻。裡斯科瓦於1987年提出了一個關於繼承的原則，也就是現在我們稱為的“里氏替換原則”。 里氏替換原則基於子類 ...
  • ShardingSphere 集成 CosId 實戰
    1.基本介紹 1.1.概念 高層模塊不能依賴於一個“具體化、細節化”的低層模塊，而是通過一個抽象的“規範/標準”建立兩者之間的依賴關係，簡言之就是：不依賴於實現，而是依賴於抽象。這裡“實現”一詞有的地方也稱為“細節”，在編碼中主要體現的是我們根據業務模型具體自定義的普通類，比如：員工類、商品類等。而 ...
  • 為什麼java代碼設計為不支持類多繼承
    package com.oop.demo05;//在java中所有的類都直接或者間接預設繼承object//人 父類public class Person { //public 公有的 //protected 受保護的 //default 預設的 //private 私有的 //private in ...
  • Java代碼中關鍵字static的功能簡介說明？
    Resources 類，顧名思義就是資源，用於讀取資源文件。其有很多方法通過載入並解析資源文件，返回不同類型的 IO 流對象 ...
  • 學習python之前，我們來看看它的辭彙~（零基礎知識分享）
    前言 在學習python的過程中，很多人會說，需要我的英語基礎特別好嘛？ 是不需要的，它所常用的單詞其實就那麼多，只要你用心和常去敲敲代碼，其實是非常容易的。 下麵我整理了一些python常用單詞，你可以看一看，希望對你帶來幫助~ 由於不太好打出來，我就用圖片來代替啦~ 好啦~就到這裡啦~辭彙還是很 ...
  • ReentrantLock學習
    ReentrantLock ReentrantLock功能 ReentrantLock和synchronized一樣是可重入的 可重入即當線程擁有了鎖時，當該線程再次請求鎖資源的時候，線程是可以再次成功獲得的。 static ReentrantLock lock = new ReentrantLoc ...
  • PageObject（PO）設計模式在 UI 自動化中的實踐總結（以 QQ 郵箱登陸為例）
    Spring Ioc源碼分析系列--Ioc的基礎知識準備 本系列文章代碼基於Spring Framework 5.2.x Ioc的概念 在Spring里，Ioc的定義為The IoC Container，翻譯過來也就是Ioc容器。為什麼會被叫做容器呢？我們來比對一下日常生活中的容器，也就是那些瓶瓶罐 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類