Spring源码分析之Bean加载（一）_cached instance of singleton bean "logingcontrolle-CSDN博客

本文链接：https://blog.csdn.net/a1047003619/article/details/103619386

本篇文章主要介绍bean加载的过程，详细过程请关注本系列博客。本系列博客的Spring版本为4.3.25
对于bean的加载功能，在Spring中的调用方式为

bf.getBean("beanName");

Spring中的源码为，实际调用了doGet()方法

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

doGet()方法源码

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
        //(1)转化对应的beanName
		//提取对应beanName
		final String beanName = transformedBeanName(name);
		Object bean;

		//(2)尝试从缓存中加载实例
		/**
		 * 检查缓存或者实例工厂中是否有对应的实例
		 * 在创建单例bean的时候会存在依赖注入的情况，在创建依赖的时候为了避免循环依赖
		 * spring创建bean的原则不等bean创建完成就会将创建bean的ObjectFactory提早曝光
		 * 也就是将ObjectFactory加入到缓存中，一旦下一个bean创建时候依赖上一个bean则直接使用ObjectFactory
		 */
		// Eagerly check singleton cache for manually registered singletons.
		// 直接尝试从缓存获取或者从singletonFactories中的ObjectFactory中获取
		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 + "'");
				}
			}
			//（3）bean的实例化
			// 返回对应的实例
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// (4)原型模式的依赖检查
			// 检查循环依赖
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			// （5）检测parentBeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 如果beanDefinitionMap中也就是在所有已加载的类中不包括beanName则尝试从parentBeanFactory中检测
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				// 递归到BeanFactory中寻找
				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);
				}
			}

			// 如果不是仅仅做类型检查则是创建bean，这里进行记录
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
				// （6）将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// （7）寻找依赖
				String[] dependsOn = mbd.getDependsOn();
				// 若存在依赖则需要递归实例化依赖的bean
				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);
						}
					}
				}

				// （8）针对不同的scope进行bean的创建
				// Create bean instance.
				// Singleton模式的创建
				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.
					// Prototype模式的创建
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					// 指定的scope上的实例化bean
					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;
			}
		}

		//（9）类型转换
		// Check if required type matches the type of the actual bean instance.
		// 检查需要的类型是否符合bean的实际类型
		if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
			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;
	}

从源码可以看出bean的加载过程相当复杂，其大致步骤为：

转换对应的beanName
将传入参数解析为真正的beanName，传入的name可能是别名也可能是FactoryBean。解析的内容包括
（1）去除FactoryBean的修饰符。
（2）解析alias的最终beanName，
尝试从缓存中加载单例
单例在Spring的同一容器内只会被创建一次，后续再获取bean，就直接从单例缓存中获取。当然这里只是尝试加载，如果加载不成功则再次从singletonFactories中加载。因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免依赖注入的情况，在Spring中创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入缓存中，一旦下一个bean创建的时候需要依赖上一个bean则直接使用ObjectFactory。
bean的实例化
如果缓存中得到bean的原始状态，则需要对bean进行实例化。缓存中记录的只是最原始的bean状态，并不一定是我们最终想要的bean。
原型模式的依赖检查
只有在单例情况下才会尝试解决循环依赖的问题。
检测parentBeanFactory
从代码上看，如果缓存没有数据的话且存在父类工厂则直接转到父类工厂上去加载
将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition。
寻找依赖
因为bean的初始化过程中很可能会用到某些属性，而某些属性很可能是动态配置的，并且配置成依赖于其的bean，那么这个时候必须先加载依赖的bean。
针对不同的scope进行bean创建
在Spring中存在着不同的scope，其中默认的是singleton，但还有其他的配置，例如：prototype，request等，在这个步骤中，Spring会根据不同的配置进行初始化策略
类型转换