spring源码解读系列（一）:Bean生命周期图解
一、注意事项：
本次源码解读基于Spring-Framework 5.2.9版本，可自行通过官网下载源码，本地安装好gradle后可自行编译和运行，跟随本教程走进Spring底层
二、spring创建bean的整体流程
三、查看入口代码
通过main方法自定义测试类
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
Person bean = ac.getBean(Person.class);
Person bean2 = ac.getBean(Person.class);
四、入口代码解析
通过new ClassPathXmlApplicationContext(“applicationContext.xml”)查看spring源码，调用的如下方法：
/**
*
* 通过给定的parent创建一个ClassPathXmlApplicationContext对象，将xml文件中的配置转换成bean对象
* Create a new ClassPathXmlApplicationContext with the given parent,
* loading the definitions from the given XML files.
* @param configLocations array of resource locations
* @param refresh whether to automatically refresh the context,
* loading all bean definitions and creating all singletons.
* Alternatively, call refresh manually after further configuring the context.
* @param parent the parent context
* @throws BeansException if context creation failed
* @see #refresh()
*/
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
// 调用父类构造方法，进行相关的对象创建等操作,包含属性的赋值操作
super(parent);
// 将给定的xml文件转成string(支持spEL表达式的解析)对象，保存在configLocations中
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
五、super(parent)源码跟踪
我们知道java中子类的创建必须先调用父类的构造方法，我们不断向上跟进，看看spring做了哪些事情
AbstractApplicationContext
跟进到父类AbstractApplicationContext中发现，该有参构造中主要做了两件事情
/**
* 主要做两件事情 1 调用无参构造创建资源模式处理器PathMatchingResourcePatternResolver
* 2 设置parent，此处为null,在springMVC中有扩展
* Create a new AbstractApplicationContext with the given parent context.
* @param parent the parent context
*/
public AbstractApplicationContext(@Nullable ApplicationContext parent) {
this();
setParent(parent);
}
/**
* 创建一个无父类的AbstractApplicationContext对象
* Create a new AbstractApplicationContext with no parent.
*/
public AbstractApplicationContext() {
// 创建资源模式处理器
this.resourcePatternResolver = getResourcePatternResolver();
}
protected ResourcePatternResolver getResourcePatternResolver() {
// 创建一个资源模式解析器(其实就是用来解析xml配置文件)
return new PathMatchingResourcePatternResolver(this);
}
DefaultResourceLoader
从AbstractApplicationContext继续向上跟进，进入DefaultResourceLoader的无参构造
/**
* 基于当前线程初始化类加载器
*/
public DefaultResourceLoader() {
this.classLoader = ClassUtils.getDefaultClassLoader();
}
@Nullable
public static ClassLoader getDefaultClassLoader() {
// 定义类加载器变量c1
ClassLoader cl = null;
try {
// 获取当前线程的上下文类加载器
cl = Thread.currentThread().getContextClassLoader();
}
catch (Throwable ex) {
// Cannot access thread context ClassLoader - falling back...
}
// 如果cl为null
if (cl == null) {
// No thread context class loader -> use class loader of this class.
// 没有线程上下文类加载器 -> 使用这个类的类加载器
// 获取ClassUtils的类加载器
cl = ClassUtils.class.getClassLoader();
// 如果c1还为null
if (cl == null) {
// getClassLoader() returning null indicates the bootstrap ClassLoader
// getClassLoader() 返回null表示boostrap ClassLoader
try {
// 获取系统的类加载器
cl = ClassLoader.getSystemClassLoader();
}
catch (Throwable ex) {
// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
}
}
}
return cl;
}
六、setConfigLocations(configLocations)源码跟踪
本方法主要功能在于将给定的xml文件转成string(支持spEL表达式的解析)对象，保存在configLocations中。其中有几个关键点需要注意
初始化环境对象
追踪该方法，发现调用了org.springframework.context.support.AbstractRefreshableConfigApplicationContext#resolvePath
/**
* 解析给定的xml路径，并将路径中的占位符使用环境变量替代
*/
protected String resolvePath(String path) {
return getEnvironment().resolveRequiredPlaceholders(path);
}
/**
* 查询Environment对象，如果有，则返回，如果没有，则创建（这里我们是第一次进来，environment为null,需要创建）
* 支持用户通过实现类，进行自定义扩展
* Return the {@code Environment} for this application context in configurable
* form, allowing for further customization.
* If none specified, a default environment will be initialized via
* {@link #createEnvironment()}.
*/
@Override
public ConfigurableEnvironment getEnvironment() {
if (this.environment == null) {
this.environment = createEnvironment();
}
return this.environment;
}
/**
* 系统默认创建并返回一个StandardEnvironment对象
* 支持用户通过实现类，进行自定义扩展
* Create and return a new {@link StandardEnvironment}.
* Subclasses may override this method in order to supply
* a custom {@link ConfigurableEnvironment} implementation.
*/
protected ConfigurableEnvironment createEnvironment() {
return new StandardEnvironment();
}
跟进StandardEnvironment的父类无参构造，查看
public AbstractEnvironment() {
customizePropertySources(this.propertySources);
}
发现调用了子类的customizePropertySources方法，我们这里是调用的StandardEnvironment的
/**
* 将系统中Java环境的属性资源添加到MutablePropertySources中
*/
@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
propertySources.addLast(
new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
propertySources.addLast(
new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}
自此，完成了环境对象StandardEnvironment的创建，并将系统资源保存在变量MutablePropertySources中，方便后续直接使用，下面是StandardEnvironment的类图
解析文件路径中的占位符
将上图中的getEnvironment().resolveRequiredPlaceholders(path)方法继续追踪resolveRequiredPlaceholders(path)方法，确认最终核心实现逻辑org.springframework.util.PropertyPlaceholderHelper#parseStringValue
/**
* 以递归的方式解析xml路径，进行占位符的解析，最终返回解析后的完整路径
*
*/
protected String parseStringValue(
String value, PlaceholderResolver placeholderResolver, @Nullable Set<String> visitedPlaceholders) {
int startIndex = value.indexOf(this.placeholderPrefix);
// 不包含占位符，则直接返回
if (startIndex == -1) {
return value;
}
StringBuilder result = new StringBuilder(value);
// 包含占位符，则进行解析，使用环境变量中的属性对占位符进行替代
while (startIndex != -1) {
int endIndex = findPlaceholderEndIndex(result, startIndex);
if (endIndex != -1) {
String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
String originalPlaceholder = placeholder;
if (visitedPlaceholders == null) {
visitedPlaceholders = new HashSet<>(4);
}
if (!visitedPlaceholders.add(originalPlaceholder)) {
throw new IllegalArgumentException(
"Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
}
// 递归调用，解析路径中的占位符
// Recursive invocation, parsing placeholders contained in the placeholder key.
placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
// Now obtain the value for the fully resolved key...
String propVal = placeholderResolver.resolvePlaceholder(placeholder);
if (propVal == null && this.valueSeparator != null) {
int separatorIndex = placeholder.indexOf(this.valueSeparator);
if (separatorIndex != -1) {
String actualPlaceholder = placeholder.substring(0, separatorIndex);
String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
if (propVal == null) {
propVal = defaultValue;
}
}
}
if (propVal != null) {
// 递归调用，解析路径中的占位符
// Recursive invocation, parsing placeholders contained in the
// previously resolved placeholder value.
propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
if (logger.isTraceEnabled()) {
logger.trace("Resolved placeholder '" + placeholder + "'");
}
startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
}
else if (this.ignoreUnresolvablePlaceholders) {
// Proceed with unprocessed value.
startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
}
else {
throw new IllegalArgumentException("Could not resolve placeholder '" +
placeholder + "'" + " in value \"" + value + "\"");
}
visitedPlaceholders.remove(originalPlaceholder);
}
else {
startIndex = -1;
}
}
return result.toString();
}
至此，spring工厂的准备工作完成，接下来将进入解析xml至bean初始化完成的核心流程。