源码梳理（1）Springboot启动过程中的refreshContext(context) 刷新上下文，实例化Bean

SpringBoot容器刷新过程

示例源码的版本是springboot3.0.2

1，主启动类执行run方法

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
    	// 执行run方法
        SpringApplication.run(MainApplication.class);
    }
}

2，执行SpringApplication.class的run方法中的refreshContext(context);方法

	public ConfigurableApplicationContext run(String... args) {
		long startTime = System.nanoTime();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			// 刷新上下文，实例化Bean
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			// 省略...
		return context;
	}

3，执行ConfigurableApplicationContext的refresh()方法

	void refresh() throws BeansException, IllegalStateException;

普通web应用为AnnotationConfigServletWebServerApplicationContext，调用了父类ServletWebServerApplicationContext的refresh() 方法

	public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
		implements AnnotationConfigRegistry {
		// ...
	}

	@Override
	public final void refresh() throws BeansException, IllegalStateException {
		try {
			// 调用父类AbstractApplicationContext的refresh()方法
			super.refresh();
		}
		catch (RuntimeException ex) {
			WebServer webServer = this.webServer;
			if (webServer != null) {
				webServer.stop();
			}
			throw ex;
		}
	}

再调用ServletWebServerApplicationContext的父类AbstractApplicationContext的refresh()方法

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
			// 4.为刷新准备此上下文
			// Prepare this context for refreshing
			prepareRefresh();
			// 5.告诉子类去刷新内部bean工厂
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 6.准备bean工厂为了在上下文中使用
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);
			try {
				// 7，允许在上下文子类中对 Bean 工厂进行后置处理
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// 8，调用在上下文中注册为Bean的工厂处理器
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);
				// 9，注册Bean后置处理器（Bean后置处理器用于后面Bean创建时的拦截处理）
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();
				// 初始化消息源
				// Initialize message source for this context.
				initMessageSource();
				// 初始化事件广播器
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// 10，在特定的上下文子类中初始化其他特殊的 bean
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// 检查并注册所有的监听器 bean
				// Check for listener beans and register them.
				registerListeners();
				// 11，实例化剩余所有的非懒加载的单例Bean
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
				// 12，发布相应的事件
				// Last step: publish corresponding event.
				finishRefresh();
			}
			catch (BeansException ex) {
				// 省略...
			}
			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
				contextRefresh.end();
			}
		}
	}

4，prepareRefresh() 准备这个上下文以进行刷新，设置它的启动日期和活动标志，并对属性源进行任何初始化操作

	protected void prepareRefresh() {
		// 省略...
		// 初始化占位符属性源
		initPropertySources();
		// 验证所有标记为必需的属性是否可解析
		getEnvironment().validateRequiredProperties();
		// 准备applicationListeners（应用程序监听器）
		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}
		// 准备earlyApplicationEvents （应用程序事件）
		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

5，ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();告诉子类刷新内部 Bean 工厂

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 给bean工厂设置了序列化id并返回
		refreshBeanFactory();
		return getBeanFactory();
	}

6，prepareBeanFactory(beanFactory);准备bean工厂为了在上下文中使用

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		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());
		}
	}

7，postProcessBeanFactory(beanFactory);允许在上下文子类中对 Bean 工厂进行处理

执行AnnotationConfigServletWebServerApplicationContext的postProcessBeanFactory方法

	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 下文有说明
		super.postProcessBeanFactory(beanFactory);
		if (this.basePackages != null && this.basePackages.length > 0) {
			this.scanner.scan(this.basePackages);
		}
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}

先调用了父类ServletWebServerApplicationContext的postProcessBeanFactory方法

	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 添加WebApplicationContextServletContextAwareProcessor后置处理器
		// 负责处理实现ServletContextAware和ServletConfigAware接口的Bean
		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
		// 告诉Bean工厂忽略对ServletContextAware接口的依赖处理
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		// 注册Web应用程序作用域以及其相应的作用域处理器。
		registerWebApplicationScopes();
	}

8，invokeBeanFactoryPostProcessors(beanFactory);调用在上下文中注册为Bean的工厂后置处理器

	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

执行所有已注册的 BeanFactoryPostProcessor 实例的 postProcessBeanFactory 方法。BeanFactoryPostProcessor实例可以根据需要在Bean实例化之前对容器中的BeanDefinition进行修改、添加或删除。

9，registerBeanPostProcessors(beanFactory);注册Bean后置处理器（Bean后置处理器用于后面Bean创建时的拦截处理）

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

将BeanPostProcessors添加到AbstractBeanFactory的beanPostProcessors

10，onRefresh();在特定的上下文子类中初始化其他特殊的 bean

AbstractApplicationContext并没有操作，全部又子类实现

	protected void onRefresh() throws BeansException {
	}

ServletWebServerApplicationContext调用父类GenericWebApplicationContext的onRefresh方法，并创建启动Web服务

	@Override
	protected void onRefresh() {
		super.onRefresh();
		try {
			// 创建Web服务
			createWebServer();
		}
		catch (Throwable ex) {
			throw new ApplicationContextException("Unable to start web server", ex);
		}
	}

GenericWebApplicationContext的onRefresh方法进行初始化主题功能

	@Override
	protected void onRefresh() {
		this.themeSource = UiApplicationContextUtils.initThemeSource(this);
	}

11，finishBeanFactoryInitialization(beanFactory);实例化剩余所有非延迟注册的单例Bean

AbstractApplicationContext的finishBeanFactoryInitialization方法，核心环节beanFactory.preInstantiateSingletons();

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 省略...

		// 实例化剩余所有的非懒加载的单例Bean
		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

DefaultListableBeanFactory实现的preInstantiateSingletons方法，这部分的核心环节是getBean()方法

	@Override
	public void preInstantiateSingletons() throws BeansException {
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
						getBean(beanName);
					}
				}
				else {
					// 核心环节
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				smartSingleton.afterSingletonsInstantiated();
				smartInitialize.end();
			}
		}
	}

DefaultListableBeanFactory的getBean方法由AbstractBeanFactory的doGetBean方法实现，核心环节getSingleton()

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		String beanName = transformedBeanName(name);
		Object beanInstance;
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 省略...
		}
		else {
			// 省略...
			try {
				// 省略...
				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 核心环节：创建bean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 省略...
			}
			catch (BeansException ex) {
				beanCreation.tag("exception", ex.getClass().toString());
				beanCreation.tag("message", String.valueOf(ex.getMessage()));
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
			finally {
				beanCreation.end();
			}
		}
		return adaptBeanInstance(name, beanInstance, requiredType);
	}

AbstractBeanFactory的doGetBean方法中的getSingleton()方法，该方法的第二参数是一个函数式接口ObjectFactory<?>，具体的实现是通过了createBean(beanName, mbd, args);方法完成，进入createBean分支，这个环节完成了Bean的实例化，依赖注入，初始化

				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						// 省略...
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

@FunctionalInterface
public interface ObjectFactory<T> {
	T getObject() throws BeansException;
}

createBean分支：AbstractAutowireCapableBeanFactory实现了createBean方法，核心环节doCreateBean方法

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// 省略...
		try {
			// 核心环节
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		// 省略...
	}

createBean分支：AbstractAutowireCapableBeanFactory的doCreateBean方法，这个方法包含了实例化，依赖注入，初始化

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		// 实例化Bean
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.markAsPostProcessed();
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 核心环节：依赖注入 
			populateBean(beanName, mbd, instanceWrapper);
			// 核心环节：初始化
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		// 省略...
		return exposedObject;
	}

createBean分支：populateBean(beanName, mbd, instanceWrapper);依赖注入
createBean分支：exposedObject = initializeBean(beanName, exposedObject, mbd);初始化bean

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		// 如果bean实现了BeanNameAware，BeanClassLoaderAware，BeanFactoryAware则执行这三个接口对应的实现方法
		invokeAwareMethods(beanName, bean);
		Object wrappedBean = bean;
		// 执行bean后置处理器的postProcessBeforeInitialization方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			// 调用Bean的初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		// 省略...
		if (mbd == null || !mbd.isSynthetic()) {
			// 执行bean后置处理器的postProcessAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

到这里，AbstractBeanFactory的doGetBean方法中的getSingleton()方法的第二参数ObjectFactory<?>已经获取到了，接下来进入getSingleton方法的实现

if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

DefaultSingletonBeanRegistry实现了getSingleton方法，核心方法有addSingleton(beanName, singletonObject)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			// 省略...
				if (newSingleton) {
					// 核心环节，添加到单实例
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

DefaultSingletonBeanRegistry的addSingleton方法，作用是将给定的单例对象添加到此工厂的单例缓存中。用于对单例进行急切注册（非延迟注册）时调用

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 将对象放入一级缓存
			this.singletonObjects.put(beanName, singletonObject);
			// 移除三级缓存中的该对象
			this.singletonFactories.remove(beanName);
			// 移除二级缓存中的该对象
			this.earlySingletonObjects.remove(beanName);
			// 将 beanName添加registeredSingletons集合中，表示这个单例对象已经在工厂中注册
			this.registeredSingletons.add(beanName);
		}
	}

12，finishRefresh();发布相应的事件

	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.
		getLifecycleProcessor().onRefresh();
		// 发布上下文刷新事件
		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));
	}