Spring之Bean生命周期

Bean的生命周期

Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的

Bean生命周期流程图

Bean的生成过程

主要源码流程:scan---getBean--doGetBean--createBean--doCreateBean

1. 解析配置类,扫描包,生成BeanDefinition

Spring启动的时候会进行扫描，会先调用ClassPathBeanDefinitionScanner的doScan方法,扫描某个包路径，并得到BeanDefinition的Set集合。

关于Spring启动流程，后续会详细讲，这里先讲一下Spring扫描的底层实现：

1. 首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件（Spring源码中将此文件包装成了Resource对象）
2. 遍历每个Resource对象
3. 利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）
4. 利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选（条件注解并不能理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）
5. 筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition
6. 再基于metadataReader判断是不是对应的类是不是接口或抽象类
7. 如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集

MetadataReader表示类的元数据读取器，主要包含了一个AnnotationMetadata，功能有

• 获取类的名字、
• 获取父类的名字
• 获取所实现的所有接口名
• 获取所有内部类的名字
• 判断是不是抽象类
• 判断是不是接口
• 判断是不是一个注解
• 获取拥有某个注解的方法集合
• 获取类上添加的所有注解信息
• 获取类上添加的所有注解类型集合

值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）

先看下前置流程

重要的doscan的大致源码如下

1.扫描配置类上@ComponentScan注解里的包路径,可以为多个路径

2.findCandidateComponents方法一般情况下调用scanCandidateComponents(basePackage),源码如下

3.registerBeanDefinition

加入到DefaultListableBeanFactory的属性中去

2. 合并BeanDefinition

实例化的代码主要如下

@Override
	public void refresh() throws BeansException, IllegalStateException {
		// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
		synchronized (this.startupShutdownMonitor) {

			/**
			 * 容器刷新前的准备工作
			 * 1.设置容器启动时间
			 * 2.将容器 active 属性设置为 true，closed 属性设置为 false
			 * 3.设置new StandardEnvironment对象,将系统属性配置加载到Environment对象中
			 * 4.准备监听器ApplicationListener,事件驱动ApplicationEvent
			 */
			// Prepare this context for refreshing.
			prepareRefresh();


			//这个方法和主流程关系也不是很大，可以简单的认为，就是把DefaultListableBeanFactory取出来而已
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
			//还是一些准备工作，添加了两个后置处理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
			//还设置了 忽略自动装配 和 允许自动装配 的接口,如果不存在某个bean的时候，spring就自动注册singleton bean
			//还设置了bean表达式解析器 等
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {

				// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
				// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
				//目前是空方法,留给后续扩展
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				//实例化并执行所有注册的实现了BeanFactoryPostProcessor的bean,必须要在单例bean实例化之前调用
				//完成扫描和解析(类--->beanDefinition) 		beanDefinitionMap
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				//实例化并注册所有的BeanPostProcessor,还没有执行
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
				// Initialize message source for this context.
				initMessageSource();

				// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// 空方法 从方法名就可以知道，典型的模板方法(钩子方法)，
				// 具体的子类可以在这里初始化一些特殊的 Bean,springboot在这里会做扩展
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
				// Check for listener beans and register them.
				registerListeners();

				//涉及到FactoryBean
				// 重点，重点，重点
				// 初始化所有的 非懒加载 的 singleton beans
				//（lazy-init 的除外）
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// 最后，广播事件，ApplicationContext 初始化完成
				// Last step: publish corresponding event.
				finishRefresh();
			}

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

				// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
				// 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();
			}
		}
	}

我们先看finishBeanFactoryInitialization(beanFactory);这里是实例化和初始化所有的 非懒加载 的 singleton beans

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {

		// 为spring容器初始化类型转化器
		// 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));
		}

		// 先初始化 LoadTimeWeaverAware 类型的 Bean
		// 之前也说过，这是 AspectJ 相关的内容，放心跳过吧
		// 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);

		// 到这一步的时候，Spring 已经开始预初始化 singleton beans 了，
		// 肯定不希望这个时候还出现 bean 定义解析、加载、注册。
		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

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

先看preInstantiateSingletons()源码,这里注意看合并父 Bean 中的配置的那行

public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// this.beanDefinitionNames 保存了所有的 beanNames
		// 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.
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// 下面这个循环，触发所有的非懒加载的 singleton beans 的初始化操作
		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 合并父 Bean 中的配置，得到RootBeanDefinition,合并后存在mergedBeanDefinitions的map中,
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

			// 非抽象、非懒加载的 singletons。如果配置了 'abstract = true'，那是不需要初始化的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 如果该beanName对应的是FactoryBean,处理 FactoryBean,FactoryBean不需要遵循spring的bean生命周期
				if (isFactoryBean(beanName)) {
					// FactoryBean 的话，在 beanName 前面加上 ‘&’ 符号。再调用 getBean，getBean 方法
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						// 判断当前 FactoryBean 是否是 SmartFactoryBean 的实现，此处忽略，直接跳过
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							//是否是SmartFactoryBean且非懒加载
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							//创建真正的bean
							getBean(beanName);
						}
					}
				}
				else {
					//核心代码,创建真正的bean 对于普通的 Bean，只要调用 getBean(beanName) 这个方法就可以进行初始化了
					getBean(beanName);
				}
			}
		}

		// 到这里说明所有的非懒加载的 singleton beans 已经完成了初始化
		// 如果我们定义的 bean 是实现了 SmartInitializingSingleton 接口的，那么在这里得到回调，忽略
		// 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			// 7.1 拿到beanName对应的bean实例
			Object singletonInstance = getSingleton(beanName);
			// 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				// 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction