Bean 的生命周期

发表于 2020-12-27 分类于技术

Bean 生命周期

参考文章

基本流程

Bean 的生命周期分成四步（五个手指头）：实例化、属性赋值、初始化、使用、销毁

实例化( createBeanInstance 方法 )（doCreateBean里面）
- 实例化一个 bean 对象
属性赋值( populateBean 方法 )
- 设置相关属性和依赖
初始化( initializeBean 方法 )
- 检查 Aware 相关接口并设置相关依赖( 初始化前执行 )
- BeanPostProcessor 前置处理( 初始化前执行 )
- 是否实现 InitializingBean 接口( 初始化 )
- 是否配置自定义的 init-method( 初始化 )
- BeanPostProcessor 后置处理( 初始化后执行 )
使用…
销毁( registerDisposableBeanIfNecessary 方法 + destroy 方法)
- 注册 Destruction 相关回调接口( ！！！在使用之前注册 )
- 是否实现 DisposableBean 接口
- 是否配置自定义的 destroy-method

扩展点

使用组件时，只要引用了一个依赖，几乎是零配置就能完成一个功能的装配

不同的扩展接口有不同的使用场景，只要实现了不同的接口

Spring 就会从 bean 被加载到最后初始化，根据不同的扩展接口执行不同的调用

Aware

若 Spring 检测到 bean 实现了 Aware 接口，则会为其注入相应的依赖

Aware 类型的接口的作用就是让我们能够拿到 Spring 容器中的一些资源，Aware 之前的名字就是可以拿到什么资源，例如 BeanNameAware 可以拿到 BeanName

所有的 Aware 方法都是在初始化阶段之前调用的！

Aware 分成两种类型：针对 BeanFactory 和 ApplicationContext 类型的容器提供的 Aware 接口

ApplicationContext 和 BeanFactory 的区别，可以从 ApplicationContext 继承的这几个接口入手，除去 BeanFactory 相关的接口就是 ApplicationContext 独有的功能

针对 BeanFactory 类型的容器提供的 Aware 接口有：

BeanNameAware：注入当前 bean 对应 beanName
BeanClassLoaderAware：注入加载当前 bean 的 ClassLoader
BeanFactoryAware：注入当前 BeanFactory 容器的引用

// 检查 Aware 相关接口并设置相关依赖
private void invokeAwareMethods(final String beanName, final 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);
        }
    }
}

以上是针对 BeanFactory 类型的容器

而对于 ApplicationContext 类型的容器，也提供了 Aware 接口，只不过这些 Aware 接口的注入实现，是通过 BeanPostProcessor 的方式注入的，但其作用仍是注入依赖

EnvironmentAware：注入 Enviroment，一般用于 获取配置属性
EmbeddedValueResolverAware：实现该接口能够获取 SpEL 解析器，用户的自定义注解需要支持 SpEL 表达式的时候可以使用
ApplicationContextAware(ResourceLoaderAware/ApplicationEventPublisherAware/MessageSourceAware)：注入 ApplicationContext 容器本身

// ApplicationContextAwareProcessor
private void invokeAwareInterfaces(Object bean) {
   if (bean instanceof EnvironmentAware) {
      ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
   }
   if (bean instanceof EmbeddedValueResolverAware) {
      ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
   }
   if (bean instanceof ResourceLoaderAware) {
      ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
   }
   if (bean instanceof ApplicationEventPublisherAware) {
      ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
   }
   if (bean instanceof MessageSourceAware) {
      ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
   }
   if (bean instanceof ApplicationContextAware) {
      ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
   }
}

BeanFactoryPostProcessor

Spring 允许 BeanFactoryPostProcessor 在容器实例化 bean 之前 读取配置元数据，这个机制可以让我们在真正的实例化 bean 之前对 BeanDefinition 进行修改

如配置文件中的数据库密码不能明文写在项目里，那就从密码中心拿到密码，然后注入
如可以把 bean 的 Scope 从 singleton 改为 prototype ，也可以把 property 的值给修改掉

此时 Bean 还未生成！！（注意和 BeanPostProcessor 区分开）

可以配置多个 BeanFactoryPostProcessor 实例，并且通过设置 order 属性，来控制这些 BeanFactoryPostProcessor 实例的运行顺序

BeanFactoryPostProcessor 的 postProcessBeanFactory 在 doCreateBean 之前，即 refresh 里面的 finishBeanFactoryInitialization 之前就执行完了

1
2
3

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

BeanPostProcessor

BeanPostProcessor 是 Spring 为修改 bean 提供的强大扩展点，其可作用于容器中所有 bean

BeanPostProcessor 可以在 Spring 容器实例化 bean 之后，在执行 bean 的初始化方法前后，添加一些自己的处理逻辑

注意：是实例化 bean 之后，在执行 bean 的初始化方法前后

BeanFactoryPostProcessor 是用来对 BeanFactory 中的 BeanDefinition 进行处理，此时 Bean 还未生成

而 BeanPostProcessor 用来对我们 生成的 Bean 进行处理，如果想要改变 Bean 实例，应该使用 BeanPostProcessor

同样

可以配置多个 BeanPostProcessor 实例，并且通过设置 order 属性，来控制这些 BeanPostProcessor 实例的运行顺序

BeanPostProcessor 分为两个方法，一个是用于初始化 前置处理，一个是用于初始化 后置处理

public interface BeanPostProcessor {
    // 初始化前置处理
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    // 初始化后置处理
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

常用场景有：

对于标记接口的实现类，进行自定义处理。例如 ApplicationContextAwareProcessor，为其注入相应依赖
自定义对实现解密接口的类，将对其属性进行解密处理
为当前对象提供代理实现。例如 Spring AOP 功能，生成对象的代理类，然后返回（AOP其实是在实例化之前就创建了，即 createBean 里面有一个 resolveBeforeInstantiation 方法，是给 BeanPostProcessor 一个机会来返回一个代理对象代替目标对象）

对于 BeanPostProcessor 和 BeanFactoryPostProcessor 的注册，可以看 refresh 方法

InitializingBean 和 init-method

实现 InitalizingBean 接口为 bean 初始化提供扩展，在 afterPropertiesSet() 方法写初始化逻辑

1
2
3

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

或在 xml 指定 init-method 方法

DisposableBean 和 destory-method 与上面类似

doCreateBean

// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(
    final String beanName, final RootBeanDefinition mbd, 
    final @Nullable Object[] args)
    throws BeanCreationException {

    // Instantiate the bean.
    // ...
    if (instanceWrapper == null) {
        // 实例化
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();
    // ...

    // Allow post-processors to modify the merged bean definition.
    // 此处处理这个接口的处理器：MergedBeanDefinitionPostProcessor
    // 他在 BeanPostProcessor 的基础上增加了 postProcessMergedBeanDefinition 方法，在此处就被调用了
	// 主要是处理 @PostConstruct,@Autowire,@Value,@Resource，@PreDestory 等这些注解
    // ...

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    // 这里面主要是解决循环引用问题
    // 如果当前 bean 是单例，且支持循环依赖，且当前 bean 正在创建，通过往 singletonFactories 添加一个 objectFactory
    // 这样后期如果有其他 bean 依赖该 bean 可以从 singletonFactories 获取到 bean
	// getEarlyBeanReference 可以对返回的 bean 进行修改，这边目前除了可能会返回动态代理对象 其他的都是直接返回 bean
	//这里主要是调用处理器：SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference 方法去寻找到前期的 Bean 们( 若存在这种处理器的话 )
    // ...

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 属性赋值，包括注解啥的
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        // ...
    }

    //如果 earlySingletonExposure 为 true，尝试从缓存获取该 bean( 一般存放在 singletonFactories 对象通过调用getObject 把对象存入earlySingletonObjects )
	// 分别从 singletonObjects 和 earlySingletonObjects 获取对象
    // 这里依然是处理循环依赖相关问题的
    if (earlySingletonExposure) {
        // ...
    }

    // Register bean as disposable.
    try {
        // 销毁-注册回调接口
        // 如果有需要，就注册 DisposableBean，这样Bean销毁的时候此种后置处理器也会生效了
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        // ...
    }

    return exposedObject;
}

initializeBean

// AbstractAutowireCapableBeanFactory
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // 检查 Aware 相关接口并设置相关依赖
    // ( 针对 BeanFactory 类型的容器提供的 Aware 接口 )
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    // BeanPostProcessor 前置处理
    // Aware 通过 BeanPostProcessor 的方式注入的
    // (针对 ApplicationContext 类型的容器提供的 Aware 接口)
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 若实现 InitializingBean 接口，调用 afterPropertiesSet 方法
    // 若配置自定义的 init-method 方法，则执行
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        // ...
    }
    
    // BeanPostProceesor 后置处理
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

destroy

public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }
    // 若实现 DisposableBean 接口，则执行 destory()方法
    if (this.invokeDisposableBean) {
        // ...logger
        // 若实现 DisposableBean 接口，则执行 destory()方法
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((DisposableBean) this.bean).destroy();
                    return null;
                }, this.acc);
            }
            else {
                ((DisposableBean) this.bean).destroy();
            }
        }
        catch (Throwable ex) {
            // ...logger
        }
    }

    // 若配置自定义的 detory-method 方法，则执行
    if (this.destroyMethod != null) {
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
        if (methodToInvoke != null) {
            invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
        }
    }
}