本篇分析Spring如何加载bean的实例,
从ClassPathXmlApplicationContext的getBean开始分析
//抽象方法
Object getBean(String var1) throws BeansException;
public Object getBean(String name) throws BeansException {
this.assertBeanFactoryActive();
return this.getBeanFactory().getBean(name);
}
会进入BeanFactory接口的getBean,根据继承图找到AbstractApplicationContext的getBean方法
上篇文章Spring IOC实现原理笔记(二) – 加载XML配置提过,ClassPathXmlApplicationContext中的BeanFactory成员实际是DefaultListableBeanFactory
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = this.transformedBeanName(name);
//【标记1】尝试获取
Object sharedInstance = this.getSingleton(beanName);//
Object bean;
if(sharedInstance != null && args == null) {
...
//返回对应的实例,有时候存在诸如BeanFactory的情况并不是直接返回实例本身
//而是返回指定方法返回的实例
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
//原型模式(Prototype)下存在循环依赖,不能解决(因为原型模式是直接创建新的实例的)
if(this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
...如果父BeanFactory不为空,并且当前没有相应bean的
BeanDefinition,那就交由父BeanFactory加载bean,并返回。
if(!typeCheckOnly) {
this.markBeanAsCreated(beanName);//标志当前bean已经创建
}
try {
//将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition
final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if(dependsOn != null) {
for(String dependsOnBean:dependsOn) {
String dependsOnBean = var11[var13];
if(this.isDependent(beanName, dependsOnBean)) {
...说明有循环依赖,要报异常(构造方法注入循环依赖)
}
//这里记录要创建的依赖的bean,用于循环依赖检测
this.registerDependentBean(dependsOnBean, beanName);
//递归实例化依赖的bean
this.getBean(dependsOnBean);
}
}
if(mbd.isSingleton()) {//单例模式
//【标记2】
sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
//【标记3】
return this.createBean(beanName, mbd, args);//真正创建实例
} catch (BeansException var2) {
this.destroySingleton(beanName);
throw var2;
}
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else ...省略其他模式
} catch (BeansException var23) {
this.cleanupAfterBeanCreationFailure(beanName);
throw var23;
}
}
if(requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
//对应类型的转换
return this.getTypeConverter().convertIfNecessary(bean, requiredType);
...
} else {
return bean;
}
}
获取bean实例时,首先尝试获取单例(对应上面【标记1】)
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//尝试从缓存池中获取
Object singletonObject = this.singletonObjects.get(beanName);
if(singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
//获取不到,但正在创建
synchronized(this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
//如果此bean不是正在加载且允许提前引用
if(singletonObject == null && allowEarlyReference) {
//当某些方法需要提前初始化的时候,会调用addSingletonFactory方法,
//将对应的ObjectFactory初始化策略存储在singletonFactories
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if(singletonFactory != null) {
//调用预设定的getObject方法
singletonObject = singletonFactory.getObject();
//记录缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject != NULL_OBJECT?singletonObject:null;
}
获取单例bean:(对应【标记2】)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
...
synchronized(this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if(singletonObject == null) {
...
//把beanName放入singletonsCurrentlyInCreation
this.beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = this.suppressedExceptions == null;
if(recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet();
}
try {
//调用工厂的getObject方法获取实例
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch ...
} finally {
...
//把beanName从singletonsCurrentlyInCreation移除
this.afterSingletonCreation(beanName);
}
if(newSingleton) {
this.addSingleton(beanName, singletonObject);
}
}
return singletonObject != NULL_OBJECT?singletonObject:null;
}
}
//把beanName缓存到singletonsCurrentlyInCreation,对应的isSingletonCurrentlyInCreation方法会返回true
protected void beforeSingletonCreation(String beanName) {
if(!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
//把beanName从singletonsCurrentlyInCreation移除
protected void afterSingletonCreation(String beanName) {
if(!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
ObjectFactory工厂的getObject方法实现调用的是createBean方法(对应【标记3】)
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
...
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if(resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
...
//验证及准备覆盖的方法
mbdToUse.prepareMethodOverrides();
...
Object beanInstance;
...
//给BeanPostProcessors(需要是InstantiationAwareBeanPostProcessor的实例)机会返回代理来代替真正的实例(AOP实现就用这)
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if(beanInstance != null) {
return beanInstance;
}
...
//真正创建bean实例
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
...
return beanInstance;
}
真正创建bean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) {
BeanWrapper instanceWrapper = null;
if(mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if(instanceWrapper == null) {
//【标记4】根据指定bean使用对应的策略创建新的实例,如工厂方法,构造函数自动注入,简单初始化
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
Class<?> beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
synchronized(mbd.postProcessingLock) {
if(!mbd.postProcessed) {
//应用MergedBeanDefinitionPostProcessor
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
//是否需要提早曝光:单例&允许循环依赖&当前bean正在创建中,检查循环依赖
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if(earlySingletonExposure) {
...
//为避免后期循环依赖,可以在bean初始化完成前将创建实例的ObjectFactory工厂加入工厂
this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
//对bean再一次依赖应用,主要应用SmartInstantiationAwareBeanPostProcessor
//AOP就是在这里将advice动态织入bean中,没有就直接返回bean,不做处理
return this.getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
//【标记5】对bean进行填充,将各个属性值注入,其中可能存在依赖于其他bean的属性,则会递归初始依赖的bean
this.populateBean(beanName, mbd, instanceWrapper);
if(exposedObject != null) {
//【标记6】调用初始化方法,如init-method,InitializingBean的afterPropertiesSet
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
}
} catch...
if(earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
//只有在检测到有循环依赖的情况下才会不会空
if(earlySingletonReference != null) {
if(exposedObject == bean) {
//没有在初始化方法中被改变(即没有被增强)
exposedObject = earlySingletonReference;
} else if(!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
for(String dependentBean:dependentBeans) {
//检测依赖,bean实例化后,其依赖的bean也需要被实例化
if(!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if(!actualDependentBeans.isEmpty()) {
...存在循环依赖
}
}
}
}
try {
//根据scope注册bean
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch ...
}
单例的循环依赖解决:如果是在构造函数循环依赖那解决不了;如果是通过setter方法的循环依赖,那会调addSingletonFactory加入一个ObjectFactory,其getObject实现会返回一个实例引用来解决循环依赖
根据指定bean使用对应的策略创建新的实例(对应【标记4】)
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if(beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
...非公开类
} else if(mbd.getFactoryMethodName() != null) {
//如果工厂方法不为空则使用工厂方法初始化策略
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
if(args == null) {
synchronized(mbd.constructorArgumentLock) {
//一个类有多个构造函数,每个构造函数都有不同的参数,所以调用前根据参数锁定构造函数或对应的工厂方法
if(mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
//如果已经解析过则使用解析好的构造函数
if(resolved) {
//autowireNecessary为true则用构造函数自动注入,否则使用默认构造函数构造
return autowireNecessary?this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null):this.instantiateBean(beanName, mbd);
} else {
//根据参数解析构造函数
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//ctors为空就用默认构造函数,否则使用用构造函数自动注入
return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)?this.instantiateBean(beanName, mbd):this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
根据参数解析构造函数逻辑很复杂,因为有很多不确定性;而使用默认构造方法实例化则会分两种情况:第一种,beanDefinition的getMethodOverrides方法返回空(即没有使用replace或lookup配置),那就直接使用反射。第二种,使用CGlib进行动态代理,覆盖或动态替换方法
上面实例化的bean,接着就是对bean进行属性填充,看populateBean方法(对用【标记5】)
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
if(bw == null) {
if(!((PropertyValues)pvs).isEmpty()) {
...空对象不能填充属性
}
} else {
//给InstantiationAwareBeanPostProcessors最后一次机会在属性设置前改变bean
boolean continueWithPropertyPopulation = true;
if(!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator it = this.getBeanPostProcessors().iterator();
while(it.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)it.next();
if(bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
if(!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
//continueWithPropertyPopulation为true,说明InstantiationAwareBeanPostProcessors没有中断属性注入
if(continueWithPropertyPopulation) {
if(mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
//根据名称自动注入
if(mbd.getResolvedAutowireMode() == 1) {
this.autowireByName(beanName, mbd, bw, newPvs);
}
//根据类型自动注入
if(mbd.getResolvedAutowireMode() == 2) {
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
//依赖检查
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
if(hasInstAwareBpps || needsDepCheck) {
//调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if(hasInstAwareBpps) {
Iterator it = this.getBeanPostProcessors().iterator();
while(it.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)it.next();
if(bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
pvs = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if(pvs == null) {
return;
}
}
}
}
if(needsDepCheck) {
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
}
//将属性应用到bean中
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
填充好bean的属性后,会调用initializeBean方法会对各种aware等接口进行调用(对应【标记6】)
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
...
this.invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
if(mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessors的postProcessBeforeInitialization
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//调用init-method,InitializingBean的afterPropertiesSet
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch...
if(mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessors的postProcessAfterInitialization
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
Spring IOC实现原理笔记(一)这篇中的例子输出结果可以在从上面里验证了
大致总结bean实例的加载流程:
• 尝试从单例缓存池中取,成功的话返回进行实际需要的实例(如在beanName前加&可以得到该bean的beanFactory)
• 单例缓存池取不到则进行实例化,需要判断能否解决循环引用,不同的scope不同地生命周期。
• 进行实例化前,如果工厂方法不为空则使用工厂方法初始化策略;否则可以通过InstantiationAwareBeanPostProcessor来实例化(AOP借此实现),如果InstantiationAwareBeanPostProcessor返回实例化对象不为空那就直接返回。
• InstantiationAwareBeanPostProcessor没返回实例,则继续进行bean实例操作,解析构造函数,用其进行反射实例化或CGlib代理实例化
• 实例化后,对实例进行属性填充,填充前还会最后一次交由InstantiationAwareBeanPostProcessor决定是否继续填充,
• 填充完属性,还会让InstantiationAwareBeanPostProcessor进行属性检验,接着就进行对各种Aware接口,init-method等进行调用
• 最后注册DisposeableBean,用户可通过配置属性destroy-method方法后之策后处理器DestructAwareBeanPostProcessor来统一处理bean的销毁方法
参考:
Spring源码(4.2.2.RELEASE)
《Spring源码深度解析》