奔跑的蜗牛_Kieasar

Spring源码之Bean的生命周期

Spring已经成为了目前最流行的第三方开源框架之一，我们在充分享受Spring IOC容器带来的便捷时，也应该考虑一下Spring这个大工厂是如何将一个个的Bean生产出来的，我们一起来讨论一下Spring中Bean的生命周期。

Spring容器就好像生产车间的流水线，创建出来的对象就像是生产出来的一个个精美绝伦的产品。 Spring将管理的对象称之为Bean。

Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的。

Bean的一生总体上来说可以分为三个阶段：

容器启动阶段
Bean的生成
Bean的销毁

一、容器启动阶段

容器的启动阶段做了很多的预热工作，为后面Bean的实例化做好了充分的准备。

1. 容器的初始化

以AnnotationConfigApplicationContext容器为例，我们看它的构造函数：

	public AnnotationConfigApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

首先，它会初始化一个AnnotatedBeanDefinitionReader为BeanDefinition读取器，它可以直接把某个类转换为BeanDefinition，并且会解析该类上的注解，比如：

    @Test
    public void testAnnotatedBeanDefinitionReader() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ScanBean.class);
        AnnotatedBeanDefinitionReader annotatedBeanDefinitionReader = new AnnotatedBeanDefinitionReader(applicationContext);
        // 将Teacher.class解析为BeanDefinition
        annotatedBeanDefinitionReader.register(Teacher.class);
        System.out.println(applicationContext.getBean("teacher"));
    }

另外，ClassPathBeanDefinitionScanner是扫描器，但是它的作用和BeanDefinitionReader类似，它可以进行扫描，扫描某个包路径，对扫描到的类进行解析，比如，扫描到的类上如果存在@Component注解，那么就会把这个类解析为一个BeanDefinition，比如：

    @Test
    public void testClassPathBeanDefinitionScanner() {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.refresh();
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(applicationContext);
        scanner.scan("cn.kieasar");
        System.out.println(applicationContext.getBean("goodsService"));
    }

2、BeanDefination

在Java世界中，万物皆对象，散落于程序代码各处的注解以及保存在磁盘上的xml或者其他文件等等配置元信息，在内存中总要以一种对象的形式表示，就好比我们活生生的人对应到Java世界中就是一个Person类。

而Spring在内存中表示这些对象的方式就是BeanDefination，Bean对象被加载到内存之后是以BeanDefination的形式存在。

3、BeanDefinationRegistry

这样我们需要创建某一个对象实例的时候，找到相应的BeanDefination然后创建对象即可。那么我们需要某一个对象的时候，去哪里找到对应的BeanDefination呢？

通过Bean定义的id找到对象的BeanDefination的对应关系或者说映射关系又是如何保存的呢？这就引出了BeanDefinationRegistry了。

Spring通过BeanDefinationReader将对象加载到内存生成相应的BeanDefination之后，就将其注册到BeanDefinationRegistry中，BeanDefinationRegistry就是一个存放BeanDefination的大篮子，它也是一种键值对的形式，通过特定的Bean定义的id，映射到相应的BeanDefination。

4、BeanFactoryPostProcessor

BeanFactoryPostProcessor是容器启动阶段Spring提供的一个扩展点，主要负责对注册到BeanDefinationRegistry中的一个个的BeanDefination进行一定程度上的修改与替换。

比如通过以下代码定义一个BeanPostProcessor：

@Component
public class KieasarBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("teacher")) {
            System.out.println("初始化前" + bean);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("teacher")) {
            System.out.println("初始化后" + bean);
        }
        return bean;
    }
}

一个BeanPostProcessor可以在任意一个Bean的初始化之前和初始化之后去做一些自定义的逻辑，当然，我们可以通过判断beanName来进行针对性处理（针对某个Bean，或某部分
Bean），通过定义BeanPostProcessor可以干涉Spring创建Bean的过程。

例如配置Jdbc的DataSource连接的时候可以这样配置：

BeanFactoryPostProcessor就会对注册到BeanDefinationRegistry中的BeanDefination做最后的修改，替换$占位符为配置文件中的真实的数据。

至此，整个容器启动阶段就算完成了，容器的启动阶段的最终产物就是注册到BeanDefinationRegistry中的一个个BeanDefination了，这就是Spring为Bean实例化所做的预热的工作。让我们再通过一张图简单回顾一下：

二、Bean的生成

如果我们不是选择懒加载的方式，容器启动阶段完成之后，将立即启动Bean实例化阶段，通过隐式的调用所有依赖对象的getBean方法来实例化所有配置的Bean并保存起来。

而如果我们选择懒加载的方式，那么直到我们伸手向Spring要依赖对象实例之前，都是以BeanDefinationRegistry中一个个的BeanDefination的形式存在，也就是Spring只有在我们需要依赖对象的时候才进行相应对象的实例化。

1. 生成BeanDefinition

Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan()方法：

protected Set doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
			// 根据扫描路径，得到BeanDefinition
			Set candidates = findCandidateComponents(basePackage);
			// 解析class
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 解析@lazy、@Primary、@DependsOn、@Role、@Description
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				// 检查Spring容器是否已经存在beanName
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					// 注册
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

扫描某个包路径，并得到BeanDefinition的Set集合。

扫描流程为：

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

上面是说的通过扫描得到BeanDefinition对象，还可以通过直接定义BeanDefinition，或
解析spring.xml文件的，或者@Bean注解得到BeanDefinition对象。

2. 合并BeanDefinition

通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在
Spring中支持父子BeanDefinition。

父子BeanDefinition实际用的比较少，使用是这样的，比如：

这种情况下，child是单例Bean。

这种情况下，child就是原型Bean了。因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。
而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的
BeanDefinition（后面Bean的初始化源码中会提到）。

3. 加载类

BeanDefinition合并之后，就可以创建Bean对象了，而创建Bean须先实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory.
createBean()方法中，一开始就会调用：

Class resolvedClass = resolveBeanClass(mbd, beanName);

这行代码就是去加载类，该方法是这么实现的：

if (mbd.hasBeanClass()) {
  return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
  return AccessController.doPrivileged((PrivilegedExceptionAction>) () ‐>
    doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
  }
else {
  return doResolveBeanClass(mbd, typesToMatch);
}

进入hasBeanClass()方法：

public boolean hasBeanClass() {
  return (this.beanClass instanceof Class);
}

如果beanClass属性的类型是Class，那么就直接返回，如果不是，则会根据类名进行加载
（doResolveBeanClass方法所做的事情）会利用BeanFactory所设置的类加载器来加载类，如果没有设置，则默认使用ClassUtils.getDefaultClassLoader()方法所返回的类加载器来加载。

        ClassUtils.getDefaultClassLoader()
        1. 优先返回当前线程中的ClassLoader；
        2. 线程中类加载器为null的情况下，返回ClassUtils类的类加载器；
        3. 如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，则返回系统类加载器。

4. 实例化前

当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但是在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。比如：

@Component
public class IBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return null;
    }

    /**
     * 这个方法很重要，在spring中就是在这个方法里面处理@Autowired、@Resource、@Value注解
     * @param pvs
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }

    /**
     * 实例化之前调用的方法，传的参数不是对象（先看这个方法）
     */
    @SneakyThrows
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        if (beanName.equals("userService")) {
            System.out.println("实例化前");
        }
        return null;
    }
}

在userService这个Bean实例化前，会进行打印。
值得注意的是，postProcessBeforeInstantiation()方法是有返回值的，如果按上面代码返回null，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。

5. 实例化

在这里就会根据BeanDefinition去创建对象了。会调用org.springframework.beans.factory.support.DefaultListableBeanFactory#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.
		// 前面的registerBeanDefinition()方法会把所有的beanName缓存到这里
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 在spring容器初始化时，遍历这个beanDefinitionNames，从这里拿beanDefinition的name
		for (String beanName : beanNames) {
			// 先合并BeanDefinition（如果存在parent，则合并父子BeanDefinition的属性，生成一个RootBeanDefinition）
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 如果是单例的、非抽象的、非懒加载的就实例化
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 判断bean是否实现FactoryBean接口
				if (isFactoryBean(beanName)) {
					// 获取FactoryBean对象，创建完之后放到单例池
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							// SmartFactoryBean继承FactoryBean接口，有个isEagerInit()方法设置是否容器启动就创建getObject()的实例
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							// 创建真正的Bean对象（调用getObject()返回的对象）
							getBean(beanName);
						}
					}
				}
				else {
					// 再实例化（创建Bean对象）******
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		// 所有的非懒加载单例Bean都创建完之后
		for (String beanName : beanNames) {
			// 从单例池中拿beanName对应的单例Bean
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction