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”属性设定方法名称，如下：

<bean id="demoBean" class="com.yangsq.bean.DemoBean" init-method="initMethod">
  .......
 </bean>

      这时会执行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”定义的方法

<bean id="demoBean" class="com.yangsq.bean.DemoBean" destory-method="destroyMethod">
  .......
</bean>

       这时会执行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;
    }

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