Spring源码剖析（二）- 启动流程

alsoapig

已于 2023-04-20 11:05:03 修改

阅读量155

点赞数

分类专栏： Spring 文章标签： spring java

于 2023-04-19 18:33:30 首次发布

本文链接：https://blog.csdn.net/alsoapig/article/details/130208960

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

上一章总体介绍了一下Spring以及IoC，本章详解分析下Spring的启动流程。

版本

本文以Spring 5.3.16的代码为例，分析启动流程。

源码分析

在前一章引出了两个问题：

哪些类需要注册到IoC容器中，由容器负责创建，比如上面的例子，怎么把Company类放入到容器中管理
类中的哪些成员需要容器自动注入，比如怎么让容器把boss和worker注入到company中

哪些类需要注册到IoC容器中，或者说，如何指定一个类由IoC容器创建和管理。有以下几种方式：

基于XML配置	基于注解配置	基于Java类配置
在XML中通过<bean>来定义	在bean实现类上注解@Component或者衍生注解@Resource，@Controller等	在注解了@Configuration类中，通过在类方法上注解@Bean定义一个bean，方法返回一个bean
Bean实现类来源于第三方类库，如DataSource、JdbcTemplate等，无法在类上注解，通过XML配置比较好；命名空间的配置，aop、context等，只能采用XML	Bean实现类是当前项目开发的，可以直接在Java类上使用注解	Bean的实例化逻辑比较复杂，可以采用这种方式

在Spring和SpringMVC时代用基于XML和基于注解的比较多，在SpringBoot后采用基于注解和基于Java类的比较多，基于XML的越来越少。

ApplicationContext

上一章说到开发时一般不直接用BeanFactory，而是用ApplicationContext，那么基于XML配置和基于注解配置对应的类分别是ClassPathXmlApplicationContext和AnnotationConfigApplicationContext。
我们先使用ClassPathXmlApplicationContext，然后跟踪代码看下Spring是如何启动的。

ApplicationContext context = new ClassPathXmlApplicationContext("server.xml");

在server.xml中定义bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="child" class="org.example.ChildClz"></bean>
</beans>

启动之后，我们跟进去看下

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
	this(new String[] {configLocation}, true, null);
}

public ClassPathXmlApplicationContext(
			String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
			throws BeansException {

	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

super(parent)主要是设置parent和ResourceResolver，setConfigLocations保存XML路径，主逻辑都在refresh方法里。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

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

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				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();
				contextRefresh.end();
			}
		}
	}

prepareRefresh

prepareRefresh做一些初始化操作，比如设置当前状态this.closed.set(false)；this.active.set(true);初始化配置initPropertySources。

obtainFreshBeanFactory

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()，这个方法从名字上就可以看出是获取beanFactory，我们看看代码内部做了什么

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

protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			this.beanFactory = beanFactory;
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
}

先new了一个beanFactory，然后loadBeanDefinitions，我们用的是ClassPathXmlApplicationContext，所以首先是解析XML的具体路径，把ClassPath转成具体的File路径，然后读取XML并进行解析。
这里是用自带XML解析器来解析，最终交由BeanDefinitionParserDelegate来处理解析出来的元素，其中有parseBeanDefinitionElement，解析<bean>元素；parseCustomElement解析自定义元素，比如<context:component-scan>标签。
我们先看下具体是怎么解析<bean>标签：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        //从属性中获取Id
		String id = ele.getAttribute(ID_ATTRIBUTE);
		//从属性中获取name
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		//按,;分割name，生成别名数组
		List<String> aliases = new ArrayList<>();
		if (StringUtils.hasLength(nameAttr)) {
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}

		//beanName等于Id，如果没定义Id，则取别名数组中的第一个作为beanName，剩余的作为别名
		String beanName = id;
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
			if (logger.isTraceEnabled()) {
				logger.trace("No XML 'id' specified - using '" + beanName +
						"' as bean name and " + aliases + " as aliases");
			}
		}

		//检查beanName是否重复
		if (containingBean == null) {
			checkNameUniqueness(beanName, aliases, ele);
		}

		//继续解析，生成beanDefinition，如果XML没定义Id，也没定义name，则按规则生成，比如beanClassName#0
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						// Register an alias for the plain bean class name, if still possible,
						// if the generator returned the class name plus a suffix.
						// This is expected for Spring 1.2/2.0 backwards compatibility.
						String beanClassName = beanDefinition.getBeanClassName();
						if (beanClassName != null &&
								beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
								!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
							aliases.add(beanClassName);
						}
					}
					if (logger.isTraceEnabled()) {
						logger.trace("Neither XML 'id' nor 'name' specified - " +
								"using generated bean name [" + beanName + "]");
					}
				}
				catch (Exception ex) {
					error(ex.getMessage(), ele);
					return null;
				}
			}
			String[] aliasesArray = StringUtils.toStringArray(aliases);
			return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
		}

		return null;
}

以上代码，通过解析<bean>标签生成beanDefinition，beanName按以下规则：

如果在XML的<bean>标签中定义了属性id，那么beanName=id
如果没有定义属性id，但定义了name，按,;分割name，取第一个作为beanName，剩余的作为别名
如果没有定义id，也没定义name，那么按一定规则生成beanName，比如beanClassName#0

解析出了beanDefinition，下一步就是注册到beanFactory中：

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
}

以beanName为key，最终注册到beanFactory中的beanDefinitionMap中。bean的别名也存到beanFactory的aliasMap中。
我们回顾一下，简单来讲，refresh的第二步就是生成beanFactory，在生成beanFactory时解析XML，处理<bean>标签，生成beanDefinition，再以beanName为key，注册到beanFactory的beanDefinitionMap中。这个时候只是保存了bean的定义，还没有实例化bean。

prepareBeanFactory

从名字可以看出是做一些beanFactory的准备工作，这里就不放出详细代码了，主要做了以下工作：

设置classLoader
设置bEL（Spring Bean 的 EL 表达式，用于在运行时访问bean属性或方法的语言）
添加BPP，BeanPostProcessor，用于在bean实例化后做一些操作。这里添加的就是ApplicationContextAwareProcessor，就是处理各种Aware的，把对应的值赋值到bean实例中
调用beanFactory的registerResolvableDependency方法，注册可解析的依赖项
调用beanFactory的registerSingleton方法，注册单例

registerResolvableDependency和registerSingleton都是往beanFactory中注册实例，两者主要是使用场景不同。registerResolvableDependency方法注册的是一个可解决的依赖项，而不是一个单例对象。该方法的主要作用是为了解决某些场景下的依赖注入问题，如数据源、配置信息等。当容器在创建bean时需要访问这些资源或对象时，会优先从这些注册的可解决依赖项中查找对应类型的对象并返回。
registerResolvableDependency和registerSingleton往beanFactory中注入一些基础类，比如BeanFactory，Environment，SystemProperties等。

postProcessBeanFactory

在beanFactory加载所有beanDefinition之后，但还没有实例化bean之前做一些事情，比如注册一些BPP，此方法为空。

invokeBeanFactoryPostProcessors

运行BFPP，在beanFactory加载所有beanDefinition之后，但还没有实例化bean之前做一些事情。
在Spring容器启动时，会先进行必要的加载和实例化操作，然后调用invokeBeanFactoryPostProcessors方法来执行所有已经注册的BeanFactoryPostProcessor对象。这些对象的作用是在bean定义被解析之后，在bean实例化之前对bean工厂进行自定义修改或扩展，例如增加或删除某些属性、更改bean的作用域等。
该方法的调用顺序如下：