源码分析：Spring是如何获取容器中的Bean？

素颜马尾好姑娘i 2022-12-16 09:27 128阅读 0赞

在上一篇《[源码分析：Spring是如何把Bean注册到IOC容器中的][Spring_Bean_IOC]》中我们分析了Bean是如何注册到容器中的，既然我们把Bean交给Spring来管理，在我们需要对象的时候Spring会自动帮我们注入，那Spring肯定会有一个从容器中获取Bean的过程，只不过这个过程是Spring框架来帮我们完成的，对于我们使用者来说没有感知

下面我们就通过源码来看一下Spring是如何从容器中获取Bean的

### 简单的例子 ###

首先还是从一个简单的例子来入手，XML配置方式我们一般这样获取Bean

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
    User user = (User) applicationContext.getBean("userBean");
    System.out.println(user.getUserName());

从上面的例子我们看到，Bean主要是applicationContext.getBean()方法来获取的，我们就从ClassPathXmlApplicationContext的getBean方法来入手

public Object getBean(String name) throws BeansException { 
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(name);
    	}

AbstractBeanFactory

public Object getBean(String name) throws BeansException { 
    		return doGetBean(name, null, null, false);
    	}

AbstractBeanFactory

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 
    
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// 从单例缓存中获取对象
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) { 
    			if (logger.isTraceEnabled()) { 
    				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 + "'");
    				}
    			}
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else { 
    			// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			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);
    				if (parentBeanFactory instanceof AbstractBeanFactory) { 
    					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
    							nameToLookup, requiredType, args, typeCheckOnly);
    				}
    				else if (args != null) { 
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else if (requiredType != null) { 
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    				else { 
    					return (T) parentBeanFactory.getBean(nameToLookup);
    				}
    			}
    
    			if (!typeCheckOnly) { 
    				markBeanAsCreated(beanName);
    			}
    
    			try { 
    			    //这里通过beanName获取相关信息来组装RootBeanDefinition
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// 当前Bean的依赖项
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) { 
    					for (String dep : dependsOn) { 
    						if (isDependent(beanName, dep)) { 
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						registerDependentBean(dep, beanName);
    						try { 
    							getBean(dep);
    						}
    						catch (NoSuchBeanDefinitionException ex) { 
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// 此处开始创建实例对象
    				//单例的对象创建
    				if (mbd.isSingleton()) { 
    					sharedInstance = getSingleton(beanName, () -> { 
    						try { 
    							return createBean(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);
    				}
                    //多例对象的创建
    				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 { 
    					String scopeName = mbd.getScope();
    					final Scope scope = this.scopes.get(scopeName);
    					if (scope == null) { 
    						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    					}
    					try { 
    						Object scopedInstance = scope.get(beanName, () -> { 
    							beforePrototypeCreation(beanName);
    							try { 
    								return createBean(beanName, mbd, args);
    							}
    							finally { 
    								afterPrototypeCreation(beanName);
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) { 
    						throw new BeanCreationException(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) { 
    					throw new BeanNotOfRequiredTypeException(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);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		return (T) bean;
    	}

doGetBean()方法基本上概括了整个Bean的获取过程

*  首先通过BeanName从容器中获取Bean相关的信息，并组装成RootBeanDefinition
 *  通过RootBeanDefinition来创建实例对象，这里需要根据单例、多例来分别进行创建
 *  将创建或者获取到的对象返回

### 组装RootBeanDefinition ###

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { 
    		// 先看看mergedBeanDefinitions中是否存在，实际上相当于缓存的作用
    		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    		if (mbd != null) { 
    			return mbd;
    		}
    		//请注意此处的第二个参数,传入的是一个BeanDefinition
    		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    	}

getBeanDefinition(beanName)方法返回的是一个BeanDefinition对象，我们来看一下

public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException { 
            //这里通过beanName从beanDefinitionMap中获取BeanDefination
    		BeanDefinition bd = this.beanDefinitionMap.get(beanName);
    		if (bd == null) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("No bean named '" + beanName + "' found in " + this);
    			}
    			throw new NoSuchBeanDefinitionException(beanName);
    		}
    		return bd;
    	}

getBeanDefinition()方法的作用就是从beanDefinitionMap中获取BeanDefinition，这里有没有很熟悉的感觉？如果你看过我另外一篇博文《[源码分析：Spring是如何把Bean注册到IOC容器中的？][Spring_Bean_IOC]》就会知道Bean在注册到容器中的时候，就是存入到beanDefinitionMap中，这里来进行获取，两边相当于对上了。

我们继续来看一下getMergedBeanDefinition()方法

protected RootBeanDefinition getMergedBeanDefinition(
    			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
    			throws BeanDefinitionStoreException { 
    
    		synchronized (this.mergedBeanDefinitions) { 
    			RootBeanDefinition mbd = null;
    
    			// Check with full lock now in order to enforce the same merged instance.
    			if (containingBd == null) { 
    			    //从缓存中获取RootBeanDefinition
    				mbd = this.mergedBeanDefinitions.get(beanName);
    			}
    
    			if (mbd == null) { 
    				if (bd.getParentName() == null) { 
    					// Use copy of given root bean definition.
    					if (bd instanceof RootBeanDefinition) { 
    						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
    					}
    					else { 
    					   //这里通过BeanDefinition来创建一个RootBeanDefinition
    						mbd = new RootBeanDefinition(bd);
    					}
    				}
    				else { 
    					// Child bean definition: needs to be merged with parent.
    					BeanDefinition pbd;
    					try { 
    						String parentBeanName = transformedBeanName(bd.getParentName());
    						if (!beanName.equals(parentBeanName)) { 
    							pbd = getMergedBeanDefinition(parentBeanName);
    						}
    						else { 
    							BeanFactory parent = getParentBeanFactory();
    							if (parent instanceof ConfigurableBeanFactory) { 
    								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
    							}
    							else { 
    								throw new NoSuchBeanDefinitionException(parentBeanName,
    										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
    										"': cannot be resolved without an AbstractBeanFactory parent");
    							}
    						}
    					}
    					catch (NoSuchBeanDefinitionException ex) { 
    						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
    								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
    					}
    					// Deep copy with overridden values.
    					mbd = new RootBeanDefinition(pbd);
    					mbd.overrideFrom(bd);
    				}
    
    				// 设置默认为单例
    				if (!StringUtils.hasLength(mbd.getScope())) { 
    					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
    				}
    
    				// A bean contained in a non-singleton bean cannot be a singleton itself.
    				// Let's correct this on the fly here, since this might be the result of
    				// parent-child merging for the outer bean, in which case the original inner bean
    				// definition will not have inherited the merged outer bean's singleton status.
    				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { 
    					mbd.setScope(containingBd.getScope());
    				}
    
    				//将构建好的RootBeanDefinition进行缓存
    				if (containingBd == null && isCacheBeanMetadata()) { 
    					this.mergedBeanDefinitions.put(beanName, mbd);
    				}
    			}
    
    			return mbd;
    		}
    	}

### 创建对象实例 ###

上面构造好了RootBeanDefinition，下面来创建对象

//单例对象的创建
    if (mbd.isSingleton()) { 
    					sharedInstance = getSingleton(beanName, () -> { 
    						try { 
    							return createBean(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);
    				}

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException { 
    
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Creating instance of bean '" + beanName + "'");
    		}
    		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);
    		}
    
    		try { 
    		    //根据beanName创建对象
    			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Finished creating instance of bean '" + beanName + "'");
    			}
    			return beanInstance;
    		}
    		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { 
    			// A previously detected exception with proper bean creation context already,
    			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
    			throw ex;
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(
    					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    		}
    	}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException { 
    
    		// 初始化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.
    		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;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Eagerly caching bean '" + beanName +
    						"' to allow for resolving potential circular references");
    			}
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// Initialize the bean instance.
    		Object exposedObject = bean;
    		try { 
    			populateBean(beanName, mbd, instanceWrapper);
    			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);
    			}
    		}
    
    		if (earlySingletonExposure) { 
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) { 
    				if (exposedObject == bean) { 
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) { 
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    					if (!actualDependentBeans.isEmpty()) { 
    						throw new BeanCurrentlyInCreationException(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.
    		try { 
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) { 
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    		}
    
    		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    		if (instanceSupplier != null) { 
    			return obtainFromSupplier(instanceSupplier, beanName);
    		}
    
    		if (mbd.getFactoryMethodName() != null) { 
    		    //使用FactotyMethod实例化Bean
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) { 
    			synchronized (mbd.constructorArgumentLock) { 
    				if (mbd.resolvedConstructorOrFactoryMethod != null) { 
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) { 
    			if (autowireNecessary) { 
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else { 
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// Preferred constructors for default construction?
    		ctors = mbd.getPreferredConstructors();
    		if (ctors != null) { 
    			return autowireConstructor(beanName, mbd, ctors, null);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		return instantiateBean(beanName, mbd);
    	}

上面可以看到，通过不同的方法进行Bean的实例化，有FactoryMethod、autowireConstructor、还有无参构造器，这里看一下通过FactoryMethod的实例化

protected BeanWrapper instantiateUsingFactoryMethod(
    			String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) { 
    
    		return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    	}

public BeanWrapper instantiateUsingFactoryMethod(
    			String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) { 
    
    		BeanWrapperImpl bw = new BeanWrapperImpl();
    		this.beanFactory.initBeanWrapper(bw);
    
    		Object factoryBean;
    		Class<?> factoryClass;
    		boolean isStatic;
            //获取FactoryBeanName
    		String factoryBeanName = mbd.getFactoryBeanName();
    		if (factoryBeanName != null) { 
    			if (factoryBeanName.equals(beanName)) { 
    				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    						"factory-bean reference points back to the same bean definition");
    			}
    			//从容器中获取factoryBean
    			factoryBean = this.beanFactory.getBean(factoryBeanName);
    			if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) { 
    				throw new ImplicitlyAppearedSingletonException();
    			}
    			//实例化factoryClass
    			factoryClass = factoryBean.getClass();
    			isStatic = false;
    		}
    		else { 
    			// It's a static factory method on the bean class.
    			if (!mbd.hasBeanClass()) { 
    				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    						"bean definition declares neither a bean class nor a factory-bean reference");
    			}
    			factoryBean = null;
    			factoryClass = mbd.getBeanClass();
    			isStatic = true;
    		}
    
    		Method factoryMethodToUse = null;
    		ArgumentsHolder argsHolderToUse = null;
    		Object[] argsToUse = null;
    
    		if (explicitArgs != null) { 
    			argsToUse = explicitArgs;
    		}
    		else { 
    			Object[] argsToResolve = null;
    			synchronized (mbd.constructorArgumentLock) { 
    				factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
    				if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) { 
    					// Found a cached factory method...
    					argsToUse = mbd.resolvedConstructorArguments;
    					if (argsToUse == null) { 
    						argsToResolve = mbd.preparedConstructorArguments;
    					}
    				}
    			}
    			if (argsToResolve != null) { 
    				argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
    			}
    		}
    
    		if (factoryMethodToUse == null || argsToUse == null) { 
    			// Need to determine the factory method...
    			// Try all methods with this name to see if they match the given arguments.
    			factoryClass = ClassUtils.getUserClass(factoryClass);
    
    			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
    			List<Method> candidateList = new ArrayList<>();
    			//过滤出工厂方法
    			for (Method candidate : rawCandidates) { 
    				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) { 
    					candidateList.add(candidate);
    				}
    			}
    
    			if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) { 
    				Method uniqueCandidate = candidateList.get(0);
    				if (uniqueCandidate.getParameterCount() == 0) { 
    					mbd.factoryMethodToIntrospect = uniqueCandidate;
    					synchronized (mbd.constructorArgumentLock) { 
    						mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
    						mbd.constructorArgumentsResolved = true;
    						mbd.resolvedConstructorArguments = EMPTY_ARGS;
    					}
    					//使用工厂方法创建实例对象
    					bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
    					return bw;
    				}
    			}
    
    			Method[] candidates = candidateList.toArray(new Method[0]);
    			AutowireUtils.sortFactoryMethods(candidates);
    
    			ConstructorArgumentValues resolvedValues = null;
    			boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
    			int minTypeDiffWeight = Integer.MAX_VALUE;
    			Set<Method> ambiguousFactoryMethods = null;
    
    			int minNrOfArgs;
    			if (explicitArgs != null) { 
    				minNrOfArgs = explicitArgs.length;
    			}
    			else { 
    				// We don't have arguments passed in programmatically, so we need to resolve the
    				// arguments specified in the constructor arguments held in the bean definition.
    				if (mbd.hasConstructorArgumentValues()) { 
    					ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    					resolvedValues = new ConstructorArgumentValues();
    					minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    				}
    				else { 
    					minNrOfArgs = 0;
    				}
    			}
    
    			/************因代码太长，略过很多代码******************************* }

private Object instantiate(String beanName, RootBeanDefinition mbd,
    			@Nullable Object factoryBean, Method factoryMethod, Object[] args) { 
    
    		try { 
    			if (System.getSecurityManager() != null) { 
    				return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    						this.beanFactory.getInstantiationStrategy().instantiate(
    								mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
    						this.beanFactory.getAccessControlContext());
    			}
    			else { 
    			    //创建实例对象
    				return this.beanFactory.getInstantiationStrategy().instantiate(
    						mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
    			}
    		}
    		catch (Throwable ex) { 
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Bean instantiation via factory method failed", ex);
    		}
    	}

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Object factoryBean, final Method factoryMethod, Object... args) { 
    
    		try { 
    			if (System.getSecurityManager() != null) { 
    				AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    					ReflectionUtils.makeAccessible(factoryMethod);
    					return null;
    				});
    			}
    			else { 
    				ReflectionUtils.makeAccessible(factoryMethod);
    			}
    
    			Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
    			try { 
    				currentlyInvokedFactoryMethod.set(factoryMethod);
    				//这里使用反射调用工厂方法，生成对象并返回
    				Object result = factoryMethod.invoke(factoryBean, args);
    				if (result == null) { 
    					result = new NullBean();
    				}
    				return result;
    			}
    			finally { 
    				if (priorInvokedFactoryMethod != null) { 
    					currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
    				}
    				else { 
    					currentlyInvokedFactoryMethod.remove();
    				}
    			}
    		}
    		catch (IllegalArgumentException ex) { 
    			throw new BeanInstantiationException(factoryMethod,
    					"Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
    					"args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
    		}
    		catch (IllegalAccessException ex) { 
    			throw new BeanInstantiationException(factoryMethod,
    					"Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
    		}
    		catch (InvocationTargetException ex) { 
    			String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
    			if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
    					((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) { 
    				msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
    						"declaring the factory method as static for independence from its containing instance. " + msg;
    			}
    			throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
    		}
    	}

使用反射调用工厂方法，生成对象并返回，返回对象就表示从容器中根据注册的Bean信息拿到了具体的对象，到此整个调用链路都完成了。

我原本以为是在调用getBean()时才去进行Bean的实例化，但是在断点跟踪的过程中，发现单例对象实际上是在容器启动的时候就会去实例化，getBean()的时候直接拿，不用再实例化。代码如下：

public void refresh() throws BeansException, IllegalStateException { 
    		synchronized (this.startupShutdownMonitor) { 
    			// Prepare this context for refreshing.
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// Prepare the bean factory for use in this context.
    			prepareBeanFactory(beanFactory);
    
    			try { 
    				// Allows post-processing of the bean factory in context subclasses.
    				postProcessBeanFactory(beanFactory);
    
    				// Invoke factory processors registered as beans in the context.
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// Register bean processors that intercept bean creation.
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				initApplicationEventMulticaster();
    
    				// Initialize other special beans in specific context subclasses.
    				onRefresh();
    
    				// Check for listener beans and register them.
    				registerListeners();
    
    				// Instantiate all remaining (non-lazy-init) singletons.
    				finishBeanFactoryInitialization(beanFactory);
    
    				// Last step: publish corresponding event.
    				finishRefresh();
    			}
    
    			catch (BeansException ex) { 
    				if (logger.isWarnEnabled()) { 
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				// Destroy already created singletons to avoid dangling resources.
    				destroyBeans();
    
    				// Reset 'active' flag.
    				cancelRefresh(ex);
    
    				// Propagate exception to caller.
    				throw ex;
    			}
    
    			finally { 
    				// Reset common introspection caches in Spring's core, since we
    				// might not ever need metadata for singleton beans anymore...
    				resetCommonCaches();
    			}
    		}
    	}

在refresh()方法中有专门进行单例初始化的方法，就是finishBeanFactoryInitialization(beanFactory)，从注释可以看出来就是用来做单例的实例化的

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
    		// Initialize conversion service for this context.
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { 
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		// Register a default embedded value resolver if no bean post-processor
    		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
    		// at this point, primarily for resolution in annotation attribute values.
    		if (!beanFactory.hasEmbeddedValueResolver()) { 
    			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    		}
    
    		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) { 
    			getBean(weaverAwareName);
    		}
    
    		// Stop using the temporary ClassLoader for type matching.
    		beanFactory.setTempClassLoader(null);
    
    		// Allow for caching all bean definition metadata, not expecting further changes.
    		beanFactory.freezeConfiguration();
    
    		// 实例化单例对象
    		beanFactory.preInstantiateSingletons();
    	}

public void preInstantiateSingletons() throws BeansException { 
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Pre-instantiating singletons in " + this);
    		}
    
    		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    		// Trigger initialization of all non-lazy singleton beans...
    		for (String beanName : beanNames) { 
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { 
    				if (isFactoryBean(beanName)) { 
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					if (bean instanceof FactoryBean) { 
    						final FactoryBean<?> factory = (FactoryBean<?>) bean;
    						boolean isEagerInit;
    						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { 
    							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
    											((SmartFactoryBean<?>) factory)::isEagerInit,
    									getAccessControlContext());
    						}
    						else { 
    							isEagerInit = (factory instanceof SmartFactoryBean &&
    									((SmartFactoryBean<?>) factory).isEagerInit());
    						}
    						if (isEagerInit) { 
    							getBean(beanName);
    						}
    					}
    				}
    				else { 
    				    //从这里可以看出来，单例的实例化是通过调用getBean方法来实现的
    					getBean(beanName);
    				}
    			}
    		}
    
    		// Trigger post-initialization callback for all applicable beans...
    		for (String beanName : beanNames) { 
    			Object singletonInstance = getSingleton(beanName);
    			if (singletonInstance instanceof SmartInitializingSingleton) { 
    				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				if (System.getSecurityManager() != null) { 
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else { 
    					smartSingleton.afterSingletonsInstantiated();
    				}
    			}
    		}
    	}

从上面的代码可以看出来，容器在启动的时候就会实例化单例对象，并且还是调用的getBean()方法做的实例化，当你从容器中获取Bean的时候，就直接取现成的对象了

protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
            //从singletonObjects中获取已经实例化好的对象
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    			synchronized (this.singletonObjects) { 
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				if (singletonObject == null && allowEarlyReference) { 
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) { 
    						singletonObject = singletonFactory.getObject();
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}

以上就是从容器中获取单例Bean的过程，多例也是差不多的过程，就不再赘述，有兴趣可以自己研究一下

### 总结一下 ###

Spring从容器中获取Bean的过程如下：

*  首先通过BeanName从容器中获取Bean相关的信息，并组装成RootBeanDefinition
 *  通过RootBeanDefinition来创建实例对象，这里需要根据单例、多例来分别进行创建
 *  单例对象是容器启动的时候就已经实例化好了，可以直接拿来用，当然你也可以设置延迟加载

> 如果感觉对你有些帮忙，请收藏好，你的关注和点赞是对我最大的鼓励！  
> 如果想跟我一起学习，坚信技术改变世界，请关注【Java天堂】公众号，我会定期分享自己的学习成果，第一时间推送给您

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B6anRpYW4_size_16_color_FFFFFF_t_70_pic_center]

[Spring_Bean_IOC]: https://blog.csdn.net/pzjtian/article/details/108763681
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B6anRpYW4_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/4ed2b77fcad746ff880d5194d2bcd8cd.png