Spring IOC（五）BeanFactory.getBean 方法分析

Spring 容器帮程序管理Bean，而实际上最终是由BeanFactory 管理的，本文就具体分析getBean方法。

重载方法

Spring 提供以下方法获取bean实例，当然大同小异：

getBean

以传入 classType为例，当调用 getBean:204, AbstractBeanFactory，进入 AbstractBeanFactory 的 getBean 方法：

	@Override
	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
		// 第三个参数为 参数，第四个为是否检查
		return doGetBean(name, requiredType, null, false);
	}

看具体 doGetBean 方法

doGetBean

该方法目的是获取一个bean实例具体实现。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		// 获取bean名称
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 尝试检查，该名称bean是否已经创建过
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
		// 不为空，那么就说明有循环依赖（circular reference），并且说明可能是不完整的。
			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类型，从而判断是否返回。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 再一次判断，是否在循环引用，如果是，那么就立即失败
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 首先回去父类里面找
			// 判断该bean定义，是否真存在与该BeanFactory
			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) {
				// 将其加入到 alreadyCreated中，说明正在创建。bean从 mergedBeanDefinitions 中暂时去除，以免再次创建。
				markBeanAsCreated(beanName);
			}

			try {
			// 从当前类中获取BeanDefinition。
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 判断当前bean 类，是否为抽象类，是就报错。
				checkMergedBeanDefinition(mbd, beanName, args);

				// 获取depensOn，即需要有该类。
				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 + "'");
						}
						// 注册并放入dependentBeanMap 中
						registerDependentBean(dep, beanName);
						try {
						// 优先获取 dependon的bean
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// 单例模式
				if (mbd.isSingleton()) {
				// 单例模式下获取，传入beanName
					sharedInstance = getSingleton(beanName, () -> {
						try {
						// 创建bean
							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()) {
					// 原型模式，即每次都创建
					Object prototypeInstance = null;
					try {
					 // 直接创建新bean
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					// 包装
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
				// 其他模式
					String scopeName = mbd.getScope();
					// 获取bean名称
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
					// 调用scope.get，而还是由createBean去创建bean
						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;
			}
		}

		// 在一次检查是否匹配，不匹配则报错。
		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;
	}

获取bean名称transformedBeanName，会分析是否以 & 从而为获取beanfactory 实例。
在 getSingleton 中看是否已经创建过时，会分析是否由于循环引用而导致先创建或者正在创建，具体存储在DefaultSingletonBeanRegistry的 singletonsCurrentlyInCreation。最后会返回具体是否由于循环依赖相关信息。
再一次判断是否在创建中，在就立即报错。
如果有父 BeanFactory，会首先去父BeanFactory 中寻找。
如果typeCheckOnly = true 其加入到 alreadyCreated中，说明正在创建。bean从 mergedBeanDefinitions 中暂时去除，以免再次创建
在获取BeanDefinition 过程中，首先会从 getMergedLocalBeanDefinition 去获取，而它主要从 mergedBeanDefinitions 获取。而在第五步中，可能被remove了，所以会再尝试从 beanDefinitionMap，再获取不到就会报错。最后，又会把获取到的BeanDefinition 重新放到 mergedBeanDefinitions 中。
初始化bean时，会校验 DependOn 类，如果有两个类，相互DependOn，则会报错。如果有且检查通过，则会将其放入HashSet的 dependentBeanMap中：而value为 LinkedHashSet 类型。并先会去获取其依赖想dep。即要先把依赖项获取。
接下来，通过判断Spring bean的 scope类型去创建，Spring Bean Scope有以下几种类型：

singleton 在Spring的IoC容器中只存在一个对象实例，所有该对象的引用都共享这个实例。默认为此类型
prototype 每次http请求将会有各自的bean实例，类似于prototype。
当然，在Spring MVC中，则可能有其他多种类型
request 每次http请求将会有各自的bean实例，类似于prototype。
session 在一个http session中，一个bean定义对应一个bean实例。
global session 在一个全局的http session中，一个bean定义对应一个bean实例。典型情况下，仅在使用portlet context的时候有效。
当然，也可以自己实现 org.springframework.beans.factory.config.Scope，自定义的作用域。

单例和原型模式区别，在於单例会首先进入 getSingleton 方法，并且将 createBean方法传入，而在 getSingleton 则会进行相应的检查。
单例模式可以理解为一种自定义Scope，最终都是同样调用方法及步骤。

getSingleton

获取单例的bean：

通过调用 singletonFactory 中具体接口方法创建并初始化bean实例
创建前后一些资源占有和释放工作。具体可以结合后面两节看。

	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 {
					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;
		}
	}

在创建完最后，会将已有单例实例放入相应变量中，便于程序从 BeanFactory 中获取：

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

beforePrototypeCreation

具体方法声明为： public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)。

	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) {
				// 判断当前BeanFactory是否处于destory状态。
					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;
		}
	}

首先会对当前单例加锁，默认Spring的单例配置有

systemEnvironment Map
enviroment StandardEnvironment
systemProperties Properties

在创建之前，执行 beforeSingletonCreation 会再一次检查，会判断是否在 inCreationCheckExclusions 创建，并且会放入 singletonsCurrentlyInCreation 中。
当执行玩createBean回调后，会在final块执行 afterSingletonCreation 将2中锁占用状态清除。

createBean

看具体的创建bean的代码，以下代码包含三部分逻辑：

创建bean实例
实例化bean
执行所有 post-processor 例子

	@Override
	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;
		// 获取bean类
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			// 填充进 beanClass中
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}
		// 校验 override 方法
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// 给一个机会 给 InstantiationAwareBeanPostProcessor，即是否自定义bean 生成过程。
			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 {
		// 执行 doCreateBean 创建。
			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);
		}
	}

校验 beanClass 并填充。
校验 override 方法，即如果判断 overloaded 中具体 override 数量。
执行 resolveBeforeInstantiation ，即当 beanFactory 中有 InstantiationAwareBeanPostProcessor 时，可以通过InstantiationAwareBeanPostProcessor 返回bean实例

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// 判断该beandefinition 不是 jvm生成，并且有 InstantiationAwareBeanPostProcessor.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
				// 执行所有的 postProcessBeforeInstantiation
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
					// 执行所有的 postProcessAfterInitialization
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

如果3中没有创建成功，则会通过 doCreateBean 创建。

doCreateBean

具体的创建逻辑，都在 doCreateBean 中了。

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// 初始化beanWrapper
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
		// 先从 factoryBeanInstanceCache 移除该beanName。
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
		// 创建 实例
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// 执行所有的 `MergedBeanDefinitionPostProcessor`，允许其修改`beanDefinition`
		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;
			}
		}
		// 提前缓存单例对象，来解决循环依赖问题，即当前bean没有初始化，只是实例化了。
		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));
		}

		// 实例化bean实例。
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			// 完成实例化bean后其他逻辑，例如 填入 相关系统参数 aware，执行所有 postProcessAfterInitialization 方法
			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;
	}

检查完 BeanWrapper 后，则会进入 createBeanInstance 创建具体bean实例
执行所有的 MergedBeanDefinitionPostProcessor，允许其修改beanDefinition
提前缓存单例对象，来解决循环依赖问题，即当前bean没有初始化，只是实例化了。
执行 populateBean 以完成bean实例化，其中@Autowired 等注入参数解析就在这里。
完成实例化bean后其他逻辑，例如填入相关系统参数 aware，执行配置的init 方法，执行所有 postProcessAfterInitialization 方法，如果bean为InitializingBean 类型，则会执行其 afterPropertiesSet 方法
判断是否为 DisposableBean（停止是回调用），是则需要建立回调。

createBeanInstance

具体选择性调用构造方法创建BeanInstance过程

	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 获取bean 类
		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) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}
		// 加锁，判断是否在构造方法初有 需要autowired的
		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);
			}
		}

		//  判断构造方法是否需要 通过 SmartInstantiationAwareBeanPostProcessor 获取。
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 看是否有配置 构造方法
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// 使用默认无参构造方法.
		return instantiateBean(beanName, mbd);
	}

获取beanClass以及校验其合法性
判断是否有专属提供者方法InstanceSupplier，有就直接通过其构建
判断是否有工厂方法，若有则从工厂方法中获取。
判断构造方法，是否需要注入 @Autowired，需要则先注入而后再构建。
以默认构造方法兜底处理去生成。

afterPrototypeCreation

这个比较简单，和方法 beforeSingletonCreation 相呼应，分别为释放和占有资源。

	protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}

本文有以下几个问题，大家可以先好好思考：

@Autowired 具体实例过程
FactoryBean 类型如何初始化，最后一个方法 getObjectForBeanInstance 作用？
Spring 中循环依赖具体解决

觉得博主写的有用，不妨关注博主公众号: 六点A君。
哈哈哈，一起研究Spring：

Spring IOC（五）BeanFactory.getBean 方法分析

重载方法

getBean

doGetBean

getSingleton

beforePrototypeCreation

createBean

doCreateBean

createBeanInstance

afterPrototypeCreation

Spring IOC(三): refresh 分析 invokeBeanFactoryPostProcessors 過程

Mybatis 主鍵回顯 KeyGenerator原理

Mybatis 攔截器及 PageHelper分析

Mybatis的 SqlSessionFactory 初始化過程和SqlSession 初始化過程

Spring IOC（四）ConfigurationClassPostProcessor 用法分析

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結