第十二章 bean的依赖注入

bean的依赖注入

org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

finishBeanFactoryInitialization(beanFactory);

org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization

/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		// 装换bean conversionService
		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.Z
		// 得到所有的实现了LoadTimeWeaverAware接口的子类名称，初始化它们
		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.
		// 允许缓存所有bean定义元数据，而不期望进一步更改。
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		// 实例化所有剩余的(非延迟-init)单例。
		beanFactory.preInstantiateSingletons();
	}

立即加载…

if (isEagerInit) {
	getBean(beanName);
}

根据bean的名字获取bean的实例对象

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

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		// 查看bean时候存在其他的别名 alias
		final String beanName = transformedBeanName(name);

		Object bean;
		// Eagerly check singleton cache for manually registered singletons.
		// IOC 容器创建单例模式 Bean 实例对象

        // 先从缓存中获取Bean，处理那些已经被创建过的单件模式的Bean，对这种Bean的请求不需要重复创建
		Object sharedInstance = getSingleton(beanName);


		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				//如果指定名称的 Bean 在容器中已有单例模式的 Bean 被创建
                //直接返回已经创建的 Bean
				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 + "'");
				}
			}
			//注意FactoryBean的BeanFactory的区别
			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)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			// Check if bean definition exists in this factory.
			//对 IOC 容器中是否存在指定名称的 BeanDefinition 进行检查，首先检查是否
			//能在当前的 BeanFactory 中获取的所需要的 Bean，如果不能则委托当前容器
			//的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//当前容器的父级容器存在，且当前容器中不存在指定名称的 Bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				//解析指定 Bean 名称的原始名称
				// 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) {
				//向容器标记指定的 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 有依赖 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 + "'");
						}
						//把被依赖 Bean 注册给当前依赖的 Bean
						registerDependentBean(dep, beanName);
						try {
							//递归调用 getBean 方法，获取当前 Bean 的依赖 Be
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				/********************************去容器中创建的过程*************************************/

				// Create bean instance.
				//创建单例模式 Bean 的实例对象
				if (mbd.isSingleton()) {
					//这里使用了一个匿名内部类，创建 Bean 实例对象，并且注册给所依赖的对象
					//
					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.
							//显式地从容器单例模式 Bean 缓存中清除实例对象
							destroySingleton(beanName);
							throw ex;
						}
					});
					//获取给定 Bean 的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
                //IOC 容器创建原型模式 Bean 实例对象
				else if (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) {
						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 的实例对象
						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.
		//对创建的 Bean 实例对象进行类型检查
		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;
	}