Spring框架中的IoC容器源码分析（下）

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
	...
	@Override
	public void refresh() throws BeansException, IllegalStateException {
		/**
		 * 对象锁加锁
		 */
		synchronized (this.startupShutdownMonitor) {
			...
			// 我这里直接定位到该流程需要的代码，其他的无关代码省略了哈
			/**
			 * 第二步：
			 *
			 * 获取BeanFactory：默认实现是DefaultListableBeanFactory
			 * Bean获取并封装成BeanDefinition对象
			 * 加载BeanDefinition 并注册到BeanDefinitionRegistry
			 */
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			...
		}
	}
	...
}

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
	refreshBeanFactory();
	return getBeanFactory();
}

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	...
	/**
	 * 对BeanFactory执行刷新操作，关闭以前的BeanFactory（如果有）
	 */
	@Override
	protected final void refreshBeanFactory() throws BeansException {
		// 判断是否已有BeanFactory
		if (hasBeanFactory()) {
			// 销毁Beans
			destroyBeans();
			// 关闭BeanFactory
			closeBeanFactory();
		}
		try {
			// 实例化DefaultListableBeanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			// 设置序列化id
			beanFactory.setSerializationId(getId());
			// 自定义bean工厂的一些属性（是否覆盖、是否允许循环依赖）
			customizeBeanFactory(beanFactory);
			// 加载应用中的BeanDefinitions
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				// 赋值当前BeanFactory
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
	...
}

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	...
	@Override
	public final ConfigurableListableBeanFactory getBeanFactory() {
		synchronized (this.beanFactoryMonitor) {
			if (this.beanFactory == null) {
				throw new IllegalStateException("BeanFactory not initialized or already closed - " +
						"call 'refresh' before accessing beans via the ApplicationContext");
			}
			return this.beanFactory;
		}
	}
	...
}

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

if (instanceWrapper == null) {
	// 创建Bean实例，仅仅调用构造方法，但是尚未设置属性
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

try {
	// Bean属性填充
	populateBean(beanName, mbd, instanceWrapper);
	// 调用初始化方法，应用BeanPostProcessor后置处理器
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

/**
 * Finish the initialization of this context's bean factory,
 * initializing all remaining singleton beans.
 *
 * 结束BeanFactory的初始化工作
 * 实例化所有单例bean
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize conversion service for this context.
	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.
	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.
	// 实例化所有立即加载的单例bean
	beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}
	
	// Iterate over a copy to allow for init methods which in turn register new bean definitions.
	// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
	// 所有bean的名字
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
	
	// Trigger initialization of all non-lazy singleton beans...
	// 触发所有非延迟加载单例bean的初始化，主要步骤为getBean
	for (String beanName : beanNames) {
		// 合并父BeanDefinition对象
		// map.get(beanName)
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				// 如果是FactoryBean则加&
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
				// 实例化当前bean
				getBean(beanName);
			}
		}
	}
	
	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

if (isPrototypeCurrentlyInCreation(beanName)) {
  throw new BeanCurrentlyInCreationException(beanName);
}

protected boolean isPrototypeCurrentlyInCreation(String beanName) { 
	Object curVal = this.prototypesCurrentlyInCreation.get(); 
	return (curVal != null && 
		(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

try {
	//创建原型bean之前添加标记 beforePrototypeCreation(beanName);
	//创建原型bean
	prototypeInstance = createBean(beanName, mbd, args);
} finally {
	//创建原型bean之后删除标记
    afterPrototypeCreation(beanName);
}

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
	if (logger.isDebugEnabled()) {
		logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
	}
	//将初始化后的对象提前已ObjectFactory对象注入到容器中 
	addSingletonFactory(beanName, new ObjectFactory<Object>() {
		@Override
		public Object getObject() throws BeansException {
		    return getEarlyBeanReference(beanName, mbd, bean);
		} 
	});
}