Spring源码导读之创建SingletonBean

Spring源码导读

 

目录

AbstractApplicationContext

DefaultListableBeanFactory

AbstractBeanFactory

DefaultSingletonBeanRegistry

AbstractAutowireCapableBeanFactory

总结

BeanPostProcessor在哪些地方被调用

如何解决循环依赖

---

 

 

Spring中的Bean如果没有定义其scop，和是否延迟加载的话。它默认是singleton 和 非延迟加载的。这类bean在Spring容器初始化的时候就会创建。

注意：Spring中的singletonObject 和单例模式没关系，单例模式是一个类只能创建一个对象，Spring中的singleton是指一个beanName仅能创建一个对象。定义为singleton的bean完全可以是一个class的多个实例。

 

AbstractApplicationContext

AbstractApplicationContext是一个骨架，其refresh规定了容器初始化的链路，

先梳理一下refresh方法，看下其主链路

	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// 告诉子列刷新其内部的factory, 这里会创建factory和加载beanDefinition
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// 允许子类对bean factory 进行前置处理
				postProcessBeanFactory(beanFactory);

				// 实例化FactoryPostProcessors
				invokeBeanFactoryPostProcessors(beanFactory);

				// 实例化BeanPostProcessors
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// 实例化那些非懒加载的singletons
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

refresh中调用 finishBeanFactoryInitialization(beanFactory)对非懒加载的singleton 进行实例化

 

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 设置类型转换服务, 后面会用到
		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));
		}

		// 一个嵌入式的解析，处理{} 这些占位符等
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// 这里是一个字节码编织技术
		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.
		beanFactory.freezeConfiguration();

		// 实例化所有剩下的非懒加载的singleton Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

 

接着，实例化所有剩下的非懒加载的singleton: beanFactory.preInstantiateSingletons(); 为什么是剩下的呢？因为前面创建了所有的FactoryBeanPostProcessor 和 BeanPostProcessor

 

在前面AbstractApplicationContext#obtainFreshBeanFactory ===》AbstractRefreshableApplicationContext#refreshBeanFactory中创建了

beanFactory，它是DefaultListableBeanFactory

 

DefaultListableBeanFactory

DefaultListableBeanFactory 里面提供了注册，获取，BeanDefinition的方法。查看其类图

它直接实现了 BeanDefinitionRegistry，是BeanDefinition的注册表，也是bean的别名的注册表。

它也是SingletonBeanRegistry的间接实现类，

 

接着看DefaultListableBeanFactory#preInstantiateSingletons：

它会遍历beanNames，这个beanNames在DefaultListableBeanFactory#registerBeanDefinition中设置的。

public void preInstantiateSingletons() throws BeansException {
	if (logger.isDebugEnabled()) {
		logger.debug("Pre-instantiating singletons in " + this);
	}
	
	List beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 遍历所有注册过的beanNames, Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
		// 当这个bean存在parent的时候，会对原来的GenericBeanDefinition进行一次融合，融合之后就是RootBeanDefinition了
		// 其实在前面invokeBeanFactoryPostProcessors时已经merge过了
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		
		// 不是抽象的，是gingleton，并且不是懒加载则创建bean
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
		
			// 如果是一个FactoryBean，这个后面介绍
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean factory = (FactoryBean) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction)
										((SmartFactoryBean) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
				// 这里开始以getBean来发起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