流程预览
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的时候先看是不是在创建中，然后判断
重申3级map的作用
- singletonObjects：这个无需讲，就是单例吃
- earlySingletonObjects：这个一般都为空，只有代理过了才不为空，也就是说他存放的是代理对象
- singletonFactory：它提供了把原生对象代理的方法，要发生代理的话通过它的getObject()就生成代理对象了，生成之后放入earlySingletonObjects中就可以了
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名字添加到了集合alreadyCreated中
if (!typeCheckOnly) {
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));// 在前面加进去了
// 允许提交暴露，就放入singletonFactory中，只不过这个factory是返回代理对象用的
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中获取，我们还没放入过，拿不到（放入的是singletonFactory）
singletonObject = this.earlySingletonObjects.get(beanName); // 循环依赖我们的最终目的是放到earlySingletonObjects里
// 在early中没拿到，去执行工厂的方法
if (singletonObject == null && allowEarlyReference) {
// 3 前面放入过singletonFactories，所以拿到了singletonFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用前面传入的工厂lambda函数的方法，getObject()里有getEarlyBeanReference(beanName, mbd, bean));所以发生了代理
singletonObject = singletonFactory.getObject();
// 执行完把代理对象或原生对象放入了earlySingletonObjects
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
至此我们知道earlySingletonObjects放入了代理对象，这个单词的early代表的是早点放入代理，而非原生对象
提前代理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;
}
上面有一个getEarlyBeanReference(exposedObject, beanName);就是发生代理的地方，我们取看看
放入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);
}
我们不细究了， 我们到这里知道代理好了就行，然后我们回到getSingleton1
提前代理放入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);
}
}
在init方法中要发生代理，因为已经代理过了，所以得在里面判断一下，判断代理过了在init中就不代理了，防止重复代理
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中获得了提前代理好的对象 // getSingleton1
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()这个方法
至此，循环依赖结束，而代理的细节还没说，下篇解释吧
3087
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
