Spring Ioc源码分析 之 Bean的加载（三）：各个 scope 的 Bean 建立

在Spring中Bean有许多不一样的做用域，例如：singleton、prototype、request等等，本篇文章就来分析一下各个scope的Bean是怎么建立的

1、singleton

代码：

// 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);
	}
复制代码

• 这里使用了匿名内部类，先经过createBean(beanName, mbd, args)方法获取一个 ObjectFactory

• 把 ObjectFactory 做为参数传入 getSingleton(beanName,objectFactory)方法

• 使用 getSingleton(beanName,objectFactory) 方法返回的 sharedInstance 做为参数传入 getObjectForBeanInstance(sharedInstance, name, beanName, mbd)来回去最终的Bean实例（详情见Spring Ioc 之 Bean的加载（一））

createBean(beanName, mbd, args)方法比较复杂，在以后的文章中会详细分析，这里就先略过，直接看 getSingleton(beanName,objectFactory)方法。

// DefaultSingletonBeanRegistry.java

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
//全局加锁
synchronized (this.singletonObjects) {
	// 从缓存中获取单例bean
	// 由于 singleton 模式其实就是复用已经建立的 bean 因此这步骤必须检查
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null) {
		//是否正在销毁该bean
		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 {
			// 初始化 bean
			// 这个过程实际上是调用 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;
	}
	}
复制代码

在这段代码中，其实主要是作了一些准备和预处理步骤，真正建立Bean是在singletonFactory.getObject()方法实现的，而 singletonFactory 是由createBean()方法建立后回调的参数。
那么这段代码主要作的事情是什么呢？

• 尝试从缓存中获取单例Bean
  若是已经加载了则直接返回，不然开始加载过程

• 加载前置处理

• 获取Bean实例

• 后置处理

• 加入缓存

1.一、加载前置处理

beforeSingletonCreation(beanName)是个标记方法，咱们来看代码：

// 用于添加标志，当前 bean 正处于建立中
	protected void beforeSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			//添加失败，抛出异常
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
复制代码

把 beanName 添加到 singletonsCurrentlyInCreationmap中，用来表示该单例bean正在建立，若是添加失败，抛出异常。

1.二、获取Bean实例

经过createBean(beanName)方法返回的 singletonFactory 获取Bean。

1.三、后置处理

afterSingletonCreation(beanName)一样是个表示方法：

// 用于移除标记，当前 Bean 不处于建立中
	protected void afterSingletonCreation(String beanName) {
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
			//移除失败，抛出异常
			throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
		}
	}
复制代码

建立Bean以后移除建立标示。
前置处理和后置处理的这个建立标示，会在调用isSingletonCurrentlyInCreation(String beanName)时用到，该方法用来判断当前bean是否已经在建立中。

1.四、加入缓存

直接看代码：

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);
	    }
	}
复制代码

一个 put、一个 add、两个 remove 操做。

• 【put】singletonObjects 属性，单例 bean 的缓存。

• 【remove】singletonFactories 属性，单例 bean Factory 的缓存。

• 【remove】earlySingletonObjects 属性，“早期”建立的单例 bean 的缓存。

• 【add】registeredSingletons 属性，已经注册的单例缓存。

2、Prototype

代码：

//建立多例Bean
	else if (mbd.isPrototype()) {
		// It's a prototype -> create a new instance.
		//原型模式(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);
	}
复制代码

原型模式很简单，直接建立一个新的实例就行了，再也不从缓存中去获取。
beforePrototypeCreation(beanName)前置处理，将当前bean标记为正在建立的原型。
afterPrototypeCreation(beanName)后置处理，取消当前bean的正在建立标示。
调用getObjectFrBeanInstance()方法获取最终bean。（详情见Spring Ioc 之 Bean的加载（一））

3、其余做用域

//要建立的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);
		}
	}
复制代码

分为如下几个步骤：

• 从Scope注解中获取scope名称

• 前置处理

• createBean()

• 后置处理

• scope.get()获取bean

• getObjectForBeanInstance()方法获取Bean

核心流程与原型模式同样，只不过这里调用了scope.get()来获取bean。

Object get(String name, ObjectFactory<?> objectFactory);
复制代码

scope.get()是一个接口，它有多种实现类：

咱们看一下spring自带的一个实现 SimpleThreadScope：

//SimpleThreadScope.java

private final ThreadLocal<Map<String, Object>> threadScope =
			new NamedThreadLocal<Map<String, Object>>("SimpleThreadScope") {
				@Override
				protected Map<String, Object> initialValue() {
					return new HashMap<>();
				}
			};


	//获取bean的实例
	@Override
	public Object get(String name, ObjectFactory<?> objectFactory) {
		// 获取 scope 缓存
		Map<String, Object> scope = this.threadScope.get();
		Object scopedObject = scope.get(name);
		if (scopedObject == null) {
			scopedObject = objectFactory.getObject();
			// 加入缓存
			scope.put(name, scopedObject);
		}
		return scopedObject;
	}
复制代码

其余scope的实现就不一一去看了，感兴趣的朋友能够本身看一下。

总结

上面的代码中有2个重要方法：

• createBean(beanName, mbd, args)

• getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd)

这2个方法在3个代码分支中都用到了，createBean下篇文章会详细分析，getObjectForBeanInstance方法在Spring Ioc 之 Bean的加载（一）中已经分析过了。
这里再引用下《Spring 源码深度解析》对该方法的分析：

这个方法主要是验证如下咱们获得的 bean 的正确性，其实就是检测当前 bean 是不是 FactoryBean 类型的 bean 。
若是是，那么须要调用该 bean 对应的 FactoryBean 实例的 getObject() 方法，做为返回值。
不管是从缓存中得到到的 bean 仍是经过不一样的 scope 策略加载的 bean 都只是最原始的 bean 状态，并不必定就是咱们最终想要的 bean。
举个例子，假如咱们须要对工厂 bean 进行处理，那么这里获得的实际上是工厂 bean 的初始状态，可是咱们真正须要的是工厂 bean 中定义 factory-method 方法中返回的 bean，而 getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) 方法，就是完成这个工做的。

参考： 《Spring 源码深度解析》- 郝佳 芋道源码