史上最完整的Spring Bean的生命周期

百事皆可乐~

于 2023-05-29 14:18:02 发布

阅读量782

点赞数

分类专栏： spring java基础文章标签： spring java

本文链接：https://blog.csdn.net/qq_2662385590/article/details/130926365

版权

java基础同时被 2 个专栏收录

21 篇文章 0 订阅

订阅专栏

spring

2 篇文章 0 订阅

订阅专栏

Bean的生命周期总在这里插入图片描述

Spring Bean 的生命周期

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

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

填充初始化容器相关信息
通过 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);
        }
    }
}

初始化构造方法
通过 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);
			}
		}
	}

Bean的后置处理（在执行初始化之前和之后）
在invokeInitMethods 的前后进行
1. applyBeanPostProcessorsBeforeInitialization
2. invokeInitMethods
3. applyBeanPostProcessorsAfterInitialization
  在后置处理中处理了包括：AOP【AnnotationAwareAspectJAutoProxyCreator】
  负责构造后@PostConstruct 和销毁前@PreDestroy 的InitDestoryAnnotationBeanPostProcessor 等
注册销毁
通过reigsterDisposableBean方法，将实现了销毁接口DisposableBean的Bean的进行注册，在销毁时，执行destory()方法
添加到单例池，通过 addSingleton 方法，将Bean 加入到单例池 singleObjects
销毁
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