protected<T>TdoGetBean(String name,@NullableClass<T> requiredType,@NullableObject[] args,boolean typeCheckOnly)throwsBeansException{//获取beanName(不带&符号的beanName)String beanName =transformedBeanName(name);Object bean;// Eagerly check singleton cache for manually registered singletons.//从缓存中获取 解决循环依赖的地方Object sharedInstance =getSingleton(beanName);if(sharedInstance !=null&& args ==null){if(logger.isTraceEnabled()){//如果当前bean正在创建中则抛出异常if(isSingletonCurrentlyInCreation(beanName)){
logger.trace("Returning eagerly cached instance of singleton bean '"+ beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else{
logger.trace("Returning cached instance of singleton bean '"+ beanName +"'");}}//获取FactoryBean工厂对象(不是获取getObject()方法返回值)// 1. 如果 sharedInstance 是普通的 Bean 实例,则下面的方法会直接返回// 2. 如果 sharedInstance 是工厂Bean类型,则需要获取 getObject 方法,可以参考关于 FactoryBean 的实现类
bean =getObjectForBeanInstance(sharedInstance, name, beanName,null);}else{// Fail if we're already creating this bean instance:// We're assumably within a circular reference.//当前bean正在创建,则抛出异常// 循环依赖有三种,setter注入、多实例和构造函数,Spring 只能解决 setter 注入,所以这里是 Prototype 则会抛出异常if(isPrototypeCurrentlyInCreation(beanName)){thrownewBeanCurrentlyInCreationException(beanName);}// Check if bean definition exists in this factory.//获取父容器BeanFactory parentBeanFactory =getParentBeanFactory();if(parentBeanFactory !=null&&!containsBeanDefinition(beanName)){//当前容器中不存在,则从父容器中获取// Not found -> check parent.//如果beanName中带& 则返回 & + beanName 否则返回原始beanNameString nameToLookup =originalBeanName(name);if(parentBeanFactory instanceofAbstractBeanFactory){return((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);}//参数不为空 调用不同父容器方法获取bean实例elseif(args !=null){// Delegation to parent with explicit args.return(T) parentBeanFactory.getBean(nameToLookup, args);}elseif(requiredType !=null){// No args -> delegate to standard getBean method.return parentBeanFactory.getBean(nameToLookup, requiredType);}else{return(T) parentBeanFactory.getBean(nameToLookup);}}//否仅是做类型检查if(!typeCheckOnly){//标记bean 已被创建markBeanAsCreated(beanName);}try{//从容器 getMergedLocalBeanDefinition 获取 beanName 对应的 GenericBeanDefinition,转换为 RootBeanDefinitionRootBeanDefinition mbd =getMergedLocalBeanDefinition(beanName);//检查当前bean是否未抽象类checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.//获取依赖 注入到当前bean的中的beanString[] dependsOn = mbd.getDependsOn();if(dependsOn !=null){for(String dep : dependsOn){//检查是否循环相互依赖了if(isDependent(beanName, dep)){thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '"+ beanName +"' and '"+ dep +"'");}//将依赖注入到当前bean中registerDependentBean(dep, beanName);try{//获取依赖的beangetBean(dep);}catch(NoSuchBeanDefinitionException ex){thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"'"+ beanName +"' depends on missing bean '"+ dep +"'", ex);}}}// Create bean instance.//判断当前bean是单例的if(mbd.isSingleton()){//beanName ObjectFactory匿名内部类 传入 作为 以后的回调//放到三级缓存中
sharedInstance =getSingleton(beanName,()->{try{returncreateBean(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);}elseif(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{String scopeName = mbd.getScope();if(!StringUtils.hasLength(scopeName)){thrownewIllegalStateException("No scope name defined for bean ´"+ beanName +"'");}Scope scope =this.scopes.get(scopeName);if(scope ==null){thrownewIllegalStateException("No Scope registered for scope name '"+ scopeName +"'");}try{Object scopedInstance = scope.get(beanName,()->{beforePrototypeCreation(beanName);try{returncreateBean(beanName, mbd, args);}finally{afterPrototypeCreation(beanName);}});
bean =getObjectForBeanInstance(scopedInstance, name, beanName, mbd);}catch(IllegalStateException ex){thrownewBeanCreationException(beanName,"Scope '"+ scopeName +"' is not active for the current thread; consider "+"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);}}}catch(BeansException ex){cleanupAfterBeanCreationFailure(beanName);throw ex;}}// Check if required type matches the type of the actual bean instance.//类型转换if(requiredType !=null&&!requiredType.isInstance(bean)){try{T convertedBean =getTypeConverter().convertIfNecessary(bean, requiredType);if(convertedBean ==null){thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}return convertedBean;}catch(TypeMismatchException ex){if(logger.isTraceEnabled()){
logger.trace("Failed to convert bean '"+ name +"' to required type '"+ClassUtils.getQualifiedName(requiredType)+"'", ex);}thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}}return(T) bean;}
protectedObjectgetSingleton(String beanName,boolean allowEarlyReference){// Quick check for existing instance without full singleton lock//首先从一级缓存中获取beanObject singletonObject =this.singletonObjects.get(beanName);//如果一级缓存中没有并且当前bean正在创建中if(singletonObject ==null&&isSingletonCurrentlyInCreation(beanName)){//则从二级缓存中获取
singletonObject =this.earlySingletonObjects.get(beanName);//如果二级缓存中没有并且已允许依赖引用if(singletonObject ==null&& allowEarlyReference){//对一级缓存加锁synchronized(this.singletonObjects){// Consistent creation of early reference within full singleton lock//再次从一级缓存中获取
singletonObject =this.singletonObjects.get(beanName);//如果还是没有if(singletonObject ==null){//则再次从二级缓存中获取
singletonObject =this.earlySingletonObjects.get(beanName);//如果二级缓存中还是空if(singletonObject ==null){//则从三级缓存中获取ObjectFactory<?> singletonFactory =this.singletonFactories.get(beanName);if(singletonFactory !=null){//调用getObject()方法返回bean
singletonObject = singletonFactory.getObject();//这时bean是半成品 则放入二级缓存中this.earlySingletonObjects.put(beanName, singletonObject);//从三级缓存中移除this.singletonFactories.remove(beanName);}}}}}}return singletonObject;}
AbstractBeanFactory#getObjectForBeanInstance()方法
protectedObjectgetObjectForBeanInstance(Object beanInstance,String name,String beanName,@NullableRootBeanDefinition mbd){// Don't let calling code try to dereference the factory if the bean isn't a factory.//判断是name前缀是&if(BeanFactoryUtils.isFactoryDereference(name)){if(beanInstance instanceofNullBean){return beanInstance;}if(!(beanInstance instanceofFactoryBean)){thrownewBeanIsNotAFactoryException(beanName, beanInstance.getClass());}}// Now we have the bean instance, which may be a normal bean or a FactoryBean.// If it's a FactoryBean, we use it to create a bean instance, unless the// caller actually wants a reference to the factory.if(!(beanInstance instanceofFactoryBean)||BeanFactoryUtils.isFactoryDereference(name)){//如果beanName带& 则直接返回当前bean 也就是FactoryBean实现类return beanInstance;}//如果beanName不带& 则调用FactoryBean.getObject()方法返回beanObject object =null;if(mbd ==null){//从缓存给中获取
object =getCachedObjectForFactoryBean(beanName);}if(object ==null){// Return bean instance from factory.FactoryBean<?> factory =(FactoryBean<?>) beanInstance;// Caches object obtained from FactoryBean if it is a singleton.if(mbd ==null&&containsBeanDefinition(beanName)){
mbd =getMergedLocalBeanDefinition(beanName);}boolean synthetic =(mbd !=null&& mbd.isSynthetic());//获取getObject方法返回的真正的对象
object =getObjectFromFactoryBean(factory, beanName,!synthetic);}return object;}