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

Bean的生命周期总史上最完整的Spring Bean的生命周期_第1张图片

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;
  }
  1. 填充初始化容器相关信息
    通过 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);
        }
    }
}
  1. 初始化构造方法
    通过 invokeInitMethods 方法进行初始化
    通过实现InitializingBean接口,重写afterPropertiesSet()方法(Bean填充属性以后,会执行这个方法)
    史上最完整的Spring Bean的生命周期_第2张图片
    然后执行Bean上的自定义的initMethod方法
    史上最完整的Spring Bean的生命周期_第3张图片
    史上最完整的Spring Bean的生命周期_第4张图片
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);
			}
		}
	}
  1. Bean的后置处理(在执行初始化之前和之后)
    在invokeInitMethods 的前后进行
    1. applyBeanPostProcessorsBeforeInitialization
    2. invokeInitMethods
    3. applyBeanPostProcessorsAfterInitialization
      在后置处理中处理了包括:AOP【AnnotationAwareAspectJAutoProxyCreator】
      负责构造后@PostConstruct 和 销毁前@PreDestroy 的InitDestoryAnnotationBeanPostProcessor 等
      史上最完整的Spring Bean的生命周期_第5张图片
      史上最完整的Spring Bean的生命周期_第6张图片
  2. 注册销毁
    通过reigsterDisposableBean方法,将实现了销毁接口DisposableBean的Bean的进行注册,在销毁时,执行destory()方法
  3. 添加到单例池,通过 addSingleton 方法,将Bean 加入到单例池 singleObjects
  4. 销毁
    a. 销毁前,调用 bean中@PreDestory 注解的方法
    b. 通过 postProcessBeforeDestruction 方法调用destoryBean逐一销毁Bean,销毁,调用 destory()方法
    史上最完整的Spring Bean的生命周期_第7张图片
    执行客户自定义销毁调用 invokeCustomDestoryMethod
    史上最完整的Spring Bean的生命周期_第8张图片
    史上最完整的Spring Bean的生命周期_第9张图片
    总结:
    史上最完整的Spring Bean的生命周期_第10张图片
    理解文档链接:
    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

你可能感兴趣的:(spring,java基础,spring,java)