流程预览
getBean(A),A调用完构造方法后,将A的工厂放入singletonFactories。属性需要注入B,B又需要注入A,又去getBean(A)时,调用了getSingleton1(),然后从工厂中获取并且提前代理了, 把提前代理好的放入earlyProxyReferences,这样B.A就注入好了。
B创建完,A的属性A.B也注入好了,A执行初始化方法,调用applyBeanPostProcessorsAfterInitialization的时候发现之前提前代理过了,所以不重复代理了。
而上面的逻辑其实是在getBean(A)
的doGetBean(A)
的getSingleton
的singletonFactory.getObject();
的createBean()
逻辑里,而在getSingleton
里,执行完getObject后,还有一个addSingleton(beanName, singletonObject);
,就是在这里添加到单例池中,并且从其他级中删除
什么叫循环依赖
A有属性B需要注入,B有属性A需要注入。
或者A有属性B,B有属性C,C有属性A
A BC B有A 然后创建C
循环依赖分析
别管几级map了,各个地方说法不一样
A有属性B,所以getBean(A)的时候又去getBean(B),但是因为B有属性A,又去getBean(A)的时候,我们应该能从单例池中直接拿到A(误)。
看似只有一个单例池就好了,即使没有属性注入,只要执行完构造函数就可以放入单例池中?B对象拿到就可以了?
但是A还没有创建完成,单例池必须是创建完的才能放入,所以我们需要另外一个map。
我们把map叫做earlySingletonObjects,存放早期对象或提前代理对象(即对象最新的)
isSingletonCurrentlyInCreation:一旦一个bean开始创建,那么就把他放入【正在创建集合isSingletonCurrentlyInCreation】中,直到最后一步再从【正在创建集合】中移除,放入单例池。这样我们就可以通过他判断是否需要提前代理(或者说还是第一次getBean这个类)
二级map可能是没有原始问题的,但是有动态代理的问题。
A有属性B,B有属性AC,C有属性A,他们都判断A需要被代理,而判断到A正在创建后他们都拿A的原始动态去包装代理,那BC都创建了各自的一个A代理对象。所以我们在判断到A需要进行AOP的时候,我们就提前进行AOP,然后返回他的代理对象放到earlySingletonObjects中。
如何提前代理?我们直接传入bean工厂,这个工厂就能帮我们创建代理对象,也可以创建普通bean,完全依赖于isSingletonCurrentlyInCreation
提前AOP的问题
提前AOP的时机:执行完构造函数就直接AOP吗?另外在最后AOP之前,判断一下是否提前进过AOP了,进行过了就不要重复AOP了
怎么判断有循环依赖:通过isSingletonCurrentlyInCreation且有切面 判断
提前AOP完能直接放到单例池吗?属性还是没有值,bean不完整。还是得在earlySingletonObjects中
所以我们应该再有个动态代理的map,getBean的时候先看是不是在创建中,然后判断
getBean
doGetBean
在这里面,首先调用了transformedBeanName给bean名字转了一个name
然后调用
Object sharedInstance = getSingleton(beanName);
注意我们有两个重载的getSingleton
// 1
getSingleton(String beanName, boolean allowEarlyReference);
// 2
getSingleton(String beanName, ObjectFactory<?> singletonFactory)
我们在这里调用的是第一个getSingleton
第一个getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1 检查单例池中是否有,拿不到
Object singletonObject = this.singletonObjects.get(beanName);
// 单例池中没有,是否在创建中?我们在这里还没有在这个集合中add过,所以也不在创建中,不进入if,返回null
if (singletonObject == null && //double check
isSingletonCurrentlyInCreation(beanName)) {
...;
}
return singletonObject;
回到了doGetBean
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 从这里退出来了
Object sharedInstance = getSingleton(beanName);
// 没拿到,进入else
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 如果是原型而正在创建中,我们不是,跳过
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 判断bd是否在工厂中
BeanFactory parentBeanFactory = getParentBeanFactory();
// 如果beanDefinitionMap中也就是在所有一级加载的类中不包括beanName则尝试从parentBeanFactory中检测
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
// 递归到beanFactory中寻找
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 在这里把当前bean名字添加到了
if (!typeCheckOnly) {
//把当前bean名字加入到集合alreadyCreated中
markBeanAsCreated(beanName);//内部是alreadyCreated.add(beanName);
}
try {
// 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition,如果指定beanName是子bean的话同时会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
// 先注册依赖的bean,这里不重点分析
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw ...;}
registerDependentBean(dep, beanName);// 缓存依赖调用
getBean(dep);
}
}
// 如果bean是单例的
if (mbd.isSingleton()) {
// 调用第二个getSingleton
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
//从这里进入getSingleton,并传入
@Override // getObject()里调用了createBean()
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
} catch (BeansException ex) {
。。。; }
}
});
// 同上
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}else if (mbd.isPrototype()) {
//多例的
我们看到从单例池中没拿到,也没在创建中,又看到bd是单例的,就去调用第二个getSingleton
,他的第二个参数利用lambda表达式传入了一个bean工厂,意思是一旦执行该bean工厂对象.getObject()
,就会调用createBean()
我们进入第二个getSingleton
放入singletonsCurrentlyInCreation
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName'不能为空");
// 锁住单例池
synchronized (this.singletonObjects) {
// 全局变量需要同步
// 从单例池中获取,拿不到
Object singletonObject = this.singletonObjects.get(beanName);
// 进入
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw("正在销毁异常")...;}
// 在里面把当前beanName加入到singletonsCurrentlyInCreation正在创建集合中
beforeSingletonCreation(beanName);
/* 看一下这个方法的源码
beforeSingletonCreation(beanName){
if (!this.inCreationCheckExclusions.contains(beanName) && // 判断当前需要创建的bean是否在Exclusions集合,被排除的bean,程序员可以提供一些bean不被spring初始化(哪怕被扫描到了,也不初始化),那么这些提供的bean便会存在这个集合当中;
!this.singletonsCurrentlyInCreation.add(beanName)) { //如果当前bean不在排除的集合当中那么则这个bean添加到(当然这里只是把bean名字添加到集合,为了方便我们直接认为把bean添加到集合吧,因为他能根据名字能找打对应的bean)
throw new BeanCurrentlyInCreationException(beanName);
}
}
*/
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
// getObject(),里面调用createBean()
singletonObject = singletonFactory.getObject();//工厂//调用传进来工厂的getObject()方法
createBean
//
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给实例化后置处理器一个返回代理对象的机会
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
}
// 前面后置处理器没有返回代理对象,我们创建正常的普通对象
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
doCreateBean
// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);// 移除缓存
}
if (instanceWrapper == null) {
// doCreateBean-1
// 仅仅完成了对象创建,剩下都没做 // 将bd转换成BeanWrapper
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从Wrapper中获取原始对象,这个时候这个bean就有地址值了,就能被引用了
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 和循环依赖无关
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 是否允许提前暴露,
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));// 在前面加进去了
// 进入
if (earlySingletonExposure) {
addSingletonFactory(beanName,
new ObjectFactory(){
public Object getObject() throws BeanException{
return getEarlyBeanReference(beanName, mbd, bean));
}
});
}
放入singletonFactories
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
// 锁住单例池
synchronized (this.singletonObjects) {
// 单例池中没有,进入
if (!this.singletonObjects.containsKey(beanName)) {
// 把传入的单例工厂放入singletonFactories
this.singletonFactories.put(beanName, singletonFactory);
// 本来也还没有,不用remove
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
可以发现虽然传入了单例工厂,并没有执行,只是放入了集合中singletonFactories。然后回到doCreateBean
属性注入
// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);// 移除缓存
}
if (instanceWrapper == null) {
// doCreateBean-1
// 仅仅完成了对象创建,剩下都没做 // 将bd转换成BeanWrapper
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从Wrapper中获取原始对象,这个时候这个bean就有地址值了,就能被引用了
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 和循环依赖无关
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 是否允许提前暴露,
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));// 在前面加进去了
// 进入
if (earlySingletonExposure) {
addSingletonFactory(beanName,
new ObjectFactory(){
public Object getObject() throws BeanException{
return getEarlyBeanReference(beanName, mbd, bean));
}
});
}
// 原始对象
Object exposedObject = bean;
try {
// 属性填充
populateBean(beanName, mbd, instanceWrapper);
属性填充,可想而已里面肯定又要有B的bean,所以去创建B,B又发现由依赖A,又去getBean(A)
//public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 又进入第一个getSingleton
Object sharedInstance = getSingleton(beanName);//重载getSingleton(beanName, true);//这时没有传入工厂
又一次getSingleton1
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
// 程序员一般从这个getSingleton中就能得到bean。但在注册容器的时候是拿不到的,除非有单例循环依赖
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 单例池中没有
Object singletonObject = this.singletonObjects.get(beanName);
// 进入if
if (singletonObject == null && //double check
isSingletonCurrentlyInCreation(beanName)) {
// 锁住单例池
synchronized (this.singletonObjects) {
// 2 从earlySingletonObjects中获取,我们还没放入锅,拿不到
singletonObject = this.earlySingletonObjects.get(beanName); // 循环依赖我们的最终目的是放到earlySingletonObjects里
// 在early中没拿到,去执行工厂的方法
if (singletonObject == null && allowEarlyReference) {
// 3 前面放入过singletonFactories,所以拿到了singletonFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用前面传入的工厂lambda函数的方法,主要是getEarlyBeanReference(beanName, mbd, bean));
singletonObject = singletonFactory.getObject();
// 执行完把代理对象或原生对象放入了earlySingletonObjects
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
提前代理getEarlyBeanReference
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
// 传入原始对象,经过代理后返回,无需代理就不代理返回
Object exposedObject = bean;
// 我们的后置处理器就是实现了该接口InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 遍历符合要求的后置处理器
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 找到动态代理的后置处理器
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
// 转换类型
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;//SmartInstantiationAwareBeanPostProcessor这个接口要求重写getEarlyBeanReference方法
// 拿到代理对象
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
// 返回代理对象
return exposedObject;
}
放入earlyProxyReferences
放入earlyProxyReferences并提前代理。如果没有代理过,就不会放入earlyProxyReferences。这个集合存放的是原生对象
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
public Object getEarlyBeanReference(Object bean, String beanName) {
// 用类和name组合一个key
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 放入集合
this.earlyProxyReferences.put(cacheKey, bean);
// 返回代理好的对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
提前代理放入earlySingletonObjects,移除singletonFactories
回到getSingleton1,提前代理的对象放入earlySingletonObjects。然后把singletonFactories移除
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1 单例池没有
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
// 锁住单例池
synchronized (this.singletonObjects) {
// 2 从earlySingletonObjects中获取,我们还没放入过,拿不到
singletonObject = this.earlySingletonObjects.get(beanName);
// 在early中没拿到,去执行工厂的方法
if (singletonObject == null && allowEarlyReference) {
// 3 前面放入过singletonFactories,所以拿到了singletonFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
// 进入
if (singletonFactory != null) {
// 调用前面传入的工厂lambda函数的方法,主要是getEarlyBeanReference(beanName, mbd, bean));
singletonObject = singletonFactory.getObject();
// 执行完把代理对象或原生对象放入了earlySingletonObjects
this.earlySingletonObjects.put(beanName, singletonObject);
// 从中singletonFactories移除
this.singletonFactories.remove(beanName);
}
}
}
}
// 返回提前代理好的对象
return singletonObject;
}
B.A属性注入好了。然后创建好了B(B的初始化流程没什么特别的,直接说A的初始化流程)
创建好了B,这样A的属性A.B也注入好了,开始执行A的初始化方法。
doCreateBean
// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);// 移除缓存
}
if (instanceWrapper == null) {
// doCreateBean-1
// 仅仅完成了对象创建,剩下都没做 // 将bd转换成BeanWrapper
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从Wrapper中获取原始对象,这个时候这个bean就有地址值了,就能被引用了
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 是否允许提前暴露,
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));// 在前面加进去了
// 进入,只是添加了个工厂,没有执行里面的方法
if (earlySingletonExposure) {
addSingletonFactory(beanName,
new ObjectFactory(){
public Object getObject() throws BeanException{
return getEarlyBeanReference(beanName, mbd, bean));
}
});
}
// A原始对象
Object exposedObject = bean;
try {
// 属性填充,我们执行完了
populateBean(beanName, mbd, instanceWrapper);
// doCreateBean-4 //调用初始化方法,如Aware、before-init后置处理器、init-method、after-init后置处理器
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}else {
//
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
initializeBean
调用before-init、init、after-init方法,前两个不分析了,基本都会执行,直接看最后一个
// AbstractAutowireCapableBeanFactory
protected Object initializeBean(final String beanName,
final Object bean,
@Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 调用before-init方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用init方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 调用after-init方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 看看早期代理引用里有没有,很明显,前面我们因为有循环依赖,该集合中有,所以不代理了,返回返回当前原始bean,这个原始bean会被代理使用
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
执行完init,回到doCreateBean
doCreateBean
// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);// 移除缓存
}
if (instanceWrapper == null) {
// doCreateBean-1
// 仅仅完成了对象创建,剩下都没做 // 将bd转换成BeanWrapper
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 从Wrapper中获取原始对象,这个时候这个bean就有地址值了,就能被引用了
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 是否允许提前暴露,
boolean earlySingletonExposure = (mbd.isSingleton() &&
this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));// 在前面加进去了
// 进入,只是添加了个工厂,没有执行里面的方法
if (earlySingletonExposure) {
addSingletonFactory(beanName,
new ObjectFactory(){
public Object getObject() throws BeanException{
return getEarlyBeanReference(beanName, mbd, bean));
}
});
}
// A原始对象
Object exposedObject = bean;
try {
// 属性填充,我们执行完了
populateBean(beanName, mbd, instanceWrapper);
// doCreateBean-4 //调用初始化方法,如Aware、before-init后置处理器、init-method、after-init后置处理器
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}else {
//
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 创建原始bean结束,进入
if (earlySingletonExposure) {
// 从earlySingletonObjects中获得了提前代理好的对象
Object earlySingletonReference = getSingleton(beanName, false);
// 进入
if (earlySingletonReference != null) {
// bean是原始对象,exposedObject是bean经过初始化之后的对象。
if (exposedObject == bean) {
//如果在本init方法中没有代理过,
// 要用exposedObject代表代理的对象,而earlySingletonReference恰好就是被提前代理对象的引用,所以拿他赋值即可
exposedObject = earlySingletonReference;
}
// 在本init方法中被代理过了
else if (!this.allowRawInjectionDespiteWrapping && // allowRawInjectionDespiteWrapping这个值默认是false
hasDependentBean(beanName)) {
// hasDependentBean:若它有依赖的bean 那就需要继续校验了~~~(若没有依赖的 就放过它~)
// 拿到它所依赖的Bean们~~~~ 下面会遍历一个一个的去看~~
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
// 一个个检查它所以Bean
// removeSingletonIfCreatedForTypeCheckOnly这个放见下面 在AbstractBeanFactory里面
// 简单的说,它如果判断到该dependentBean并没有在创建中的了的情况下,那就把它从所有缓存中移除~~~ 并且返回true
// 否则(比如确实在创建中) 那就返回false 进入我们的if里面~ 表示所谓的真正依赖
//(解释:就是真的需要依赖它先实例化,才能实例化自己的依赖)
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
// 若存在真正依赖,那就报错(不要等到内存移除你才报错,那是非常不友好的)
// 这个异常是BeanCurrentlyInCreationException,报错日志也稍微留意一下,方便定位错误~~~~
if (!actualDependentBeans.isEmpty()) {
throw new 。。。;
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 如论如何,要返回被代理的对象,而不是返回原始对象
return exposedObject;
}
getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 2 从earlySingletonObjects中获取
singletonObject = this.earlySingletonObjects.get(beanName);
// 拿到了代理对象,不进入了
if (singletonObject == null && allowEarlyReference) {
...;
}
}
}
// 返回提前代理好的对象
return singletonObject;
}
放入单例池getSingleton
在doGetBean的第二个getSingleton中,在他里面,会进addSingleton(beanName, singletonObject);
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 创建,也就是我们文中大部分篇幅写的逻辑,里面是createBean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 加入到单例池中,并且把别的里面的移除
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
getSingleton是在哪里被调用的呢?
doGetBean
//public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
// 递归到beanFactory中寻找
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 如果不是仅仅做类型检查则是创建bean,这里要做记录
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition,如果指定beanName是子bean的话同时会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
// 若存在依赖则需要递归实例化依赖的bean
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw ...;}
// 缓存依赖调用
registerDependentBean(dep, beanName);
getBean(dep);
}
}
//------------doGetBean-4------------ //创建单例bean实例
if (mbd.isSingleton()) {
// 判断当前bean是否单例
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
//从这里进入getSingleton,并传入
@Override // getObject()里调用了createBean()
public Object getObject() throws BeansException {
try {
// 注:循环依赖的①会执行这里,②也会,但③不会。但是在createBean里①和②返回地方也不一样
return createBean(beanName, mbd, args);//createBean创建 // 好了我们可以取下面第二个getSingleton里看了
}
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);
}else if (mbd.isPrototype()) {
//多例的
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}else {
//指定的scope上实例化bean
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw... ;}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw ...;}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查需要的类型是否符合bean的实际类型
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;//finish阶段直接return的有
}
总结
SmartInstantiationAwareBeanPostProcessor
这个类有点意思,他是一个后置处理器,并且里面有个方法是getEarlyBeanReference(),他就是说这个后置处理器可以提前提供代理
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
return wrapIfNecessary(bean, beanName, cacheKey);
}
三级缓存流程
A实例化的时候把bean工厂提前准备好,这样发生循环依赖就能用了
B填充A属性的时候发现在singletonsCurrentlyInCreation中,说明出现了循环依赖,A就去三级缓存中拿到bean工厂提前代理好,然后放到earlySingletonObjects中。全部执行完后,相当于getBean最后一步再放到单例池中
类提前代理怎么操作的?
关键在于wrapIfNecessary()这个方法
至此,循环依赖结束,而代理的细节还没说,下篇解释吧