前言
今天开始跟大家一起进入spring源码阅读阶段,我们将从一个大家比较熟悉的高级容器-ClassPathXmlApplicationContext为入口去了解spring容器的加载过程。
IOC容器的加载
ClassPathXmlApplicationContext有许多构造函数,我们找到真的调用的入口。
public ClassPathXmlApplicationContext(String[] paths, Class<?> clazz, @Nullable ApplicationContext parent)
throws BeansException {
//加载容器前的一些处理
super(parent);
Assert.notNull(paths, "Path array must not be null");
Assert.notNull(clazz, "Class argument must not be null");
this.configResources = new Resource[paths.length];
for (int i = 0; i < paths.length; i++) {
this.configResources[i] = new ClassPathResource(paths[i], clazz);
}
//真正开始加载容器的方法
refresh();
}
这个构造函数中,我们只需要关注最后一个方法refresh(),这个才是容器加载的入口,下面我们跟进去看下具体的内容。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//刷新容器前的预处理,包括删除旧容器等
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 创建bean工厂
// 加载解析XML文件,并完成BeanDefinition的加载和注册
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);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// 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.
// 实例化剩余的单例bean(非懒加载方式)
// Bean的IoC、DI和AOP都是发生在这个过程中
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
。。。。。
}
spring容器的加载有多个步骤,我们主要关系里面的两个步骤
- obtainFreshBeanFactory():该方法主要是创建springBean工厂,同时加载xml配置文件,将配置文件中的bean标签,解析成一个个BeanDefinition对象,并注册到spring容器中
- finishBeanFactoryInitialization(beanFactory):该方法是实例化spring中非懒加载的单例bean,同时spring中的依赖注入和产生代理对象都是在这个过程中完成的。
而剩余的其他步骤,主要初始哈一些BeanPostProcessor,然括对BeanDefinition的一些处理,初始化一些特殊的bean,然后注册监听器,最后广播加载完成的消息等一些功能。这些功能分支,大家有兴趣的可以自己进行了解,在这里就不一一详细说明了。今天,我们主要是来看springBean的加载,及初始化流程。也就是,我们主要看finishBeanFactoryInitialization该方法完成的内容。
下面我们就接着看finishBeanFactoryInitialization这个方法到底完成了些什么事情:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
。。。。。。。。。
// Instantiate all remaining (non-lazy-init) singletons.
// 完成单例Bean的初始化
beanFactory.preInstantiateSingletons();
}
这个方法前面的一些内容我们并不需要太多关注,我们看到方法最后,这个preInstantiateSingletons()就是实例化我们单例bean的入口:
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("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...
// 加载所有非懒加载方式的单例bena
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 { // 普通bean走下面的方法
getBean(beanName);
}
}
}
我们来一步步看下这个方法
- 便利所有的beanName,然后从BeanDefinition集合中获取到对应的BeanDefinition对象
- 接着判断该对象如果不是抽象类,是个单例对象,不是懒加载方式的就进入执行if()下面的代码
- 接着判断如果这个bean是个特殊的工厂bean,就执行对应的方法。
- 最后就是加载普通的bean
接着我们顺着getBean方法往下点,最终会来到AbstractBeanFactory中真正创建bean的doCreateBean方法
这里面的代码很长,在这里我们就不贴出来了,大家跟着我的思路往下看就可以了 *
Object sharedInstance = getSingleton(beanName);
首先我们看到句代码,这个其实是从spring的缓存容器中获取bean对象,spring容器中一共有三层缓存,一级缓存就是存放spring加载完成的bean对象。而二三级缓存主要是为了解决spring中的循环依赖这个问题(这个问题比较重要,我们后面会在具体的说明这个问题)。
// 从一级缓存也就是map容器中获取对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从二级缓存中尝试获取单例bean
singletonObject = this.earlySingletonObjects.get(beanName);
// allowEarlyReference
//是否允许从三级缓存中获取对象就是是否允许循环依赖
if (singletonObject == null && allowEarlyReference) {
//尝试从三级缓存中获取单例bean
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//通过单例工厂获取单例bean
singletonObject = singletonFactory.getObject();
//将bean放到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
//将bean从三级缓存中删除
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
这个就是获取单例bean的过程,其中三级缓存中存放的是bean的工厂对象。
接着我们继续看doCreateBean下面的代码
- 接着就是判断是否获取到了bean对象,如果获取到的是一个Factory对象,就产生对应的bean实例
- 如果没有获取到bean对象,就进入else去创建该bean对象
- 接着就看到我们最主要的创建单例bean的方法
if (mbd.isSingleton()) {
sharedInstance = getSingletion(beanName, () -> {
try {
// 创建单例Bean的主要方法
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;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 这个方法中用了lamda表达式,大家可以直接点进去getSingleton这个方法中。 里面的方法很长我们主要先关注这两句代码
singletonObject = singletonFactory.getObject();
newSingleton = true;
这个getObject()方法真正的实现是之前的这个createBean(beanName, mbd, args); 这个方法是真正去创建一个bean的方法。这个我们等下在看。 这个getSingletion方法的最后就是将创建好的bean加入到map容器中,同时删除二三级缓存
addSingleton(beanName, singletonObject);
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
// 加入到一级缓存
this.singletonObjects.put(beanName, singletonObject);
// 删除三级缓存
this.singletonFactories.remove(beanName);
// 删除二级缓存
this.earlySingletonObjects.remove(beanName);
// 将beanName加入到已经创建的beanName集合中
this.registeredSingletons.add(beanName);
}
}
现在我们就去看下最后一个creatBean这个创建bean的方法
。。。。
try {
// 完成Bean实例的创建包括-实例化,依赖注入(填充属性值),初始化(调用初始化方法)
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
。。。
里面我们关注这个doCreateBean(),我们接着往下找,终于来到了具体创建bean的代码,这代码有点长,我们截取一些片段
// Instantiate the bean.
。。。
//1. 实例化bean对象
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//实例化后的Bean对象
。。。。。
// 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));
// 为解决循环依赖提前暴露单例Bean,将该Bean放入三级缓存中
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 把刚创建的bean放入三级缓存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 属性填充也就是DI的过程
populateBean(beanName, mbd, instanceWrapper);
//调用初始化方法,完成初始化操作
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
。。。。。。。
return exposedObject;
这里面主要可以分成三步
- 实例化单例Bean,且将单例bean放入二级缓存
- 进行bean的属性填充
- 对bean进行初始化,就是调用初始化方法完成bean的初始化操作
结语
至此,我们已经看完了springIOC的主要加载流程,我们主要对bean的创建过程进行了解读,知道了bean是如何创建出来并加入到容器中。而这里也剩下一个循环依赖的问题,及属性填充的过程我们还没有进行理解和阅读,这两个问题我们留到下面的文章为大家讲解,希望大家多多关注,谢谢阅读。