小言_互联网的博客

Spring源码分析 (Spring启动过程之容器对象的创建) (十五)

2023-02-06 15:14 388人阅读  评论(0)

Spring启动过程之容器对象的创建

1.this()
2.注册配置类
3.refresh()

Spring会将所有交由Spring管理的类，扫描其class文件，将其解析成BeanDefinition，在BeanDefinition中会描述类的信息，例如:这个类是否是单例的，Bean的类型，是否是懒加载，依赖哪些类，自动装配的模型。Spring创建对象时，就是根据BeanDefinition中的信息来创建Bean。

文章目录

1.this()

（1）实例化BeanFactory【DefaultListableBeanFactory】工厂，用于生成Bean对象。
（2）实例化BeanDefinitionReader注解配置读取器，用于对特定注解（如@Service、@Repository）的类进行读取转化成 BeanDefinition 对象，（BeanDefinition 是 Spring 中极其重要的一个概念，它存储了 bean 对象的所有特征信息，如是否单例，是否懒加载，factoryBeanName 等）
（3）实例化ClassPathBeanDefinitionScanner路径扫描器，用于对指定的包目录进行扫描查找 bean 对象。

1.1 reader

reader 用于读取 BeanDefinition

registerAnnotationConfigProcessors(): 注册一个注解配置处理器

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
   

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
   
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
   
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
   
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   
			RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
   
			RootBeanDefinition def = new RootBeanDefinition();
			try {
   
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
   
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		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));
		}

		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));
		}

		return beanDefs;
	}
  1. 给工厂加入基础组件, 各种解析器

  1. 给工厂注册核心组件
    internalConfigurationAnnotationProcessor: 底层的配置文件处理器
    internalAutowiredAnnotationProcessor: 底层的自动装配处理器
    internalCommonAnnotationProcessor: 支持@PostConstruct @PreDestry注解
    PersistenceAnnotationBeanPostProcessor: jpa的后置处理器
    internalPersistenceAnnotationProcessor
    internalEventListenerProcessor: 事件功能处理器
    internalEventListenerFactory: 事件工厂功能处理器

1.2 scanner

scanner 扫描器: 准备了环境变量等信息和resourceLoader

2.register()

注册主配置类, 调用reader.register()

  1. 拿到主配置类的定义信息BeanDefinition

  2. 完善主配置类定义信息: processCommonDefinitionAnnotations()

    查看是否有@Lazy注解, @Primary, @Role, @DependsOn, @Description

  3. 注册主配置类

Spring启动时候会注册主配置类和加入核心后置处理器组件

3.refresh() 12大步

执行refresh()方法refresh()方法是整个Spring容器的核心，在这个方法中进行了bean的实例化、初始化、自动装配、AOP等功能。

public void refresh() throws BeansException, IllegalStateException {
   
	synchronized (this.startupShutdownMonitor) {
   
		// Prepare this context for refreshing.
		// 1. 刷新前的预处理
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 2. 获取 beanFactory，即前面创建的【DefaultListableBeanFactory】
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		// 3. 预处理 beanFactory，向容器中添加一些组件
		prepareBeanFactory(beanFactory);

		try {
   
			// Allows post-processing of the bean factory in context subclasses.
			// 4. 子类通过重写这个方法可以在 BeanFactory 创建并与准备完成以后做进一步的设置
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 5. 执行 BeanFactoryPostProcessor 方法，beanFactory 后置处理器
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			// 6. 注册 BeanPostProcessors，bean 后置处理器
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			// 7. 初始化 MessageSource 组件（做国际化功能；消息绑定，消息解析）
			initMessageSource();

			// Initialize event multicaster for this context.
			// 8. 初始化事件派发器，在注册监听器时会用到
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			// 9. 留给子容器（子类），子类重写这个方法，在容器刷新的时候可以自定义逻辑，web 场景下会使用
			onRefresh();

			// Check for listener beans and register them.
			// 10. 注册监听器，派发之前步骤产生的一些事件（可能没有）
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			// 11. 初始化所有的非单实例 bean
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			// 12. 发布容器刷新完成事件
			finishRefresh();
		}	
	}
}
  1. prepareRefresh()刷新前的预处理：
    1. initPropertySources()：初始化一些属性设置，子类自定义个性化的属性设置方法；
    2. getEnvironment().validateRequiredProperties()：检验属性的合法性
    3. earlyApplicationEvents = new LinkedHashSet()：保存容器中的一些早期的事件；
  2. obtainFreshBeanFactory()：获取在容器初始化时创建的BeanFactory：
    1. refreshBeanFactory()：刷新BeanFactory，设置序列化ID；
    2. getBeanFactory()：返回初始化中的GenericApplicationContext创建的BeanFactory对象，即【DefaultListableBeanFactory】类型
  3. prepareBeanFactory(beanFactory)：BeanFactory的预处理工作，向容器中添加一些组件：
    1. 设置BeanFactory的类加载器、设置表达式解析器等等
    2. 添加BeanPostProcessor【ApplicationContextAwareProcessor】
    3. 设置忽略自动装配的接口：EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware；
    4. 注册可以解析的自动装配类，即可以在任意组件中通过注解自动注入：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
    5. 添加BeanPostProcessor【ApplicationListenerDetector】
    6. 添加编译时的AspectJ；
    7. 给BeanFactory中注册的3个组件：environment【ConfigurableEnvironment】、systemProperties【Map<String, Object>】、systemEnvironment【Map<String, Object>】
  4. postProcessBeanFactory(beanFactory)：子类重写该方法，可以实现在BeanFactory创建并预处理完成以后做进一步的设置。
  5. invokeBeanFactoryPostProcessors(beanFactory)：在BeanFactory标准初始化之后执行 BeanFactoryPostProcessor的方法，即BeanFactory的后置处理器：
    1. 先执行BeanDefinitionRegistryPostProcessor： postProcessor.postProcessBeanDefinitionRegistry(registry)
      1. 获取所有的实现了BeanDefinitionRegistryPostProcessor接口类型的集合
      2. 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
      3. 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
      4. 最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors
    2. 再执行BeanFactoryPostProcessor的方法：postProcessor.postProcessBeanFactory(beanFactory)
    3. 获取所有的实现了BeanFactoryPostProcessor接口类型的集合
    4. 先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor
    5. 再执行实现了Ordered顺序接口的BeanFactoryPostProcessor
    6. 最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor
  6. registerBeanPostProcessors(beanFactory)：向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能
    1. 获取所有实现了BeanPostProcessor接口类型的集合：
    2. 先注册实现了PriorityOrdered优先级接口的BeanPostProcessor；
    3. 再注册实现了Ordered优先级接口的BeanPostProcessor；
    4. 最后注册没有实现任何优先级接口的BeanPostProcessor；
    5. 最终注册MergedBeanDefinitionPostProcessor类型的BeanPostProcessor：beanFactory.addBeanPostProcessor(postProcessor);
    6. 给容器注册一个ApplicationListenerDetector：用于在Bean创建完成后检查是否是ApplicationListener，如果是，就把Bean放到容器中保存起来：applicationContext.addApplicationListener((ApplicationListener<?>) bean);此时容器中默认有6个默认的BeanProcessor(无任何代理模式下)
  7. initMessageSource()：初始化MessageSource组件，主要用于做国际化功能，消息绑定与消息解析：
  8. initApplicationEventMulticaster()：初始化事件派发器，在注册监听器时会用到
    1. 看BeanFactory容器中是否存在自定义的ApplicationEventMulticaster：如果有，直接从容器中获取；如果没有，则创建一个SimpleApplicationEventMulticaster
    2. 将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件就可以直接自动注入。
  9. onRefresh()：留给子容器、子类重写这个方法，在容器刷新的时候可以自定义逻辑。
  10. registerListeners()：注册监听器：将容器中所有的ApplicationListener注册到事件派发器中，并派发之前步骤产生的事件：
  11. finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的单实例bean，核心方法是preInstantiateSingletons()，会调用getBean()方法创建对象；
    1. 获取容器中的所有beanDefinitionName，依次进行初始化和创建对象
    2. 获取Bean的定义信息RootBeanDefinition，它表示自己的BeanDefinition和可能存在父类的BeanDefinition合并后的对象
    3. 如果Bean满足这三个条件：非抽象的，单实例，非懒加载，则执行单例Bean创建流程：
    4. 所有Bean都利用getBean()创建完成以后，检查所有的Bean是否为SmartInitializingSingleton接口的，如果是；就执行afterSingletonsInstantiated()；
  12. finishRefresh()：发布BeanFactory容器刷新完成事件：

3.1 prepareRefresh

刷新前的准备

3.2 obtainFreshBeanFactory

获取之前this()new出来的工厂

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   
		refreshBeanFactory();
		return getBeanFactory();
	}

	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
   
		DefaultListableBeanFactory beanFactory = this.beanFactory;
		if (beanFactory == null) {
   
			throw new IllegalStateException("BeanFactory not initialized or already closed - " +
					"call 'refresh' before accessing beans via the ApplicationContext");
		}
		return beanFactory;
	}

3.3 prepareBeanFactory

BeanFactory的预处理工作，向容器中添加一些组件

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		if (!shouldIgnoreSpel) {
   
			beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		}
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
   
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
   
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
   
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
   
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
   
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}

3.4 postProcessBeanFactory

留给子类的模板方法,允许子类继续对工厂执行处理, 为模板方法模式

3.5 invokeBeanFactoryPostProcessors

在BeanFactory标准初始化之后执行BeanFactory的后置处理器

PostProcessorRegistrrationDelegate为一个可以执行BeanFactory和Bean的后置处理器的类

  • invokeBeanDefinitionRegistryPostProcessors: 执行BeanDefinitionRegistryPostProcessor
  • invokeBeanFactoryPostProcessors: 执行BeanFactoryPostProcessor
  • registerBeanPostProcessors: 注册BeanPostProcessor
  • sortPostProcessors: 排序后置处理器

3.6 registerBeanPostProcessors

向容器中注册Bean的后置处理器BeanPostProcessor，它的主要作用是干预Spring初始化bean的流程，从而完成代理、自动注入、循环依赖等功能

	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

3.7 initMessageSource

初始化MessageSource组件, 主要用于国际化功能消息绑定功能和消息解析功能。

3.8 initApplicationEventMulticaster

初始化事件派发器，在注册监听器时会用到。
在整个容器创建过程中，Spring 会发布很多容器事件，如容器启动、刷新、关闭等，这个功能的实现得益于这里的 ApplicationEventMulticaster 广播器组件，通过它来派发事件通知。

protected void initApplicationEventMulticaster() {
   
	// 获取 beanFactory
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	// 看看容器中是否有自定义的 applicationEventMulticaster
	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 {
   
		// 没有，就创建一个 SimpleApplicationEventMulticaster
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		// 将创建的 ApplicationEventMulticaster 添加到 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() + "]");
		}
	}
}

3.9 onRefresh

模板方法模式, 容器刷新时候可以自定义逻辑

3.10 registerListeners

注册监听器, 将ApplicationListener注册进派发器, 并派发事件

protected void registerListeners() {
   
	// Register statically specified listeners first.
	// 获取之前步骤中保存的 ApplicationListener
	for (ApplicationListener<?> listener : getApplicationListeners()) {
   
		// getApplicationEventMulticaster() 就是获取之前步骤初始化的 applicationEventMulticaster
		getApplicationEventMulticaster().addApplicationListener(listener);
	}
 
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let post-processors apply to them!
	// 从容器中获取所有的 ApplicationListener
	String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
	for (String listenerBeanName : listenerBeanNames) {
   
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}
 
	// Publish early application events now that we finally have a multicaster...
	// 派发之前步骤产生的 application events
	Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
	this.earlyApplicationEvents = null;
	if (earlyEventsToProcess != null) {
   
		for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
   
			getApplicationEventMulticaster().multicastEvent(earlyEvent);
		}
	}
}

3.11 finishBeanFactoryInitialization

初始化剩下的单例Bean。
在前面的步骤中，Spring 的大多数组件都已经初始化完毕了，剩下来的这个步骤就是初始化所有剩余的单实例 bean，Spring主要是通过preInstantiateSingletons()方法把容器中的 bean 都初始化完毕。

public void preInstantiateSingletons() throws BeansException {
   
	if (logger.isTraceEnabled()) {
   
		logger.trace("Pre-instantiating singletons in " + this);
	}
 
	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	// 获取容器中的所有 beanDefinitionName
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
 
	// Trigger initialization of all non-lazy singleton beans...
	// 循环进行初始化和创建对象
	for (String beanName : beanNames) {
   
		// 获取 RootBeanDefinition，它表示自己的 BeanDefinition 和可能存在父类的 BeanDefinition 合并后的对象
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		// 如果是非抽象的，且单实例，非懒加载
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
   
			// 如果是 factoryBean，利用下面这种方法创建对象
			if (isFactoryBean(beanName)) {
   
				// 如果是 factoryBean，则 加上 &，先创建工厂 bean
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
   
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
   
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
   
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
   
						getBean(beanName);
					}
				}
			}
			else {
   
				// 不是工厂 bean，用这种方法创建对象
				getBean(beanName);
			}
		}
	}
 
	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
   
		Object singletonInstance = getSingleton(beanName);
		// 检查所有的 bean 是否是 SmartInitializingSingleton 接口
		if (singletonInstance instanceof SmartInitializingSingleton) {
   
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
   
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
   
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
   
				// 回调 afterSingletonsInstantiated() 方法，可以在回调中做一些事情
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

3.12 finishRefresh

发布完成BeanFactory容器刷新事件。
整个容器初始化完毕之后，会在这里进行一些扫尾工作，如清理缓存，初始化生命周期处理器，发布容器刷新事件等。

protected void finishRefresh() {
   
	// Clear context-level resource caches (such as ASM metadata from scanning).
	// 清理缓存
	clearResourceCaches();
 
	// Initialize lifecycle processor for this context.
	// 初始化和生命周期有关的后置处理器
	initLifecycleProcessor();
 
	// Propagate refresh to lifecycle processor first.
	// 拿到前面定义的生命周期处理器【LifecycleProcessor】回调 onRefresh() 方法
	getLifecycleProcessor().onRefresh();
 
	// Publish the final event.
	// 发布容器刷新完成事件
	publishEvent(new ContextRefreshedEvent(this));
 
	// Participate in LiveBeansView MBean, if active.
	LiveBeansView.registerApplicationContext(this);
}

转载：https://blog.csdn.net/qq_43141726/article/details/128807204
查看评论
* 以上用户言论只代表其个人观点，不代表本网站的观点或立场