spring源码学习-前戏- 如何从源码来看什么是IOC容器

之前一直想要找到一个学习spring源码的主线。看了《spring源码深度解析》这本书，效果不是很好，没有得到我想得到的。最终还是借助《spring技术内幕》这本书，抽丝剥茧，打开了思路。

我换一种方式来学习spring源码，走一个不一样的spring源码学习方式——从“农村包围城市”。

先理解里边的关键点，然后逐一击破，走一个星星之火可以燎原的学习道路。

不一样的spring源码学习方式——从“农村包围城市”。我把IOC作为学习spring源码的切入点。

采用归一的方法，不妨问题化繁为简，先不要想那么多，然后自顶而下的去梳理脉络，真的有轻松很多。

spring源码这一块，近期我会持续更新的~！这篇文章先梳理出来一个spring的脉络，后续在逐一展开分享。

 

第一个概念，就是IOC容器—— BeanFactory

首先说一下我对spring容器的理解，本身spring的设计之初，也是为了来管理复杂的类和对象关系，所以spring 的一个核心就是 IOC 容器。那么容器本身就是用来包裹 POJO对象的集装箱。 

BeanFactory 是一个接口，它声明了一个容器应该具备的最起码的功能。

其中包括了获取 容器的方法 getBean() 这是最最最重要的方法，通过它可以拿到我们想要的容器。还包括了判断容器是否存在的方法 constainsBean（）， 是否是单例的方法，是否是多例的方法，以及获取类的类型，获取到别名的方法。

 

 

第二个概念，FactoryBean ，看起来和 BeanFactory很像的东西

 FactoryBean也是一个接口，只有三个方法，一个是获取对象，第二个是获取对象的类型，第三个是判断对象是否是单例的。

至于两者的对应关系如下图所示，BeanFactory 是容器工厂， 而FactoryBean 是对象工厂。前者是用来管理容器的，后者是用来获取对象的。

 

BeanFactory 的一个非常重要的实现类 DefaultListableBeanFactory

可以说 DefaultListableBeanFactory 已经是一个默认完整的容器了，该有的功能基本上都有了（入股以人的进化史来比喻，此时容器经从猴子进化成人了，具备的容器的最初比较完整的形态）。根据这个图，其实已经可以作为阅读spring源码的切入点了。想要看懂spring源码就必须懂 IOC容器，想要懂IOC容器，不妨以这个图上的每个接口，和每个实现类，都做了什么来展开。我相信如果有耐心看完全部，IOC容器是什么，都包括什么功能，应该也能学到百分只八十了！（这里就不普及如何查看具体的某个接口和类的源码了）

这里分享一下学习方法，阅读spring源码，要化繁为简，自顶向下的去学习，这就是打开spring的切入点。为什么要自顶向下去阅读，spring是践行面向接口编程最好的一个框架技术了。顶层的接口，只定义了最简单的一些内容，读起来不是很吃力。

先把最基础的给拿下，然后再向下走，通过不断的增加接口（每个接口都是有单一的职责的），越是向下的类，继承的类和实现的接口越多（通过扩展接口的方式来增加功能）。在一个庞大的可扩展的框架里边，这是非常重要的。

 

第三个概念，ApplicationContext

  ApplicationContext  是进化后的容器的又一个新的时代的容器，就好猴子进化成人，人又学会了打造工具，最北最初的文明形态。同样下边的图中的接口，也是我们展开spring容器相关学习重要的点。

实现 ApplicationEventPublisher 接口，引入了事件的机制。

实现 ResourcePatternResolver 接口， 用来加载资源相关内容。

实现 HierarchicalBeanFactory 接口，提供父容器的访问功能.

DefaultListableBeanFactory 和 ApplicationContext 的区别就是，前者是一个纯粹的容器，而后者带有资源加载等模块。

再来看下applicationContext 都有什么

 

第四个概念，AbstractApplicationContext

 IOC容器的又一大进步，一个能拿的出手的IOC容器雏形。

看到文章这里的朋友可能会发现，如果按照我上边的流程走下来，用到的其实就几个接口了。这就是自顶向下学习建立知识体系的好处，思路清晰。

 AbstractApplicationContext 在这里主要是继承了 DefaultResourceLoader，使之具备了 ResourceLoader读入以Resource定义的BeanDefinition的能力。

 AbstractApplicationContext 实现了ConfigurableApplicationContext接口。在这个接口中中定义了一些基本操作，比如设置上下文ID，设置父应用上下文，添加监听器和刷新容器相关的操作等。

 

先看一个成熟的ApplicationContext 的案例

 ApplicationContext 是一个高级的容器，应为它带有资源的读取，对于不同类型的资源，有不同的实现。例如ClassPathXmlApplicationContext，从class path下读取配置文件的方式。 XmlWebApplicationContext 从web容器中加载资源。而这的FileSystemXmlApplicationContext 则是通过文件系统载入资源。

 

---

2021.3.23   1:00

又到凌晨一点了，该睡了，整理一下明天晚上要写的内容

 

容器的初始化过程

在上边的环节中，大概能够明白IOC容器是什么，都有哪些功能。

接下来一起看看容器是怎样一个初始化过程。

容器的初始化，其实就忙活了一件事，就是把Bean装到容器里边。但是这件事又是分为三个步骤来完成的：一是资源定位（ResourceLoader）；二是BeanDefinitiond载入的过程，就是把第一步加载到资源，转义成IOC容器内部的数据结构；三是通过BeanDefinitionRegister将BeanDefinition注册到IOC容器里边。在IOC容器里边，通过一个HashMap来存放BeanDefinition。

BeanDefinition 究竟是什么

 BeanDefinition 是对POJO对象的一个描述。

 

 容器初始化之 refresh（） 方法的来龙去脉

refresh（） 方法是容器启动的入口

该方法是在  ConfigurableApplicationContext 这个接口中被声明的，下图右下角可以看到。

 

该方法是在 AbstractApplicationContext 抽象类中被实现的，它作为一个模板方法，用到了模板方法模式，定义了初始化一个容器的算法骨架。

@Override
	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();
			}
		}

 BeanFactory 又是何时，在哪里被创建的呢？

 答案是  AbstractRefreshableApplicationContext 类的 refreshBeanFactory() 方法， 从下边的图上可以看到，AbstractRefreshableApplicationContext 是继承了 AbstractApplicationContext

 注意一种自顶向下的思路。一定要顺着脉络去学。

  refreshBeanFactory() 这个方法正是负责创建 BeanFactory的。

@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

 这段代码的主要逻辑就是，先看看有没有容器，如果有就销毁。如果没有就创建一个 DefaultListableBeanFactory 实例容器。

 到这里我们能够创建了 BeanFactory容器。同事有引入了另外应该问题，这个也是比较关键的，正是在这里使用了模板方法，引入了加载BeanDefinitions 的方法  loadBeanDefinitions(beanFactory); 继续点这个方法，我们在AbstractRefreshableApplicationContext 类里看到的是一个抽象方法，

protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
			throws BeansException, IOException;

   一直提到，spring是把单一职责运用到极致的一个优秀的框架。 此类的目的从名字上就能看出来，这是用来刷新 BeanFactory的，说是创建了BeanFactory 有些牵强，毕竟是如果有容器就先销毁。 创建好了BeanFactory以后，接下来就要load BeanDefinitions，根据单一职责，这个工作不应该在此类完成，所以定义成了抽象类，交给了子类去实现。 这里也是模板方法模式。这里这样做还有一个好处是方便扩展，因为你加载 BeanDefinition,还有一个好处，就是你可能有不用的方式来加载，这也预留了扩展和定制的空间。

 

BeanDefinition 是在哪里被加载的，源码在哪里

  其实想都不用想，我们想要看 BeanDefinition 也只能到 AbstractRefreshableApplicationContext的子类去看了。

 而AbstractRefreshableApplicationContext的子类只有这么几个，如下图：从名字不难看到，其中包含了 注解的方式，包括的文件系统的方式，包括了xml的方式。

 

 

而其中 真的实现了  loadBeanDefinitions 方法的只有画红线的子类。

 感兴趣的朋友可以点进去，看看每个的内容。我不准备在这篇文章中展开太多。

 这里只看一个 AbstractXmlApplicationContext 这个子类里边的 loadBeanDefinitions  方法

 如下代码，又引入了 资源加载者 reader。我们要清楚的知道，资源加载的工作是交给 Reader来完成的，并且这写资源有不同的形式：xml，注解，文件系统。不同形式的资源，只不过是对同一件事的不同描述方式。

@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 创建一个读xml类型的  DefinitionReader， 其实其他几个子类，这里是不一样的，通过xml和注解有不用的reader来处理。
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// 初始化 DefinitionReader
		initBeanDefinitionReader(beanDefinitionReader);
        // 将 beanDefinition 通过初始化好的 beanDefinitionReader 加载进来
		loadBeanDefinitions(beanDefinitionReader);
	}

 

 这里目前不准备展开太多关于  资源加载者 reader。后续可能要单独的出文章来分析。资源加载者 reader，主要做的工作，就是把我们写的配置文件也好，注解也好，这些对类的描述信息，给转化到 beanDefinition中。

 不过作为主线里边的内容，还是要列一下的，关于资源加载者 reader，具体的实现，如何把类的描述信息转化到 beanDefinition中的 ， 应该看AbstractBeanDefinitionReader 这个抽象类 子类。

 到这里结束，我们只知道资源被转换成了 beanDefinition，后续是要把这些入住到容器里边！

 

~ 这里留一个作业吧： 以后展开 ResourceLoader  beanDefinitionReader

 

BeanDefinition 加载到了哪里，如何存储的

 顺着上边的思路看到这里的话，应该比较清晰，BeanDefinition 是BeanFactory的内容，自然存在了BeanFactory里边， 这在 DefaultListableBeanFactory 类中有了定义，定义如下：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

 

BeanDefinition 注册到 BeanFactory

DefaultListableBeanFactory 实现了 BeanDefinitionRegistry接口， 然后在DefaultListableBeanFactory 类中进行了实现，代码比较简单，就是把 beanDefinition 放到 map里边。不过逻辑里边有一些判断，是否是重名的beanDefinition，如果是的话，需要判断该BeanDefinition是否允许被覆盖，如果允许则覆盖，如果不允许则报错。

 

容器的依赖注入问题

 依赖注入的入口是 AbstractBeanFactory 的 getBean() 方法

 

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

	@Override
	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
		return doGetBean(name, requiredType, null, false);
	}

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

 调用了 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;

		// 如果该 Bean是单例的，则先从单例池中取
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				if (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 实例，也就是bean对象
			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);
			}

			// 检查 bean definition 是否在 BeanFactory 中存在. 这里就比较重要了，如果当前BeanFactory不存在BeanDefinition，则继续从 parent BeanFactory中取尝试获取。直到获取到了BeanDefinition 如果最终一直没获取到，则报错，
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				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);
				}
			}

			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// 当前bean 依赖的 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);
						getBean(dep);
					}
				}

				// 如果是单例的，则执行下边的逻辑，创建单例的实例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							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, 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 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 && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

 

 

 

关注 createBean 方法，这个方法是在子类AbstractAutowireCapableBeanFactory中实现的

 

@Override
	@SuppressWarnings("unchecked")
	public <T> T createBean(Class<T> beanClass) throws BeansException {
		// Use prototype bean definition, to avoid registering bean as dependent bean.
		RootBeanDefinition bd = new RootBeanDefinition(beanClass);
		bd.setScope(SCOPE_PROTOTYPE);
		bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
		return (T) createBean(beanClass.getName(), bd, null);
	}

createBean

/**
	 * Central method of this class: creates a bean instance,
	 * populates the bean instance, applies post-processors, etc.
	 * @see #doCreateBean
	 */
	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("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 {
			// 让 BeanPostProcessors 执行，返回一个代理对象 
			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);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

 doCreateBean（），最终的创建 bean的代码

/**
	 * Actually create the specified bean. Pre-creation processing has already happened
	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
	 * <p>Differentiates between default bean instantiation, use of a
	 * factory method, and autowiring a constructor.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param args explicit arguments to use for constructor or factory method invocation
	 * @return a new instance of the bean
	 * @throws BeanCreationException if the bean could not be created
	 * @see #instantiateBean
	 * @see #instantiateUsingFactoryMethod
	 * @see #autowireConstructor
	 */
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		// bean对象.
		BeanWrapper instanceWrapper = null;
        // 如果是单例的，则尝试从单例池中去去单例对象
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
        // 单例池中没有拿到对象，则去创建对象
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		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.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// 依赖注入就是在这里完成的.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				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<String>(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;
	}

 

 这里边有两个关键的方法，createBeanInstance（）,和 populateBean(beanName, mbd, instanceWrapper)方法。

 看我的这篇文章 https://blog.csdn.net/star1210644725/article/details/115339866