Spring Ioc源码分析 之 Bean的加载（一）

时间  2019-12-18
标签 spring ioc 源码 分析 bean 加载 栏目 Spring 繁體版
原文   原文链接

前言

在以前的文章中，咱们分析了Spring的Ioc的初始化过程，实际上就是把 beanName 和 BeanDefinition 注册到DefaultListableBeanFactory的map中。
在完成 bean 的注册以后， refresh() 还调用了不少后处理器的方法，其中有一个方法 finishBeanFactoryInitialization()，注释上面写着 Instantiateall remaining(non-lazy-init)singletons ，意味着非延迟加载的类，将在这一步实例化，完成类的加载。
而咱们使用到 context.getBean("beanName") 方法，若是对应的 bean 是非延迟加载的，那么直接就能拿出来进行使用，而延迟加载的 bean 就须要上面的步骤进行类的加载，加载完以后才能进行使用。java

咱们接着分析一下Ioc的bean实例化过程：缓存

1、getBean

当咱们显示或者隐式地调用 BeanFactory#getBean(String name) 方法时，则会触发加载 Bean 阶段。代码以下：session

// AbstractBeanFactory.java

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

内部调用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly) 方法，其接受四个方法参数：多线程

  • name ：要获取 Bean 的名字app

  • requiredType ：要获取 bean 的类型ide

  • args ：建立 Bean 时传递的参数。这个参数仅限于建立 Bean 时使用。post

  • typeCheckOnly ：是否为类型检查。ui

2、doGetBean

//真正实现向IOC容器获取Bean的功能，也是触发依赖注入功能的地方
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖
		// 若是指定的是别名，将别名转换为规范的Bean名称
<1>		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 从缓存中获取已被建立过的单例Bean
<2>		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 + "'");
				}
			}

			//注意：BeanFactory是管理容器中Bean的工厂
			// FactoryBean是建立建立对象的工厂Bean，二者之间有区别

			//获取给定Bean的实例对象，该对象要么是 bean 实例自己，要么就是 FactoryBean 建立的 Bean 对象
			//（为何要再次获取呢，由于上面获取的sharedInstance不必定是完整的）
<3>			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 由于 Spring 只解决单例模式下的循环依赖，在原型模式下若是存在循环依赖则会抛出异常。
<4>			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)) {
				// Not found -> check parent.
				//解析指定Bean名称的原始名称
				String nameToLookup = originalBeanName(name);
				// 若为 AbstractBeanFactory 类型，委托父类处理
				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 {
					// No args -> delegate to standard getBean method.
					//委派父级容器根据指定名称和类型查找
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			// 建立的Bean是否须要进行类型验证，通常不须要
<5>			if (!typeCheckOnly) {
				//向容器标记指定的Bean已经被建立
				markBeanAsCreated(beanName);
			}

			try {
				//从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象
				// 主要解决Bean继承时子类合并父类公共属性问题
<6>				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 检查给定的合并的 BeanDefinition (是否为抽象类)
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 处理所依赖的 bean @DependsOn()
				// 获取当前Bean全部依赖Bean的名称
<7>				String[] dependsOn = mbd.getDependsOn();
				//若是有依赖
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						//校验该依赖是否已经注册过给当前 Bean
						if (isDependent(beanName, dep)) {
							//已注册，抛出异常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//没有，则先注册依赖的bean
						registerDependentBean(dep, beanName);
						//递归调用getBean()，先生成依赖的bean
						getBean(dep);
					}
				}

				// Create bean instance.
				//建立单例Bean
<8>				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);
				}

				//建立多例Bean
				else if (mbd.isPrototype()) {
					//原型模式(Prototype)是每次都会建立一个新的对象
					Object prototypeInstance = null;
					try {
						//加载前置处理，默认的功能是注册当前建立的原型对象
						beforePrototypeCreation(beanName);
						//建立指定Bean对象实例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						//加载后置处理，默认的功能告诉IOC容器指定Bean的原型对象再也不建立
						afterPrototypeCreation(beanName);
					}
					//获取给定Bean的实例对象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				//要建立的Bean既不是Singleton也不是Prototype
				//如：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实例对象进行类型检查
<9>		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.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;
	}
复制代码

代码很长，须要一些耐心，下面咱们来逐步分析这段代码：this

  • <1>处：具体分析，见2.1获取原始beanNamespa

  • <2>处: 具体分析，见2.2从缓存中获取单例bean

  • <3>处: 具体分析，见2.3获取最终的bean实例对象

  • <4>处: 具体分析，见2.4原型模式依赖检查(Prototype)和从 parentBeanFactory 获取 Bean

  • <5>处: 具体分析，见2.5标记bean为已建立或即将建立

  • <6>处: 具体分析，见2.6获取BeanDefinition

  • <7>处: 具体分析，见2.7bean依赖处理

  • <8>处: 具体分析，见2.8不一样做用域bean的实例化

  • <9>处: 具体分析，见2.9类型转换

2.一、获取原始beanName

代码以下：

final String beanName = transformedBeanName(name);
复制代码

继续深刻，代码以下：

protected String transformedBeanName(String name) {
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}
复制代码

BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修饰符

//对FactoryBean的转义定义，由于若是使用bean的名字检索FactoryBean获得的对象是工厂生成的对象，
	//若是须要获得工厂自己，须要转义
	String FACTORY_BEAN_PREFIX = "&";

public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		String beanName = name;
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		return beanName;
	}
复制代码

ps: 若是一个factoryBean的名称为“student”，获取factoryBean建立的Bean时，使用getBean("student")，获取factoryBean自己时，使用getBean("&student")
接着深刻，最终代码以下：

/** Map from alias to canonical name */
	private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


//循环处理，从aliasMap中根据aliasName获取真实beanName，直到获取到的真实beanName为null
	public String canonicalName(String name) {
		String canonicalName = name;
		// Handle aliasing...
		String resolvedName;
		do {
			resolvedName = this.aliasMap.get(canonicalName);
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}
复制代码

主要是一个循环获取 beanName 的过程，例如，别名 A 指向名称为 B 的 bean 则返回 B，若 别名 A 指向别名 B，别名 B 指向名称为 C 的 bean，则返回 C

2.二、从缓存中获取单例bean

Spring 对单例模式的 bean 只会建立一次。后续，若是再获取该 Bean ，则是直接从单例缓存中获取，该过程就体如今 #getSingleton(String beanName) 方法中。代码以下：

/** Cache of singleton objects: bean name --> bean instance */
	//单例bean的缓存
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	//单例对象工厂缓存
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	//预加载单例bean缓存
	//存放的 bean 不必定是完整的
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

//对于单例模式的Bean整个IOC容器中只建立一次，不须要重复建立
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		//从单例缓存中获取单例bean
		Object singletonObject = this.singletonObjects.get(beanName);
		//若是缓存中没有 而且 该bean正在建立
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				// earlySingletonObjects 中没有，且容许提早建立
				if (singletonObject == null && allowEarlyReference) {
					//从缓存中获取 ObjectFactory
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						//从单例工厂中获取bean
						singletonObject = singletonFactory.getObject();
						//存入early
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}
复制代码

这段代码很简单，流程以下：

  • 第一步，从singletonObjects中获取Bean对象

  • 第二步，若是获取不到且Bean正在建立中，从earlySingletonObjects获取Bean对象

  • 第三步，若是获取不到且容许提早建立,从singletonFactories获取FactoryBean

  • 第四步，若是不为null，则经过FactoryBean.getObject()获取Bean，而后将其加入到 earlySingletonObjects ，而且从 singletonFactories 删除，二者是互斥的，主要用来解决循环依赖的问题

  • 总结就是：从这三个Map依次去取，取不到就取下一个Map

2.2.一、isSingletonCurrentlyInCreation

在上面的代码中又一个重要的方法isSingletonCurrentlyInCreation(beanName)，代码以下：

private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	
public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}
复制代码

这个方法是用来判断当前Bean是否在建立中，看到是个Map，咱们能够猜想，应该有一个地方在建立Bean的时候，会把正在建立的BeanName给put到这个Map中。具体咱们以后将。

2.2.二、getObjectForBeanInstance

当咱们从getSingleton(beanName)拿到bean对象后，会接着调用getObjectForBeanInstance()方法，来获取最终的Bean实例。

  • 为何这里要再获取一次Bean呢，以前明明都拿到了呀？

  • 由于咱们从缓存中获取的 bean 是最原始的 Bean ，并不必定是咱们最终想要的 Bean

  • 怎么办呢？调用 #getObjectForBeanInstance(...) 方法，进行处理，该方法的定义为获取给定 Bean 实例的对象，该对象要么是 bean 实例自己，要么就是 FactoryBean 建立的 Bean 对象。

看代码：

//获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
	protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		//容器已经获得了Bean实例对象，这个实例对象多是一个普通的Bean，
		//也多是一个工厂Bean，若是是一个工厂Bean，则使用它建立一个Bean实例对象，
		//若是调用自己就想得到一个容器的引用，则指定返回这个工厂Bean实例对象

		//若为工厂类引用（name 以 & 开头） 且 Bean实例也不是 FactoryBean
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			//抛出异常
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		
		//若是类型不是FactoryBean，直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		//若 BeanDefinition 为 null，则从缓存中加载 Bean 对象
		if (mbd == null) {
			//从Bean工厂缓存中获取给定名称的Bean实例对象
			object = getCachedObjectForFactoryBean(beanName);
		}

		// 若 object 依然为空，则能够确认，beanInstance 必定是 FactoryBean 。从而，使用 FactoryBean 得到 Bean 对象
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			// 检测是否认义 beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
				//从容器中获取指定名称的Bean定义，若是继承基类，则合并基类相关属性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			//若是从容器获得Bean定义信息，而且Bean定义信息不是虚构的，
			//则让工厂Bean生产Bean实例对象
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法，
			//实现工厂Bean生产Bean对象实例的过程
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}
复制代码

首先看下这个方法的流程：

  • 一、类型检查，判断是不是FactoryBean

  • 二、对非 FactoryBean 不作处理

  • 三、对 bean 进行转换

  • 四、处理 FactoryBean 类型：委托给 getObjectFromFactoryBean 方法进行处理。

咱们直接看第3步，走到这里，说明这个bean必定是FactoryBean类型的，再从Ioc容器中获取该beanName对应的BeanDefinition，若是不为null，且不是abstract，则调用getObjectFromFactoryBean方法获取bean实例

从这里能够看出， getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法，分红两种状况：

  • 第一种，当该实例对象为非 FactoryBean类型，直接返回给定的 Bean 实例对象 beanInstance 。

  • 第二种，当该实例对象为FactoryBean 类型，从 FactoryBean ( beanInstance ) 中，获取 Bean 实例对象。

2.2.三、getObjectFromFactoryBean

咱们接着看第二种状况：

//Bean工厂生产Bean实例对象
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		//为单例模式且缓存中存在
		if (factory.isSingleton() && containsSingleton(beanName)) {
			//多线程同步，以防止数据不一致
1.1			synchronized (getSingletonMutex()) {
				//从缓存中获取指定的 factoryBean
1.2				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					// 为空，则从 FactoryBean 中获取对象
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
1.3						if (shouldPostProcess) {
							try {
								// 对从 FactoryBean 获取的对象进行后处理
								// 生成的对象将暴露给 bean 引用
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						//将生产的实例对象添加到Bean工厂缓存中
1.4						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
				return object;
			}
		}
		// 为空，则从 FactoryBean 中获取对象
2		else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			// 须要后续处理
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}
复制代码

  • 一、判断是否为单例而且缓存中存在 若是存在，则顺着1.1往下走，不存在，则走2的流程

  • 1.一、sync加锁，锁住的是singletonObjects，和其余单例锁同样，保证全局惟一

  • 1.二、从缓存factoryBeanObjectCache中获取Bean实例 若是获取不到，则调用doGetObjectFromFactoryBean()方法获取，实际最后调用的是factory.getObject()方法

  • 1.三、若是须要后续处理( shouldPostProcess = true )，则进行下一步处理 postProcessObjectFromFactoryBean() 方法，对从 FactoryBean 处获取的 Bean 实例对象进行后置处理。其默认实现是直接返回 object 对象，不作任何处理。代码以下：

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
		return object;
	}
复制代码

可是子类能够重写，例如应用后处理器等。

  • 1.四、加入到 factoryBeanObjectCache 缓存中
  • 二、若是缓存中不存在，一样调用doGetObjectFromFactoryBean()获取bean实例

总结

到这里，doGetBean()方法的2.2从缓存中获取单例bean和2.3获取最终的bean实例对象咱们已经分析完了，下篇文章咱们接着分析后面的步骤。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程