Spring Bean生命周期

下面以BeanFactory为例，说明一个Bean的生命周期活动：

Bean的建立(doCreateBean)

由BeanFactory读取Bean定义文件，并生成各个实例。

Setter注入(populateBean)
```
initializeBean(invokeAwareMethods)
```

执行Bean的属性依赖注入。

BeanNameAware的setBeanName()

如果Bean类实现了org.springframework.beans.factory.BeanNameAware接口，则执行其setBeanName()方法。

BeanFactoryAware的setBeanFactory()

如果Bean类实现了org.springframework.beans.factory.BeanFactoryAware接口，则执行其setBeanFactory()方法。

BeanPostProcessors的processBeforeInitialization()

容器中如果有实现org.springframework.beans.factory.BeanPostProcessors接口的实例，则任何Bean在初始化之前都会执行这个实例的processBeforeInitialization()方法。

InitializingBean的afterPropertiesSet()

如果Bean类实现了org.springframework.beans.factory.InitializingBean接口，则执行其afterPropertiesSet()方法。

Bean定义文件中定义init-method

在Bean定义文件中使用“init-method”属性设定方法名称，如下：

这时会执行initMethod()方法，注意，这个方法是不带参数的。

BeanPostProcessors的processAfterInitialization()

容器中如果有实现org.springframework.beans.factory.BeanPostProcessors接口的实例，则任何Bean在初始化之前都会执行这个实例的processAfterInitialization()方法。

DisposableBean的destroy()

在容器关闭时，如果Bean类实现了org.springframework.beans.factory.DisposableBean接口，则执行它的destroy()方法。

Bean定义文件中定义destroy-method

在容器关闭时，可以在Bean定义文件中使用“destory-method”定义的方法

这时会执行destroyMethod()方法，注意，这个方法是不带参数的。

以上就是BeanFactory维护的一个Bean的生命周期。下面这个图可能更直观一些：

如果使用ApplicationContext来维护一个Bean的生命周期，则基本上与上边的流程相同，只不过在执行BeanNameAware的setBeanName()后，若有Bean类实现了org.springframework.context.ApplicationContextAware接口，则执行其setApplicationContext()方法，然后再进行BeanPostProcessors的processBeforeInitialization()

实际上，ApplicationContext除了向BeanFactory那样维护容器外，还提供了更加丰富的框架功能，如Bean的消息，事件处理机制等。

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean
  - 　getInstantiationStrategy().instantiate(mbd, beanName, parent) //创建对象
    - 　BeanUtils.instantiateClass(constructorToUse);
- populateBean(beanName, mbd, instanceWrapper); //为bean生成属性
- initializeBean(beanName, exposedObject, mbd);
  - org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods //通知setname, setBeanFactroy
  - org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization //前置通知
  - org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods // 调用init-method
  - org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization //后置通知

    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);
            }
        }
    }

initializeBean()方法为容器产生的Bean 实例对象添加BeanPostProcessor 后置处理器

    //初始容器创建的Bean 实例对象，为其添加BeanPostProcessor 后置处理器
    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
     //JDK 的安全机制验证权限
        if (System.getSecurityManager() != null) {
     //实现PrivilegedAction 接口的匿名内部类
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        } else {
     　　    //为Bean 实例对象包装相关属性，如名称，类加载器，所属容器等信息
            invokeAwareMethods(beanName, bean);
        }
        Object wrappedBean = bean;
     //对BeanPostProcessor 后置处理器的postProcessBeforeInitialization
     //回调方法的调用，为Bean 实例初始化前做一些处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
     //调用Bean 实例对象初始化的方法，这个初始化方法是在Spring Bean 定义配置
     //文件中通过init-Method 属性指定的
        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        } catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init Method failed", ex);
        }
     //对BeanPostProcessor 后置处理器的postProcessAfterInitialization
     //回调方法的调用，为Bean 实例初始化之后做一些处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

    @Override
     //调用BeanPostProcessor 后置处理器实例对象初始化之前的处理方法
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
     //遍历容器为所创建的Bean 添加的所有BeanPostProcessor 后置处理器
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
     //调用Bean 实例所有的后置处理中的初始化前处理方法，为Bean 实例对象在
     //初始化之前做一些自定义的处理操作
            Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

    @Override
     //调用BeanPostProcessor 后置处理器实例对象初始化之后的处理方法
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
     //遍历容器为所创建的Bean 添加的所有BeanPostProcessor 后置处理器
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
     //调用Bean 实例所有的后置处理中的初始化后处理方法，为Bean 实例对象在
                          //初始化之后做一些自定义的处理操作
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

AOP 创建代理过程

AOP 调用过程

Spring AOP源码分析

Spring 的AOP 是通过接入BeanPostProcessor 后置处理器开始的，它是Spring IOC 容器经常使用到的一个特性，这个Bean 后置处理器是一个监听器，可以监听容器触发的Bean 声明周期事件。后置处理器向容器注册以后，容器中管理的Bean 就具备了接收IOC 容器事件回调的能力。

BeanPostProcessor 后置处理器的调用发生在Spring IOC 容器完成对Bean 实例对象的创建和属性的依赖注入完成之后.

方法`org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean` 中, 为容器产生的Bean 实例对象添加BeanPostProcessor 后置处理器

//为Bean 实例对象包装相关属性，如名称，类加载器，所属容器等信息
invokeAwareMethods(beanName, bean);

//对BeanPostProcessor 后置处理器的postProcessBeforeInitialization
//回调方法的调用，为Bean 实例初始化前做一些处理
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

//调用Bean 实例对象初始化的方法，这个初始化方法是在Spring Bean 定义配置
//文件中通过init-Method 属性指定的
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}

//对BeanPostProcessor 后置处理器的postProcessAfterInitialization
//回调方法的调用，为Bean 实例初始化之后做一些处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

return wrappedBean;

在Spring 中，BeanPostProcessor 的实现子类非常的多，分别完成不同的操作，如：AOP 面向切面编程的注册通知适配器、Bean 对象的数据校验、Bean 继承属性、方法的合并等等，

下面我们来分析其中一个创建AOP 代理对象的子类AbstractAutoProxyCreator 类。该类重写了postProcessAfterInitialization()方法。

//org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

代理对象生成了，那切面是如何织入的？

posted @ 2019-04-18 20:26 龘人上天阅读(130) 评论(0) 编辑收藏举报

刷新页面返回顶部

肥龙上天

Spring Bean生命周期

公告