Bean的生命周期总

Spring Bean 的生命周期

Spring中的bean的生命周期主要包含四个阶段：实例化Bean–> Bean属性填充–>初始化Bean—>销毁Bean

1. 加载Bean定义
   通过 loadBeanDefinitions 扫描所有xml配置、注解将Bean记录在beanDefinitionMap中
2. 创建Bean对象
   通过 createBean 遍历 beanDefinitionMap 创建bean
3. 构建对象
   1. 容器通过 createBeanInstance 进行对象构造
      1. 如果只有一个构造方法，直接使用创建对象。
      2. 如果有多个构造方法
      • 优先获取无参构造方法去创建对象（前提是构造方法中都没有标注@Autowired注解），如果没有无参构造方法，就寻找有参构造方法，如果有多个，直接报错
      • 如果构造方法标注了@Autowired注解的构造方法，直接使用标注了@Autowired注解的构造方法，如果有多个，直接报错
   2. 准备构造方法的参数
      1. 如果是无参构造方法，直接构造对象
      2. 如果是有参构造方法
      • 在bean单例池中，根据参数的Class类进行查找，如果这个类在单例池中有多个，则在根据参数名字在进行匹配，如果没有找到，则构造信息不完整，直接报错。
   3. 构建对象（实例化bean）
4. 填充属性
   通过populateBean方法为Bean内部所需的属性进行赋值
   • 通常是 @Autowired 注解的变量
   • 通过三级缓存机制进行属性填充，也就是我们所谓的依赖注入
5. 初始化Bean对象
   1. 通过initializeBean对填充后的实例进行初始化

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  	if (System.getSecurityManager() != null) {
  		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
              //执行实现了xxxAware方法
  			invokeAwareMethods(beanName, bean);
  			return null;
  		}, getAccessControlContext());
  	}
  	else {
          //执行实现了xxxAware方法
  		invokeAwareMethods(beanName, bean);
  	}

  	Object wrappedBean = bean;
  	if (mbd == null || !mbd.isSynthetic()) {
          //Bean的后置处理
  		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  	}

  	try {
  		invokeInitMethods(beanName, wrappedBean, mbd);
  	}
  	catch (Throwable ex) {
  		throw new BeanCreationException(
  				(mbd != null ? mbd.getResourceDescription() : null),
  				beanName, "Invocation of init method failed", ex);
  	}
  	if (mbd == null || !mbd.isSynthetic()) {
          //Bean的后置处理
  		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  	}

  	return wrappedBean;
  }

2. 填充初始化容器相关信息
   通过 invokeAwareMethods 方法：为实现各种aware接口【信息感知接口】的Bean 设置注入beanName、beanFactory等容器信息

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ClassLoader bcl = getBeanClassLoader();
            if (bcl != null) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
            }
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

3. 初始化构造方法
   通过 invokeInitMethods 方法进行初始化
   通过实现InitializingBean接口，重写afterPropertiesSet()方法（Bean填充属性以后，会执行这个方法）
   
   然后执行Bean上的自定义的initMethod方法
   
   

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
                //这里会执行Bean上的自定义的initMethod方法
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

4. Bean的后置处理（在执行初始化之前和之后）
   在invokeInitMethods 的前后进行
   1. applyBeanPostProcessorsBeforeInitialization
   2. invokeInitMethods
   3. applyBeanPostProcessorsAfterInitialization
      在后置处理中处理了包括：AOP【AnnotationAwareAspectJAutoProxyCreator】
      负责构造后@PostConstruct 和 销毁前@PreDestroy 的InitDestoryAnnotationBeanPostProcessor 等
      
      
5. 注册销毁
   通过reigsterDisposableBean方法，将实现了销毁接口DisposableBean的Bean的进行注册，在销毁时，执行destory()方法
6. 添加到单例池，通过 addSingleton 方法，将Bean 加入到单例池 singleObjects
7. 销毁
   a. 销毁前，调用 bean中@PreDestory 注解的方法
   b. 通过 postProcessBeforeDestruction 方法调用destoryBean逐一销毁Bean，销毁，调用 destory（）方法
   
   执行客户自定义销毁调用 invokeCustomDestoryMethod
   
   
   总结：
   
   理解文档链接：
   https://blog.csdn.net/qq_2662385590/article/details/123841115
   bilibili的视频解析：
   https://www.bilibili.com/video/BV1584y1r7n6/?spm_id_from=333.999.0.0&vd_source=aac4a0b20704a0563e1e519cc8bdc560