Spring容器之refresh方法源码分析

最新推荐文章于 2024-03-29 17:27:13 发布
原创 最新推荐文章于 2024-03-29 17:27:13 发布 · 1.7k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析Spring框架的启动流程，从BeanFactory与ApplicationContext的关系出发，详细介绍refresh方法在启动Spring应用上下文中的作用，涵盖初始化前的准备、XML文件解析、BeanFactory的定制化、BeanPostProcessor注册等关键步骤。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

BeanFactory作为IOC容器的核心接口，ApplicationContext接口包含了BeanFactory的所用功能
来看看两者关系：
在这里插入图片描述既然是继承关系，那么ApplicationContext包含了BeanFactory的所用功能也就不足为奇了

ApplicationContext作为Spring上下文的关键接口，除了BeanFactory的功能，还包括各种环境、参数、BeanFactoryPostProcessors后处理器、事件以及单例bean的初始化等一系列操作，其中以refresh方法为spring启动入口，为整个Spring context上下文做准备工作；顺着refresh这个入口方法理下去，你会发现这段代码结构清晰，层次分明，以及优秀的扩展点的设计，阅读起来也是一种享受！

具体来看看AbstractApplicationContext#refresh方法在启动Spring应用上下文中做了哪些初始化操作

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			// 初始化前的准备工作，比如系统属性、环境变量的准备及验证
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			// 初始化BeanFactory,并进行XML文件解析
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			// 准备bean和非bean
			// BeanFactory各种功能的填充，比如对@Qualifier和@Autowired注解的支持
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 扩展点，具体功能由子类实现
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				// 激活各种BeanFactory处理器
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				// 注册拦截Bean创建的后处理器，这里只是注册，真正的调用在getBean的时候
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				// 国际化处理
				// 为上下文初始化Message源，即不同语音的消息体
				initMessageSource();

				// Initialize event multicaster for this context.
				// 初始化应用消息广播器，并初始化"applicationEventMulticaster"bean
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				// 模版方法，由子类扩展
				onRefresh();

				// Check for listener beans and register them.
				// 在所有注册的bean中查找Listener bean,注册到消息广播器中
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				// 对非惰性的单例进行初始化
				// 一般情况下单例都会在这里就初始化了，除非指定了惰性加载
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				// 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，
				// 同时发出ContextRefreshedEvent时间通知别人
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

1、prepareRefresh

初始化前的准备工作，比如系统属性、环境变量的准备及验证

	/**
	 * Prepare this context for refreshing, setting its startup date and
	 * active flag as well as performing any initialization of property sources.
	 */
	// AbstractApplicationContext#prepareRefresh
	protected void prepareRefresh() {
		// Switch to active.
		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());
			}
		}

		// Initialize any placeholder property sources in the context environment.
		// 模版方法，供子类实现
		initPropertySources();

		// Validate that all properties marked as required are resolvable:
		// see ConfigurablePropertyResolver#setRequiredProperties
		// 验证需要的属性文件是否都已经放入环境中
		getEnvironment().validateRequiredProperties();

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

		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		// 记录事件广播器启动之前发布的事件
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}

2、obtainFreshBeanFactory

初始化BeanFactory,并进行XML文件解析

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 初始化beanFactory，加载解析XML配置文件并转换成BeanDefinition
		refreshBeanFactory();
		return getBeanFactory();
	}	
	
	/**
	 * This implementation performs an actual refresh of this context's underlying
	 * bean factory, shutting down the previous bean factory (if any) and
	 * initializing a fresh bean factory for the next phase of the context's lifecycle.
	 */
	// AbstractRefreshableApplicationContext#refreshBeanFactory
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			// 创建DefaultListableBeanFactory实例
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 为了序列化指定id,如果需要的话，让这个BeanFactory从id反序列到BeanFactory
			beanFactory.setSerializationId(getId());
			// 定制化BeanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
			customizeBeanFactory(beanFactory);
			// 加载并解析XML文件
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
2.1、customizeBeanFactory

定制化BeanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖

	protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}
2.2、loadBeanDefinitions

加载并解析XML文件

    // AbstractXmlApplicationContext#loadBeanDefinitions
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		// 对beanDefinitionReader进行环境变量的设置
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		// 对beanDefinitionReader进行设置，可由子类覆盖，然后定制化实现
		initBeanDefinitionReader(beanDefinitionReader);

		// 有了资源读取器，那就开始解析了...
		// 这里底层IOC容器(DefaultListableBeanFactory)已经被注入到XmlBeanDefinitionReader中了,
		// 所以解析得到的BeanDefinition信息都会添加到DefaultListableBeanFactory#beanDefinitionMap中
		loadBeanDefinitions(beanDefinitionReader);
	}

主要操作

  • 定义XmlBeanDefinitionReader对象，对XML文件的读取
  • 对beanDefinitionReader进行环境变量的设置
  • 通过beanDefinitionReader读取资源文件，转换为成Document文档，然后从Document文档中提取Element元素，
    将这些元素解析成BeanDefinition对象，注入到IOC容器中管理

3、prepareBeanFactory

BeanFactory各种功能的填充

	/**
	 * Configure the factory's standard context characteristics,
	 * such as the context's ClassLoader and post-processors.
	 * @param beanFactory the BeanFactory to configure
	 */
	 // AbstractApplicationContext#prepareBeanFactory
	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()));
		// 为bean增加了一个默认的propertyEditor，这个主要是对bean的属性等设置管理的一个工具
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		// 通过ApplicationContextAwareProcessor#invokeAwareInterfaces进行aware接口信息回调
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

		// 设置几个忽略自动装配的接口
		// 当Spring将ApplicationContextAwareProcessor注册后，
		// 通过invokeAwareInterfaces方法间接调用的Aware类已经不是普通的bean了，
		// 因此spring在依赖注入的时候需要忽略它们
		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 interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		// 设置了几个自动装配的特殊规则
		// 注册一些固定依赖的属性，这些不属于Spring IOC容器管理
		// 当需要这些特定的bean时可以从resolvableDependencies中获取
		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.
		// 增加对AspectJ的支持
		if (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());
		}
	}

prepareBeanFactory主要做的事情

  • 设置beanFactory的classLoader为当前context的classLoader
  • 设置beanFactory的表达式语言处理器
  • 添加Aware回调接口的后处理器ApplicationContextAwareProcessor
  • 设置需要忽略自动装配的接口；因为这些接口在注册ApplicationContextAwareProcessor之后，后面的操作会触发相关方法，也就不是普通的bean了
  • 增加对AspectJ的支持
  • 添加默认的系统环境bean

4、invokeBeanFactoryPostProcessors

激活各种BeanFactory后处理器，可以理解为对BeanFactory的增强操作

	/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * respecting explicit order if given.
	 * <p>Must be called before singleton instantiation.
	 */
	// AbstractApplicationContext#invokeBeanFactoryPostProcessors
	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 (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}
	
	// 后处理器的来源有两处，一处是硬编码的形式，一处是从配置文件中读取
	// 其中硬编码信息的不考虑激活的优先级顺序，而配置中的则会考虑
	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();

		// 也就通过AbstractApplicationContext#addBeanFactoryPostProcessor方式添加的后处理器
		// 首先beanFactory得是BeanDefinitionRegistry类型才能把这些后处理解析的BeanDefinition注册到IOC容器
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			// 记录通过硬编码方式注册的BeanFactoryPostProcessor类型的处理器
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			// 记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor类型的处理器
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			// 情况一：对硬编码的添加的beanFactoryPostProcessors进行处理，
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					// BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry
					// 这种方法的作用就是通过后处理器将beanDefinition解析出来，通过registry注册到IOC容器
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			// 不初始化FactoryBeans类型，交给BeanFactoryPostProcessors去处理
			// 将BeanDefinitionRegistryPostProcessors按照PriorityOrdered，Ordered和其他进行分开处理
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// 情况二： 从配置文件中读取BeanDefinitionRegistryPostProcessor后处理器，也就是可以解析出BeanDefinition的后处理器
			// 比如ConfigurationClassPostProcessor，就是将@Configuration中的beanDefinition解析出来，
			// 并通过BeanDefinitionRegistry注册到IOC容器的beanDefinitionMap中(DefaultListableBeanFactory#beanDefinitionMap)
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			
			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			// 按优先级排序
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 将BeanDefinitionRegistryPostProcessor解析出来的beanDefinition
			// 通过registry注册到beanDefinitionMap中
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			// 处理Ordered这种优先级
			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);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 原理同上
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			// 就是剩下的了
			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;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			// 一种是可以解析注册beanDefinition的BeanFactory后处理器，一种是普通的BeanFactory后处理器，
			// 都分别调用其后处理方法BeanFactoryPostProcessor#postProcessBeanFactory
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}


		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		// 从配置中读取的BeanFactoryPostProcessor的后处理器
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		// 对后处理器进行分类
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

invokeBeanFactoryPostProcessors做的事情:

  • 有两类BeanFactoryPostProcessors后处理器
    • BeanDefinitionRegistryPostProcessor，这一类就通过后处理器可以将BeanDefinition解析出来，然后通过registry注册到IOC容器
    • BeanFactoryPostProcessor，这一类就是普通的bean工厂后处理器，调用其相关方法对BeanFactory进行增强
  • 知道了这两类BeanFactoryPostProcessors后处理器的作用，那这些后处理器从哪里来的呢？
    • 硬编码的方式，也就是通过AbstractApplicationContext#addBeanFactoryPostProcessor方式添加的后处理器
    • 通过配置文件，beanFactory.getBeanNamesForType找出来
  • 硬编码的后处理器不区分调用顺序，配置文件中的后处理器需要按照优先级调用
  • 两类后处理器做的事情不完全一样
    • BeanDefinitionRegistryPostProcessor不仅要调用postProcessBeanDefinitionRegistry解析BeanDefinition，还有调用postProcessBeanFactory对BeanFactory进行增强
    • BeanFactoryPostProcessor只调用postProcessBeanFactory

5、registerBeanPostProcessors

注册拦截Bean创建的后处理器，这里只是注册，真正的调用在getBean的时候

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

	// PostProcessorRegistrationDelegate#registerBeanPostProcessors
	// 这里是将配置文件中的BeanPostProcessor提取出来并注册进入beanFactory
	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		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.
		// BeanPostProcessorChecker是一个普通的信息打印，可能会有些情况，
		// 当Spring的配置中后处理器还没有被注册就已经开始了bean的初始化时，
		// 便会打印BeanPostProcessorChecker中设定的信息
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		// 使用priorityOrdered包装顺序
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		// MergedBeanDefinitionPostProcessor
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
		// 使用ordered保证顺序
		List<String> orderedPostProcessorNames = new ArrayList<>();
		// 无序BeanPostProcessor
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		// 第一步注册所有实现PriorityOrdered的BeanPostProcessors
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		// 第二步注册所有实现Ordered的BeanPostProcessors
		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.
		// 第三步注册所有无序的BeanPostProcessors
		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.
		// 第四步注册所有MergedBeanDefinitionPostProcessor类型的BeanPostProcessors
		sortPostProcessors(internalPostProcessors, beanFactory);
		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).
		// 添加ApplicationListeners探测器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
	
	/**
	 * Register the given BeanPostProcessor beans.
	 */
	// PostProcessorRegistrationDelegate#registerBeanPostProcessors
	private static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

		for (BeanPostProcessor postProcessor : postProcessors) {
			beanFactory.addBeanPostProcessor(postProcessor);
		}
	}

registerBeanPostProcessors主要做的事情

  • 将配置文件中的BeanPostProcessor提取出来并注册进入beanFactory
  • 第一步注册所有实现PriorityOrdered的BeanPostProcessors
  • 第二步注册所有实现Ordered的BeanPostProcessors
  • 第三步注册所有无序的BeanPostProcessors
  • 第四步注册所有MergedBeanDefinitionPostProcessor类型的BeanPostProcessors

6、 initMessageSource

为上下文初始化Message源，即不同语言的消息体

	/**
	 * Initialize the MessageSource.
	 * Use parent's if none defined in this context.
	 */
	protected void initMessageSource() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
			// 如果在配置中已经配置了messageSource，那么将messageSource提取并记录在this.messageSource中
			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.
			// 如果用户没有定义配置文件，那么使用临时的DelegatingMessageSource以便于作为调用getMessage方法的返回
			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信息，那就通过getBean的方式加载出来，否则的话定义默认DelegatingMessageSource实例

7、initApplicationEventMulticaster

初始化应用消息广播器

    // AbstractApplicationContext#initApplicationEventMulticaster
	// 如果用户自定义了事件广播器，那么使用用户自定义的事件广播器
	// 否则的话使用默认的ApplicationEventMulticaster
	protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		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 {
			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() + "]");
			}
		}
	}

也是一样的道理，如果用户定义了事件广播器就通过getBean的方式加载出来，否则的话创建默认SimpleApplicationEventMulticaster实例

8、registerListeners

注册监听器

	// AbstractApplicationContext#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!
		// 其次是通过配置文件的的方式注册监听器
		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...
		// 发布早期multicaster启动之前的事件
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

9、finishBeanFactoryInitialization

对非惰性的单例进行初始化

	/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		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));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		// 冻结所有的bean定义，说明注册的bean定义将不被修改或者任何进一步的处理
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		// 初始化剩下的单例对象(非惰性的)
		beanFactory.preInstantiateSingletons();
	}
9.1、preInstantiateSingletons

通过getBean的方式对非惰性单例对象进行初始化

	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.
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		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 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 {
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		// SmartInitializingSingleton#afterSingletonsInstantiated初始化完成的收尾工作
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

10、finishRefresh

完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshedEvent事件通知别人

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

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}		
	
	//
	//

refresh在spring应用上下文启动过程中的操作：

  • 初始化前准备工作，系统属性、环境变量的准备及验证
  • XML文件的解析，并将解析好的BeanDefinition注册到IOC容器的beanDefinitionMap
  • postProcessBeanFactory，提供扩展点，也就是在Application Context上下文做一些特定扩展 使得BeanFactory(IOC容器)执行预定的行为
  • 激活各种BeanFactory处理器BeanFactoryPostProcessors，以便于对BeanFactory的扩展
  • 注册拦截Bean的后处理器BeanPostProcessors，也就是在bean生命周期中的一揽子行为
  • 国际化处理，为上下文初始化Message源，即不同语语言的消息体
  • 初始化应用消息广播器
  • 在所有注册的bean中查找Listener bean,注册到消息广播器中
  • 对非惰性的单例进行实例化，一般情况下的单例都会在这里就实例化了，这样的好处是，在程序启动过程中就可以及时发现问题
  • 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程

以上是个人理解，如有问题请指出，谢谢！

深入理解 Spring IOC 底层实现机制（refresh 方法源码分析）
weixin_42118323的博客
04-26 1594
/IOC 核心方法//防止 启动和销毁并发执行//启动步骤记录//刷新准备工作//创建 beanFactory 将配置文件解析为 beandefiniton 对象 注册到 beanFactory 中//ConfigurableListableBeanFactory是一个接口 真正干活的是 DefaultListableBeanFactory//beanFactory 预处理 主要是设置 beanFactory 类加载器及忽略一些自动装配 设置一些默认benatry {
Spring容器启动流程——refresh()单个方法分析
最新发布
qq_44027353的博客
06-24 929
父类中定义的方法模板，子类去实现的重写的，AnnotationConfigApplicationContext没有重写该方法，但是SpringMVC的那个类重写了。这里会判断能否刷新，并且返回一个BeanFactory, 刷新不代表完全情况，主要是先执行Bean的销毁，然后重新生成一个BeanFactory，再在接下来的步骤中重新去扫描等等。把程序员自己定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件。
Spring源码refresh方法调试笔记
11-01
Spring源码refresh方法调试笔记，经过的所有的类，和步骤都有记载
Spring的refresh源码解读整理
flower_boboji的博客
02-08 1462
Spring的控制反转IOC 帮我们创建当前的对象,把对象交给spring,工厂模式工厂可以帮我们生产这些对象,工厂的这些类依旧需要手动去定义 技术的更新迭代最重要的一个目的就是 偷懒 springIOC容器可以放入bean对象,还可以放集合框架,在spring当中选择的是Map,因为当我们创建完成的时候,map是一个k-v键值对的方式,我们可以根据我们的key很方便的获取到value. 容器的底层原理是反射 spring当中用的最多的一个注解 @Autowire 手写一个反射实现@Autowire ca
【Spring源码分析】refresh方法
scj1022的博客
03-29 1295
Spring源码分析 - refresh方法内的12个方法
Spring refresh源码解析
m0_37604110的博客
11-25 236
1.refresh() @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识 prepareRefresh(); ...
Spring源码分析：refresh()
weixin_44145526的博客
01-25 1101
refresh()中共有13个方法，分别为。
Spring启动流程refresh()源码深入解析
09-07
Spring框架的启动流程是其核心功能之一，其中`refresh()`方法起到了至关重要...通过深入理解`refresh()`方法的源码，我们可以更好地掌握Spring容器的工作原理，这对于故障排查、性能优化以及自定义扩展都有极大的帮助。
Spring源码分析：IOC容器的刷新 - refresh()
adobe754的博客
01-04 1608
Spring源码分析：IOC容器的刷新 - refresh()
Spring IOC容器初始化流程源码分析
zwx900102的博客
11-05 890
Spring 源码之 IOC 容器前言IOC 只是一个 Map 集合IOC 三大核心接口IOC 初始化三大步骤定位加载注册总结 前言 在 Spring 框架中，大家耳熟能详的无非就是 IOC，DI，Spring MVC，AOP，这些是 Spring 中最基础的核心功能，再高级点的功能就还有数据数据访问模块（JDBC，ORM，事务等）。Spring 本身的扩展性也做得非常好，源码当中也是运用了大量设计模式来实现，了解 Spring 源码对于一个 Java 开发人员来说是非常有必要的，从源码中我们也可以学习到很
Spring源码：refresh方法解析
weixin_51110958的博客
03-19 2870
前言 在Spring中，refresh方法就是整个框架的核心，也是阅读源码的最合适的入口。这个方法包括了整个Spring的执行流程和bean的完整生命周期。首先从new ClassPathXmlApplicationContext(“xxx.xml”)开始。 public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
Spring源码-refresh
u012432276的博客
07-04 226
一、整体流程 AbstractApplicationContext 1.1 AbstractApplicationContext.refesh @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. // 初始化前的准备工
Spring中的IOC
liming0025的专栏
08-11 265
ICO\DI（控制翻转\依赖注入）是spring中比较核心的功能，也是其称霸java框架的主要原因之一，spring可以理解为众多框架的粘合剂，让项目中轻松可以引入想要使用的框架，能够让引入的框架之间解耦，可以看下在网上找到的图片，形容的很生动： 一、spring ioc初步 1、引入spirng核心包 spring-context 2、编写beans.xml，bean节点很简单，里面两个内容 id=也就是在spring容器内部的id，class=需要托管给容器的类路径 PS： ...
Spring源码解析(13)之refresh源码分析(一)
jokeMqc的博客
01-03 927
一、前言 在之前我们已经对spring的生命周期、AOP、事物等源码有了大体的分析，其中在对源码分析中大家有看到过refresh方法，Spring容器创建之后，会调用它的refresh方法，refresh的时候会做很多事情：比如完成配置类的解析、各种BeanFactoryPostProcessor和BeanPostProcessor的注册、国际化配置的初始化、web内置容器的构造等等。 接下来我们以ClassPathXmlApplicationContext这容器入手看整个refresh方法到底做了哪些
spring源码解析（二）：refresh()源码解析
L的追寻
08-05 1609
文章目录Spring refresh()源码解析1. prepareRefresh()：容器刷新前的准备2. obtainFreshBeanFactory()：初始化beanFactory，加载并解析配置3. prepareBeanFactory():设置beanFactory的属性4. postProcessBeanFactory(): BeanFactory创建完成后进行的后置处理工作5. i...
Spring源码分析refresh()第一篇
程序员路同学
07-05 181
spring源码分析 refresh方法 prepareBeanFactory 方法 方法说明
细说Spring——IoC详解（深入IoC实现）
啦啦啦的博客
05-12 4152
容器启动阶段我们可以其实可以偷偷做一些事情 书接上文：细说Spring——IoC详解（一），我们已经知道了容器实现控制反转和依赖注入的过程可以分为两个阶段： 容器启动阶段 Bean的实例化阶段 其实在这个两个阶段我们都可以偷偷的做一些事情，我们可以根据具体的场景加入自定义的扩展逻辑，下面我们就来了解一下容器启阶段我们可以做哪些事情。 Spring提供了一种叫做BeanFactoryPo...
Spring refresh()源码详解
qq_34573913的博客
03-27 1531
Spring refresh()源码详解
spring容器的refresh方法分析
guofeng5201314的博客
02-23 2759
从这里进去： 进入到refresh方法中,有10几个子方法，一个个讲。 1.prepareRefresh，刷新前的准备工作，比如：设置容器启动时间，设置活跃状态为true，设置关闭状态为false，获取environment对象，并加载当前的属性值到environment对象中，准备监听器和事件的集合对象，默认为空的集合。 2.obtainFreshBeanFactory，主要是创建容器对象(DefaultListableBeanFactory),生成BeanDefination,这个时候Default
Spring IoC深度解析：源码剖析与实践要点
Spring IoC容器的加载过程始于创建`AnnotationConfigApplicationContext`，这是一个用于从Java配置类启动Spring容器的上下文类。接着，通过`DefaultListableBeanFactory`实例化一个bean工厂，它是Spring中用于管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柏油

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值