Spring Bean的生命周期

1.BeanDefinition对象的创建

加载一个Bean，首先要将Bean对应的class文件加载进来，同时生成一个BeanDefinition对象，将class文件中的类信息分块归类的存放到这个BeanDefinition对象中
BeanDefinition对象的作用：

• 用来确定Bean的类型
• 存储加载类的信息
• 包括加载验证等阶段
  在完成BeanDefinition对象的创建之后，将这个对象放入一个map中

2.Bean实例化

根据BeanDefinition中定义的类信息，执行doCreateBean方法，创建类实例，此时创建的类对象是目标类的一个空对象，既不是对象实例因为还没有进行初始化，更不是Bean。对于Spring容器来说，Spring容器管理的是Bean对象，而不是仅仅将类加载并进行初始化那么简单。

3.提前暴露

此时会将这个半成品Bean，封装成一个工厂对象，同时将这个Bean的后置处理器挨个执行，最后将这个工厂对象存入Spring的第三级缓存中。这么做是为了解决循环依赖的问题。

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

图解循环依赖：

4.属性填充

执行populateBean方法，为Bean进行属性填充
@Autowired和@Resource区别

• autowired默认使用类型去注入，而resource默认使用对象名去注入
• @Autowired的在依赖注入时，使用的后置处理器是AutowiredAnnotationBeanPostProcessor
• @Resource使用的后置处理器是CommonAnnotationBeanPostProcessor

// AbstractAutowireCapableBeanFactory#populateBean
	// beanName : bean 的name
	// mbd  :  bean的定义信息
	// bw  : bean实例的包装类型，里面有bean的实例
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			 没有属性抛出异常
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}
		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		//
		boolean continueWithPropertyPopulation = true;
         //mbd.isSynthetic() 合成类
		//todo 第五次---判断属性是否填充：InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
		// 给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}
 
		if (!continueWithPropertyPopulation) {
			return;
		}
		//获取容器在解析Bean定义资源时为BeanDefiniton中设置的属性值
		//这个是程序员在 bd中 写入的属性rootBeanDefinition.getPropertyValues().add("type","男的");
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
 
		 2. 自动装配 ：autowiring自动装配的。根据名称或类型自动注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
 
 
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
 
			// Add property values based on autowire by name if applicable.
			//根据Bean名称进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
 
			// Add property values based on autowire by type if applicable.
			//根据Bean类型进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
 
			pvs = newPvs;
		}
		//对非autowiring的属性进行依赖注入处理
		// 后处理器已经初始化
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
 
		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				//TODO 获取的bean所有后置处理器找到 所有需要注入的属性
				// 这里会进行 @Autowired 和 @Resource 的注入工作
				// 属性填充InstantiationAwareBeanPostProcessor
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						//下面是完成属性注入的
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						// 如果postProcessProperties 返回null，再调用 postProcessPropertyValues这个过时的方法
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				// 依赖检查，对应 depends-on 属性，3.0 已弃用
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
		if (pvs != null) {
			 4. 将属性应用到bean中
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
}

5.BeanPostProcessor的beforeInit

如果定义了后置处理器的beforeInit方法，则在这个步骤会执行

6.初始化

如果有给Bean的属性设置默认值，则在这个步骤进行赋值。

7.BeanPostProcessor的afterInit方法

同样的，如果定义了后置处理器的afterInit方法，则在这个步骤会执行

生成Bean对象，放入容器中

最终，将这个Bean放入SingleTon单例池中，也就是我们常说的容器。
简化的生命周期流程图：