spring源码学习（4）

前面一节，我们看了一下getBean的大致流程，首先是转化beanName，然后根据beanName去缓存当中获取，如果没有的话，那我们就会通过factory去生成指定域的bean，放入缓存当中。

那么我们接着就深入了解一下每一步的详细流程。那么今天，就来看一下我们到底应该如何得到bean。

（1）缓存当中获取

Object sharedInstance = getSingleton(beanName);
//最终进了这个方法，其中allowEarlyReference是true
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //singletonObjects就是一个map，也就是一个缓存，key为beanName，值为bean（仅仅只是单例）
		Object singletonObject = this.singletonObjects.get(beanName);
        //没有缓存，并且该bean正在被创建（解决循环依赖的）
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
                //earlySingletonObjects主要是用来装正在创建的bean，因为有些bean可能循环引用，比如你中有我，我中有你
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
（这是和3：详情请看前一篇  挂钩的）
//最后返回的结果还只是一个共享的bean，可能是一个工厂bean，也可能是一个真正的bean
//那么接下来看一下返回过后。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
//这个才是真正的bean，无论是缓存或者指定域，都需要使用到这个方法。因此，这个方法也比较重要，我们可以看一下。
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
		}

		//因为beanInstance可能是个工厂，getBean（）才能获取到真正的bean
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
}
//并且每次生成bean之后，都会调用beanProcessor的注册功能
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
			result = beanProcessor.postProcessAfterInitialization(result, beanName);
			if (result == null) {
				return result;
			}
		}
		return result;
}

（2）指定域中获取（先考虑单例）

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    @Override
	public Object getObject() throws BeansException {
		try {
			return createBean(beanName, mbd, args);
		}catch (BeansException ex) {
			destroySingleton(beanName);
			throw ex;
		}
	}
});
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' 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<Exception>();
				}
				try {
                    //关键：创建bean的地方
					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 != NULL_OBJECT ? singletonObject : null);
		}
	}