@SuppressWarnings("unchecked")//真正实现向IOC容器获取Bean的功能,也是触发依赖注入功能的地方protected<T> T doGetBean(final String name,@Nullablefinal Class<T> requiredType,@Nullablefinal Object[] args,boolean typeCheckOnly)throws BeansException {//根据指定的名称获取被管理Bean的名称,剥离指定名称中对容器的相关依赖//如果指定的是别名,将别名转换为规范的Bean名称final String beanName =transformedBeanName(name);
Object bean;// Eagerly check singleton cache for manually registered singletons.//先从缓存中取是否已经有被创建过的单态类型的Bean//对于单例模式的Bean整个IOC容器中只创建一次,不需要重复创建
Object sharedInstance =getSingleton(beanName);//IOC容器创建单例模式Bean实例对象if(sharedInstance != null && args == null){if(logger.isDebugEnabled()){//如果指定名称的Bean在容器中已有单例模式的Bean被创建//直接返回已经创建的Beanif(isSingletonCurrentlyInCreation(beanName)){
logger.debug("Returning eagerly cached instance of singleton bean '"+ beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else{
logger.debug("Returning cached instance of singleton bean '"+ beanName +"'");}}//获取给定Bean的实例对象,主要是完成FactoryBean的相关处理//注意:BeanFactory是管理容器中Bean的工厂,而FactoryBean是//创建创建对象的工厂Bean,两者之间有区别
bean =getObjectForBeanInstance(sharedInstance, name, beanName, null);}else{// Fail if we're already creating this bean instance:// We're assumably within a circular reference.//缓存没有正在创建的单例模式Bean//缓存中已经有已经创建的原型模式Bean//但是由于循环引用的问题导致实例化对象失败if(isPrototypeCurrentlyInCreation(beanName)){thrownewBeanCurrentlyInCreationException(beanName);}// Check if bean definition exists in this factory.//对IOC容器中是否存在指定名称的BeanDefinition进行检查,首先检查是否//能在当前的BeanFactory中获取的所需要的Bean,如果不能则委托当前容器//的父级容器去查找,如果还是找不到则沿着容器的继承体系向父级容器查找
BeanFactory parentBeanFactory =getParentBeanFactory();//当前容器的父级容器存在,且当前容器中不存在指定名称的Beanif(parentBeanFactory != null &&!containsBeanDefinition(beanName)){// Not found -> check parent.//解析指定Bean名称的原始名称
String nameToLookup =originalBeanName(name);if(parentBeanFactory instanceofAbstractBeanFactory){return((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);}elseif(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已经被创建markBeanAsCreated(beanName);}try{//根据指定Bean名称获取其父级的Bean定义//主要解决Bean继承时子类合并父类公共属性问题final RootBeanDefinition mbd =getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.//获取当前Bean所有依赖Bean的名称
String[] dependsOn = mbd.getDependsOn();//如果当前Bean有依赖Beanif(dependsOn != null){for(String dep : dependsOn){if(isDependent(beanName, dep)){thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '"+ beanName +"' and '"+ dep +"'");}//递归调用getBean方法,获取当前Bean的依赖BeanregisterDependentBean(dep, beanName);//把被依赖Bean注册给当前依赖的BeangetBean(dep);}}// Create bean instance.//创建单例模式Bean的实例对象if(mbd.isSingleton()){//这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象
sharedInstance =getSingleton(beanName,()->{try{//创建一个指定Bean实例对象,如果有父级继承,则合并子类和父类的定义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.//显式地从容器单例模式Bean缓存中清除实例对象destroySingleton(beanName);throw ex;}});//获取给定Bean的实例对象
bean =getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}//IOC容器创建原型模式Bean实例对象elseif(mbd.isPrototype()){// It's a prototype -> create a new instance.//原型模式(Prototype)是每次都会创建一个新的对象
Object prototypeInstance = null;try{//回调beforePrototypeCreation方法,默认的功能是注册当前创建的原型对象beforePrototypeCreation(beanName);//创建指定Bean对象实例
prototypeInstance =createBean(beanName, mbd, args);}finally{//回调afterPrototypeCreation方法,默认的功能告诉IOC容器指定Bean的原型对象不再创建afterPrototypeCreation(beanName);}//获取给定Bean的实例对象
bean =getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}//要创建的Bean既不是单例模式,也不是原型模式,则根据Bean定义资源中//配置的生命周期范围,选择实例化Bean的合适方法,这种在Web应用程序中//比较常用,如:request、session、application等生命周期else{
String scopeName = mbd.getScope();final Scope scope =this.scopes.get(scopeName);//Bean定义资源中没有配置生命周期范围,则Bean定义不合法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的实例对象
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.//对创建的Bean实例对象进行类型检查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.isDebugEnabled()){
logger.debug("Failed to convert bean '"+ name +"' to required type '"+
ClassUtils.getQualifiedName(requiredType)+"'", ex);}thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());}}return(T) bean;}
//真正创建Bean的方法protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final@Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.//封装被创建的Bean对象
BeanWrapper instanceWrapper = null;if(mbd.isSingleton()){
instanceWrapper =this.factoryBeanInstanceCache.remove(beanName);}if(instanceWrapper == null){//根据指定bean 使用对应的策略创建新的实例,如工厂方法,构造函数自动注入,简单初始化
instanceWrapper =createBeanInstance(beanName, mbd, args);}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.//调用PostProcessor后置处理器// MergedBeanDefinitionPostProcessor 应用 Autowired注解正是通过此方法实现诸如类型的预解析synchronized(mbd.postProcessingLock){if(!mbd.postProcessed){try{applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch(Throwable ex){thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}
mbd.postProcessed =true;}}// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.//向容器中缓存单例模式的Bean对象,以防循环引用 --》是否需要提早曝光。boolean earlySingletonExposure =(mbd.isSingleton()&&this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if(earlySingletonExposure){if(logger.isDebugEnabled()){
logger.debug("Eagerly caching bean '"+ beanName +"' to allow for resolving potential circular references");}//这里是一个匿名内部类,为了防止循环引用,尽早持有对象的引用// 为避免后期的循环依赖,可以在初始化完成前将创建实例的ObjectFactory加入工厂。addSingletonFactory(beanName,()->getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.//Bean对象的初始化,依赖注入在此触发//这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean
Object exposedObject = bean;try{//将Bean实例对象封装,并且Bean定义中配置的属性值赋值给实例对象populateBean(beanName, mbd, instanceWrapper);//初始化Bean对象
exposedObject =initializeBean(beanName, exposedObject, mbd);}catch(Throwable ex){if(ex instanceofBeanCreationException&& beanName.equals(((BeanCreationException) ex).getBeanName())){throw(BeanCreationException) ex;}else{thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Initialization of bean failed", ex);}}if(earlySingletonExposure){//获取指定名称的已注册的单例模式Bean对象
Object earlySingletonReference =getSingleton(beanName,false);// earlySingletonReference 只有在检测到有循环依赖的情况下才会不为空。if(earlySingletonReference != null){//根据名称获取的已注册的Bean和正在实例化的Bean是同一个,exposedObject 没有被增强。if(exposedObject == bean){//当前实例化的Bean初始化完成
exposedObject = earlySingletonReference;}//当前Bean依赖其他Bean,并且当发生循环引用时不允许新创建实例对象elseif(!this.allowRawInjectionDespiteWrapping &&hasDependentBean(beanName)){
String[] dependentBeans =getDependentBeans(beanName);
Set<String> actualDependentBeans =newLinkedHashSet<>(dependentBeans.length);//获取当前Bean所依赖的其他Beanfor(String dependentBean : dependentBeans){//对依赖Bean进行类型检查if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
actualDependentBeans.add(dependentBean);}}//因为bean创建后,其所依赖的bean 一定是已经创建的// actualDependentBeans不为空,表示当前bean 创建后其所依赖的bean 却没有全部创建完,就是说存在循环依赖。if(!actualDependentBeans.isEmpty()){thrownewBeanCurrentlyInCreationException(beanName,"Bean with name '"+ beanName +"' has been injected into other beans ["+
StringUtils.collectionToCommaDelimitedString(actualDependentBeans)+"] in its raw version as part of a circular reference, but has eventually been "+"wrapped. This means that said other beans do not use the final version of the "+"bean. This is often the result of over-eager type matching - consider using "+"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.//注册完成依赖注入的Beantry{// 根据scope注册beanregisterDisposableBeanIfNecessary(beanName, bean, mbd);}catch(BeanDefinitionValidationException ex){thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Invalid destruction signature", ex);}return exposedObject;}
Spring bean的加载AbstractBeanFactory#doGetBeandoGetBean才是真正向IoC容器获取被管理Bean的过程AbstractAutowireCapableBeanFactory#doCreateBean真正创建bean//获取IOC容器中指定名称的Bean @Override public Object getBean(String n...