Spring Bean生命周期详解

最新推荐文章于 2021-05-23 20:01:46 发布

xinyuan_java

最新推荐文章于 2021-05-23 20:01:46 发布

阅读量371

点赞数

分类专栏： j2ee框架 java 文章标签： Spring Bean生命周期详解

java 同时被 2 个专栏收录

192 篇文章 3 订阅

订阅专栏

j2ee框架

51 篇文章 1 订阅

订阅专栏

1本文说明

本文所述基于Spring3.2.7，已由作者通过程序验证，如果和你理解的过程有所不同，首先请查看环境（春季版本，豆单例，非单例的豆级生命周期相关方法会多次执行）是否一样，其后最好自己手动写个测试程序测试一下。另外，本文结合Spring IoC容器初始化过程结合看更容易理解。
具体环境：
ApplicationContext context = new ClassPathXmlApplicationContext(path);
通过豆工厂创建或者网络环境，即web.xml文件文件中配置春季容器初始化监听器的的的ContextLoaderListener启动春季容器，或者其他方式，其中间或有其他外接接口，但这些对豆的生命周期并没有什么关系，但需要注意执行流程可能有增加。
豆工厂和的ApplicationContext中的对于豆后置处理器还有所不同，需要注意，的的的ApplicationContext会自动检测在配置文件中实现了BeanPostProcessor的的的接口的所有的豆腐，并把它们注册为后置处理器，然后在容器创建豆的适当时候调用它，因此部署一个后置处理器同部署其他的并没有豆什么区别。而使用的Bean工厂实现的时候，豆后置处理器必须通过代码显式地去注册。

2 Bean生命周期

概述

　　我们知道一个对象的生命周期：创建（实例化 - 初始化） - 使用 - 销毁，而在春天中，豆对象周期当然遵从这一过程，但是春季提供了许多对外接口，允许开发者对三个过程实例化，初始化，销毁）的前后做一些操作。
　　这里就实例化，初始化区别做一个说明，在Spring Bean中，实例化是为bean对象开辟空间（具体可以理解为构造函数的调用），初始化则是对属性的初始化，说的具体点，这里的属性初始化应该是属性的注入（构造函数也可以有属性的初始化语句，但不属于这一部分），属性注入是通过设置器方法注入属性（不管是注解方式还是豆配置属性属性方式，其实质都是通过属性的设置器方法实现的）。

豆具体生命周期

postprocessBeanFactory（ConfigurableListableBeanFactory c）
工厂后处理器（这名字其实只是一个翻译，感觉意义有的时候不一定正确），这个方法其实和Bean生命周期没多少关系，是IoC容器（ApplicationContext）初始化的一部分，详细的可以参考IoC容器初始化一节。具体是容器每次刷新时（初始化）调用，它是对BeanDefinition进行后处理（BeanDefinition可以参考：Spring IoC容器结构），具体的作用就是可以修改配置文件的各个bean的配置，
实现：写一个类，实现BeanFactoryPostProcessor的接口，重写该方法，并在春配置文件中配置该类的一个豆腐。
postProcessBeforeInstantiation（Class <？> c，String beanName）
所有bean对象（注1）实例化之前执行，具体点就是执行每个bean类构造函数之前。
实现：写一个类，实现InstantiationAwareBeanPostProcessor接口，重写该方法，在春天配置文件中配置该类的一个豆腐。返回一个对象，但是实际上你返回一个空即可。
豆实例化，调用豆类构造函数
postProcessAfterInstantiation（Object bean，String beanName）
bean类实例化之后，初始之前调用
实现：同第2步，重写该方法，但注意，返回类型这里是boolean，默认是false，你需要更改为true，否则无法注入属性
postProcessPropertyValue（属性名太长，详细查看代码实现）
属性注入之前调用
实现：同第2步，重写该方法，注意返回类型是的PropertyValue，默认返回空值，这里需改为返回第一个参数，详见代码章节3。
setBeanName（String beanName）
属性注入后调用，该方法作用是让Bean类知道自己所在的Bean的名字或者id属性。
实现：Bean类实现BeanNameAware接口，重写该方法。
setBeanFactory（BeanFactory factory）
setBeanName后调用，该方法作用是让Bean类知道自己所在的BeanFactory的属性（传入bean所在的BeanFactory类型参数）。
实现：Bean类实现BeanFactoryAware接口，实现该方法。
postProcessBeforeInitialization（对象豆，字符串beanName）
的BeanPostProcessor作用是对豆实例化，初始化做预处理操作（注2）。
实现：写一个类，实现BeanPostProcessor的接口，注意返回类型为对象，默认返回空，需要返回参数中豆。
postProcessBeforeInitialization（Object bean，Strign beanName）
实现：同第2步，实现该方法，注意点同第8步。（注3）
的
实现：bean类实现的InitializingBean接口，重写该方法的初始化工作，但实现该接口这种方法和弹簧耦合，不推荐（这一点DisposableBean的一样）
11. xml_init（）
实现：弹簧豆配置文件中配置豆属性初始化方法=“xml_init”，这个方法名开发者自己定义，与弹簧代码解耦。另外需要注意的是，初始化方法指定的方法不能有参数，有参数抛异常-方法一样）。
postProcessAfterInitialization（Object bean，Strign beanName）
实现：同第8步，注意点相同。
postProcessAfterInitialization（Object bean，Strign beanName）
实现：同第2步，注意点同第9步。
程序执行，豆工作
销毁（）
bean销毁前执行
实现：bean类实现DisposableBean接口
xml_destroy（）
实现：这个方法名开发者自己定义。

注1：这里的豆类指的是普通豆类，不包括这里实现了各类接口（就是2.2提到的这些接口）而在配置文件中声明的豆。
注2：如果有多个的的BeanPostProcessor的实现类，其执行顺序参考：的的BeanPostProcessor的详解。
注3：InstantiationAwareBeanPostProcessor接口继承自的BeanPostProcessor的的接口，是它的子接口，扩展了两个方法，即豆实例化前后操作，当然前者也会有豆初始化前后操作，当它们两同时存在的话，开发者又同时对两者的postProcessBeforeInitialization，postProcessAfterInitialization方法实现了，先回去执行的的BeanPostProcessor的的方法，再去执行InstantiationAwareBeanPostProcessor的。

3代码实现

1.bean类

package com.fcc.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

import java.io.Serializable;

/**
 * Created by fuchaochao on 16/8/5.
 */
public class HelloWorld implements BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean{
    private String message;

    public HelloWorld(){
        System.out.println("3.HelloWorld struct.......");
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public void xml_init(){
        //xml开头的表示配置文件配置,这里是bean配置中init-method配置调用
        System.out.println("11.HelloWorld 初始化(init-method)");
    }
    public void xml_destroy(){
        //destroy-method 配置调用
        System.out.println("16.HelloWorld 销毁(destroy-method)");
    }

    public void setBeanName(String s) {
        //属性注入后调用
        System.out.println("6.setBeanName(BeanNameAware) 属性注入后调用, 此时s = " + s);
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        //setBeanName 后调用
        System.out.println("7.setBeanFactory(BeanFactory) setBeanName后调用");
    }

    public void afterPropertiesSet() throws Exception {
        //processBeforeInitialization(BeanPostProcessor)后调用
        System.out.println("10.afterPropertiesSet(InitializingBean) processBeforeInitialization之后,配置的xml_init之前调用");
    }

    public void destroy() throws Exception {
        System.out.println("15.destroy(DisposableBean) 在processAfterInitialization之后,配置的xml_destroy之前调用");
    }
}

1
2
3
4
五
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
三十
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2.BeanFactoryPostProcessor类

package com.fcc.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

/**
 * Created by fuchaochao on 16/8/12.
 */
public class BeanFactoryPostProcessorTest implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        //configurableListableBeanFactory.getBeanDefinition("appcontext-service.xml");
        System.out.println("1.postProcessBeanFactory(BeanFactoryPostProcessor) 工厂后处理器, ApplicationContext容器初始化中refresh()中调用");
    }
}

3.BeanPostProcessor类

package com.fcc.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * Created by fuchaochao on 16/8/12.
 */
public class InitBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("8.postProcessBeforeInitialization(BeanPostProcessor), bean = " + o.getClass());
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("12.postProcessAfterInitialization(BeanPostProcessor), bean = " + o.getClass());
        return o;
    }
}

4.InstantiationAwareBeanPostProcessor类

package com.fcc.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

import java.beans.PropertyDescriptor;
import java.util.Arrays;

/**
 * Created by fuchaochao on 16/8/12.
 */
public class InstanceBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    public Object postProcessBeforeInstantiation(Class<?> aClass, String s) throws BeansException {
        System.out.println("2.实例化bean之前调用,即调用bean类构造函数之前调用 " + aClass.getName());
        /*try {
            return Class.forName(""+aClass);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }*/
        return null;//其实我不是很明白这里返回值得作用,之后可能会去深入理解
    }

    public boolean postProcessAfterInstantiation(Object o, String s) throws BeansException {
        System.out.println("4.返回boolean,bean实例化后调用,并且返回false则不会注入属性");
        return true;
    }

    public PropertyValues postProcessPropertyValues(PropertyValues propertyValues, PropertyDescriptor[] propertyDescriptors, Object o, String s) throws BeansException {
        System.out.println("5.postProcessPropertyValues,在属性注入之前调用...... beanName = " + s + " 属性名集合 : " + Arrays.toString(propertyValues.getPropertyValues()));
        //System.out.println("message = " + ((HelloWorld)o).getMessage()); 这里可以看到message还是null
        return propertyValues;//这里要返回propertyValues,否则属性无法注入
    }

    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("9.postProcessBeforeInitialization(InstantiationAwareBeanPostProcessor) ");
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("13.postProcessAfterInitialization(InstantiationAwareBeanPostProcessor) ");
        return o;
    }
}

1
2
3
4
五
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
三十
31
32
33
34
35
36
37
38
39
40
41
42
43
44

5.测试类SpringTest2

package com.fcc.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by fuchaochao on 16/8/12.
 */
public class SpringTest2 {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:config/spring/local/appcontext-*.xml");
        HelloWorld obj = (HelloWorld)context.getBean("helloWorld");
        System.out.println("14.Bean working, message = " + obj.getMessage());
        //((ClassPathXmlApplicationContext)context).refresh();
        ((ClassPathXmlApplicationContext)context).close();
    }
}

6.Spring Bean配置文件appcontext-service.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
                            ">

   <context:component-scan base-package="com.fcc.spring.test.*" />

    <bean id="helloWorld" class="com.fcc.spring.test.HelloWorld" init-method="xml_init" destroy-method="xml_destroy">
        <property name="message" value="Hello World!" />
    </bean>

    <bean class="com.fcc.spring.test.InitBeanPostProcessor" />
    <bean class="com.fcc.spring.test.InstanceBeanPostProcessor" />
    <bean class="com.fcc.spring.test.BeanFactoryPostProcessorTest" />
</beans>

7.结果代码：

八月 12, 2016 5:19:48 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@27b4fe4d: startup date [Fri Aug 12 17:19:48 CST 2016]; root of context hierarchy
八月 12, 2016 5:19:48 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from file [/Users/fuchaochao/joy/spring-test2/target/classes/config/spring/local/appcontext-service.xml]
1.postProcessBeanFactory(BeanFactoryPostProcessor) 工厂后处理器, ApplicationContext容器初始化中refresh()中调用
2.实例化bean之前调用,即调用bean类构造函数之前调用 com.fcc.spring.test.HelloWorld
3.HelloWorld struct.......
4.返回boolean,bean实例化后调用,并且返回false则不会注入属性
5.postProcessPropertyValues,在属性注入之前调用...... beanName = helloWorld 属性名集合 : [bean property 'message']
八月 12, 2016 5:19:48 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@3ae4cdc3: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,helloWorld,com.fcc.spring.test.InitBeanPostProcessor#0,com.fcc.spring.test.InstanceBeanPostProcessor#0,com.fcc.spring.test.BeanFactoryPostProcessorTest#0,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
6.setBeanName(BeanNameAware) 属性注入后调用, 此时s = helloWorld
7.setBeanFactory(BeanFactory) setBeanName后调用
8.postProcessBeforeInitialization(BeanPostProcessor), bean = class com.fcc.spring.test.HelloWorld
9.postProcessBeforeInitialization(InstantiationAwareBeanPostProcessor) 
10.afterPropertiesSet(InitializingBean) processBeforeInitialization之后,配置的xml_init之前调用
11.HelloWorld 初始化(init-method)
12.postProcessAfterInitialization(BeanPostProcessor), bean = class com.fcc.spring.test.HelloWorld
13.postProcessAfterInitialization(InstantiationAwareBeanPostProcessor) 
14.Bean working, message = Hello World!
八月 12, 2016 5:19:48 下午 org.springframework.context.support.AbstractApplicationContext doClose
15.destroy(DisposableBean) 在processAfterInitialization之后,配置的xml_destroy之前调用
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@27b4fe4d: startup date [Fri Aug 12 17:19:48 CST 2016]; root of context hierarchy
16.HelloWorld 销毁(destroy-method)
八月 12, 2016 5:19:48 下午 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry destroySingletons
信息: Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@3ae4cdc3: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,helloWorld,com.fcc.spring.test.InitBeanPostProcessor#0,com.fcc.spring.test.InstanceBeanPostProcessor#0,com.fcc.spring.test.BeanFactoryPostProcessorTest#0,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy

Process finished with exit code 0

结果代码的详细解析查看下一节：Spring IoC初始到Bean应用到容器销毁全过程。

总结

豆生命周期流程图：
这里写图片描述

xinyuan_java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Spring Bean生命周期详解

1本文说明本文所述基于Spring3.2.7，已由作者通过程序验证，如果和你理解的过程有所不同，首先请查看环境（春季版本，豆单例，非单例的豆级生命周期相关方法会多次执行）是否一样，其后最好自己手动写个测试程序测试一下。另外，本文结合Spring IoC容器初始化过程结合看更容易理解。具体环境：ApplicationContext context = new ClassPathXmlAppl...
复制链接

扫一扫