Spring源码分析之容器Refresh()方法

原创已于 2024-12-12 20:04:56 修改 · 1.6k 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

一直要努力哦

关注

标签

#spring #java #后端

分类后端开发

于 2024-12-03 17:06:20 首次发布

Spring源码分析专栏收录该内容

14 篇文章

订阅专栏

前言:

通过学习了上一篇文章Spring源码分析之容器的Register()以及Scan()-CSDN博客这个时候我们就学习Spring容器中的refresh()方法这个方法我们在SpringBoot的启动流程中也看到过那么我们就好好研究一下这个方法到底是有什么作用做了哪些事情

Refresh()方法:

@Override
	public void refresh() throws BeansException, IllegalStateException {
		this.startupShutdownLock.lock();
		try {
			//获得当前的线程
			this.startupShutdownThread = Thread.currentThread();
			// 开始记录上下文刷新的启动步骤
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
			// 准备上下文以进行刷新
			//这个就是进行一些准备工作
			prepareRefresh();
			// 初始化 BeanFactory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 为 BeanFactory 准备一些处理器
			prepareBeanFactory(beanFactory);
			try {
				// 允许子类在上下文中后处理 BeanFactory
				postProcessBeanFactory(beanFactory);
				// 开始记录 Bean 后处理器的启动步骤
				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// 初次调用 BeanPostProcessor
				// BeanFactoryPostProcessors 是 BeanFactory 的后置处理器
				// 这些处理器可以在类加载成为 BeanDefinition 时修改里面的属性值
				// 存在一些调用顺序(这个是一个重点)
				invokeBeanFactoryPostProcessors(beanFactory);
				// 注册拦截 Bean 创建的 BeanPostProcessor
				registerBeanPostProcessors(beanFactory);
				// 结束记录 Bean 后处理器的启动步骤
				beanPostProcess.end();
				// 初始化上下文的消息源
				initMessageSource();
				// 初始化上下文的事件多播器
				initApplicationEventMulticaster();
				// 初始化特定上下文子类中的其他特殊 Bean
				onRefresh();
				// 检查并注册监听器 Bean
				registerListeners();
				// 实例化所有剩余的非懒加载的单例 Bean
				//这个方法也是一个重点
				finishBeanFactoryInitialization(beanFactory);
				// 最后一步：发布相应的事件
				finishRefresh();
			}

对上面的方法进行一些概括：

1.prepareRefresh ：初始化前的准备工作，例如标记当前的状态,初始化属性源,验证一些属性
2.obtainFreshBeanFactory ：初始化BeanFactory，并进行XML 文件读取（如果需要的话）。这一步之后ApplicationContext就具有BeanFactory 所提供的功能，也就是可以进行Bean的提取等基础操作了。
3.prepareBeanFactory ：对BeanFactory 进行各种功能填充。
4.postProcessBeanFactory ：对 BeanFactory 做额外处理。默认没有实现
5.invokeBeanFactoryPostProcessors ：激活各种BeanFactory 处理器。这个就是可以修改以及添加BeanDefinition的一些属性这个也会出BeanDefinitionRegistryPostProcessor其子接口

6.registerBeanPostProcessors ：注册和创建拦截bean创建的bean处理器。BeanPostProcessor 在这一步已经完成了创建。这个就是通过type进行获得的然后将这些放到CopyonArraylist集合
7.initMessageSource ：为上下文初始化Message 源，即对不同语言的消息体进行国际化处理
8.initApplicationEventMulticaster ：初始化应用消息广播器，并放入"applicationEventMulticaster" bean 中如果没有的话那么就会创建SimpleApplicationEventMulticaster然后注册为单例Bean
9.onRefresh ：留给子类来初始化其他bean
10.registerListeners ：在所有注册的bean中查找listener bean，注册到消息广播器中
11.finishBeanFactoryInitialization ：初始化剩下的实例(非惰性)，在这里调用了getBean方法，创建了非惰性的bean实例
12.finishRefresh ：完成刷新过程，通知生命周期处理器 lifecycleProcesseor 刷新过程，同时发出ContextRefreshEvent 事件进行通知

具体的方法的分析:

Preparerefresh():

这个就是进行一些状态以及属性的初始化设置监听器的状态收集然后为后面的工作做准备

protected void prepareRefresh() {
		//设置一些状态如活跃
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);
		if (logger.isDebugEnabled()) {
			if (logger.isTraceEnabled()) {
				logger.trace("Refreshing " + this);
			}
			else {
				logger.debug("Refreshing " + getDisplayName());
			}
		}
		//什么都不做就是一个模块方法将方法交给子类来完成
		initPropertySources();
		//当前的环境是否有这个属性
		getEnvironment().validateRequiredProperties();

		//存储当前的应用监听器
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			//设置当前的监听器为刷新之前的状态
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}
		//这个可以收起早期的时间然后可以在多播器中进行发布
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

obtainFreshBeanFactory():

refreshBeanFactory()：

这个就是创建DefaultListableBeanFactory类型的BeanFactory并且进行一些基础的配置如设置这个BeanFactory设置为当前application的BeanFactory

protected final void refreshBeanFactory() throws BeansException {
		//如果已经存在的话那么就销毁Bean并且将这个BeanFactory进行关闭
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			//进行必要的配置
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			beanFactory.setApplicationStartup(getApplicationStartup());
			customizeBeanFactory(beanFactory);
		    //加载BeanDefinition
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

prepareBeanFactory:

这个理解起来就比较简单了就是对这个BeanFactory进行一些额外的配置也就是额外功能的推展如添加一些Bean的后置处理器,添加默认环境的Bean对象具体来看:

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		// 设置当前beanFactory 的classLoader 为当前context 的classLoader
		beanFactory.setBeanClassLoader(getClassLoader());
		// 设置beanFactory 的表达式语言处理器，Spring3 增加了表达式语言的支持
		// 默认可以使用 #{bean.xxx}的形式来调用处理相关属性。
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		// 为beanFactory 增加一个默认的propertyEditor，这个主要是针对bean的属性等设置管理的一个工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
		// Configure the bean factory with context callbacks.
		//添加BeanPostProcessor这个也就是说是Bean对象的后置处理器
		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.
		//添加默认环境配置的Bean
		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());
		}
	}

postProcessBeanFactory:

这个就是对BeanFactory进行一些后置的处理也就是功能个BeanPostProcessor一样

invokeBeanFactoryPostProcessors(beanFactory重点):下篇文章中会仔细说明

这个就是说执行所有的BeanFactoryPostProcessors这个也就是说通过执行这个后置处理器的话我们是可以对BeanDefinition(这个就是说通过对配置类进行解析(如:@Bean或者说@componentScan得到BeanDefinition然后注册到Spring容器中))进行一些处理的如修改其的class或者名字都是可以的在Bean没有实例化之前(也就是说我们可以从根上修改)但是这个里面就是会存在一个接口顺序的调用问题:如实现

BeanDefinitionRegistryPostProcessor>BeanFactoryPostProcessors除此以外里面还存在的顺序为

priorityOrder>Order>一无所有的

// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			//先执行实现BeanDefinitionRegistryPostProcessor的实例并且实现了proprityOrder的实例
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			//这个就是优先级proprityOrder的优先级是大于Order的优先级
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			//这个就是没有任何优先级的BeanDefinitionRegistryPostProcessor的处理器
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}

registerBeanPostProcessors:

这个就是说完成Bean后置处理器的创建和invokeBeanFactoryPostProcessors(beanFactory)的逻辑是有相似之处的如(顺序性是一样的)

 //这个主要就是获得BeanBeanPostProcessor的名字通过ByType
		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
		// Register BeanPostProcessorChecker that logs a warn message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		//这个就是获得BeanFactory里面的BeanBeanPostProcessor的数目的
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		//这个就是BeanFactory里面添加后置处理器
		//这个就是保证所有的Bean都能被BeanPostprocessor进行处理防止Bean已经完成创建
		beanFactory.addBeanPostProcessor(
				new BeanPostProcessorChecker(beanFactory, postProcessorNames, beanProcessorTargetCount));
//这个省略一些代码
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);核心逻辑

registerBeanPostProcessors():

这个就是将BeanPostProcessors方法集合中这个集合是CopyOnWriteArrayList

private static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<? extends BeanPostProcessor> postProcessors) {
         //这个就是根据不同的类型放到不同的集合中
if (beanFactory instanceof AbstractBeanFactory abstractBeanFactory) {
			// Bulk addition is more efficient against our CopyOnWriteArrayList there
			abstractBeanFactory.addBeanPostProcessors(postProcessors);
		}
		else {
			for (BeanPostProcessor postProcessor : postProcessors) {
				beanFactory.addBeanPostProcessor(postProcessor);
			}
		}
	}
	/** BeanPostProcessors to apply. */
    //这个就是一个copyonArrayList的集合
	private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();

initMessageSource():

这个方法就是说获得消息来源然后将其配置到容器里面如果没有设置的化那么就使用默认的

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    
    // 检查当前上下文是否已定义了名为 MESSAGE_SOURCE_BEAN_NAME 的 Bean
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        
        // 如果当前上下文有父上下文，并且 messageSource 实现了 HierarchicalMessageSource 接口，
        // 且其父级 MessageSource 尚未设置，则设置当前上下文的内部父级 MessageSource 为它的父级
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource hms &&
                hms.getParentMessageSource() == null) {
            hms.setParentMessageSource(getInternalParentMessageSource());
        }
        
        // 记录日志，说明使用了哪个 MessageSource
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    } else {
        // 当前上下文没有定义 MessageSource Bean，使用 DelegatingMessageSource
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        
        // 注册 DelegatingMessageSource 为单例 Bean
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        
        // 记录日志，说明使用了哪个 MessageSource
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
        }
    }
}

initApplicationEventMulticaster:

这个方法就是为了保证上下文会有一个事件多播器如果没有的化那么就会创建一个SimpleApplicationEventMulticaster 注册为单例 Bean

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    
    // 检查当前上下文是否已定义了名为 APPLICATION_EVENT_MULTICASTER_BEAN_NAME 的 Bean
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        
        // 记录日志，说明使用了哪个 ApplicationEventMulticaster
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    } else {
        // 当前上下文没有定义 ApplicationEventMulticaster Bean，使用 SimpleApplicationEventMulticaster
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        
        // 注册 SimpleApplicationEventMulticaster 为单例 Bean
        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() + "]");
        }
    }

onRefresh ：

这个就是说交给子类进行一些拓展点的如可以初始化一些资源或者配置某些服务

registerListeners ：

这个就是注册监听器如果有早期的事件的化那么就会通过多播器进行发布

protected void registerListeners() {
    // 注册静态指定的监听器
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // 不在这里初始化 FactoryBeans：我们需要保持所有常规 Bean 未初始化，
    // 以便后处理器可以应用到它们身上！
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // 发布早期应用程序事件因为我们在前面已经完成了多播器的创建
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

finishBeanFactoryInitialization(重点):

这个就是完成所有的单例Bean的初始化(Bean生命周期的一部分)

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 初始化引导执行器
		if (beanFactory.containsBean(BOOTSTRAP_EXECUTOR_BEAN_NAME) &&
				beanFactory.isTypeMatch(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class)) {
			beanFactory.setBootstrapExecutor(
					beanFactory.getBean(BOOTSTRAP_EXECUTOR_BEAN_NAME, Executor.class));
		}
		// 初始化类型转换服务
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}
		// 注册嵌入式值解析器，用于处理注解中的占位符
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 初始化 BeanFactoryInitializer Bean，以便它们可以尽早初始化其他特定的 Bean
		String[] initializerNames = beanFactory.getBeanNamesForType(BeanFactoryInitializer.class, false, false);
		for (String initializerName : initializerNames) {
			beanFactory.getBean(initializerName, BeanFactoryInitializer.class).initialize(beanFactory);
		}
		// 初始化 LoadTimeWeaverAware Bean，以便它们可以尽早注册转换器
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			try {
				beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
			} catch (BeanNotOfRequiredTypeException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to initialize LoadTimeWeaverAware bean '" + weaverAwareName +
							"' due to unexpected type mismatch: " + ex.getMessage());
				}
			}
		}
		// 停止使用临时类加载器，用于类型匹配
		beanFactory.setTempClassLoader(null);
		// 冻结配置，不允许进一步更改
		beanFactory.freezeConfiguration();
        //上面做的一些准备的工作都是为了这个方法做准备
		// 预实例化所有剩余的非懒加载的单例 Bean
		beanFactory.preInstantiateSingletons();
	}

preInstantiateSingletons():

这个方法就是说实例化一些Bean对象然后就是说SmartInitializingSingleton这接口也就是一个后置处理器和我们后面要说的BeanPostProcessor接口就是比较类似

public void preInstantiateSingletons() throws BeansException {
		// 记录日志，跟踪预实例化单例的过程
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}
		// 创建一个当前 Bean 定义名称列表的副本，以允许在初始化方法中注册新的 Bean 定义
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		// 触发所有非懒加载的单例 Bean 的初始化
		List<CompletableFuture<?>> futures = new ArrayList<>();
		// 设置标志，表示当前处于预实例化阶段
		this.preInstantiationPhase = true;
		this.preInstantiationThread.set(PreInstantiation.MAIN);
		try {
			// 遍历所有 Bean 名称
			for (String beanName : beanNames) {
				// 获取合并后的本地 Bean 定义
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 如果 Bean 不是抽象的且是单例的
				if (!mbd.isAbstract() && mbd.isSingleton()) {
					// 预实例化单例 Bean，并将返回的 CompletableFuture 添加到 futures 列表中
					//进行Bean的创建
					CompletableFuture<?> future = preInstantiateSingleton(beanName, mbd);
					if (future != null) {
						futures.add(future);
					}
				}
			}
		} finally {
			// 清除预实例化线程标识
			this.preInstantiationThread.remove();
			// 重置预实例化阶段标志
			this.preInstantiationPhase = false;
		}

		// 如果有未完成的 CompletableFuture，等待它们全部完成
		if (!futures.isEmpty()) {
			try {
				CompletableFuture.allOf(futures.toArray(new CompletableFuture<?>[0])).join();
			} catch (CompletionException ex) {
				// 重新抛出异常
				ReflectionUtils.rethrowRuntimeException(ex.getCause());
			}
		}
		// 触发所有适用的 Bean 的后初始化回调
		for (String beanName : beanNames) {
			// 获取单例实例
			Object singletonInstance = getSingleton(beanName, false);
			// 如果单例实例实现了 SmartInitializingSingleton 接口
			if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
				// 记录启动步骤
				StartupStep smartInitialize = getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				// 调用 afterSingletonsInstantiated 方法
				//这个就是说单例Bean完成初始化之后进行一个额外的操作
				smartSingleton.afterSingletonsInstantiated();
				// 结束启动步骤记录
				smartInitialize.end();
			}
		}

preInstantiateSingleton():

这个方法就是说提前初始话一些Bean这个Bean就是不能是抽象而且必须是单例的而且不能是懒加载的这个就是为了提高效率的一个举措也是异步进行的(初始化Bean的话中的GetBean方法后面会说)

//这个就是这个方法里面的核心方法
private void instantiateSingleton(String beanName) {
		//如果是FactoryBean的话那么这个时候
		if (isFactoryBean(beanName)) {
			Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
			if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
				getBean(beanName);
			}
		}
		else {
			//如果不是FactoryBean的话
			getBean(beanName);
		}
	}

finishRefresh：

这个我觉得就是发布一些事件以及清除缓存表示完成了刷新的操作然后就是开启生命周期的进行这个的话通常就是用来配置后台程序

protected void finishRefresh() {
    // 重置 Spring 核心基础设施中的通用内省缓存
    resetCommonCaches();

    // 清除上下文级别的资源缓存（如扫描生成的 ASM 元数据）
    clearResourceCaches();

    // 初始化生命周期处理器
    initLifecycleProcessor();

    // 通知生命周期处理器上下文已刷新
    getLifecycleProcessor().onRefresh();

    // 发布 ContextRefreshedEvent 事件，表示上下文刷新完成
    publishEvent(new ContextRefreshedEvent(this));
}