精华内容
下载资源
问答
  • Spring Bean生命周期

    2018-04-23 18:51:34
    spring 的两大核心,IOC与AOP,IOC主要用来管理bean的依赖,耦合代码,但是spring的bean的生命周期也是需要深入理解的,bean...Spring Bean生命周期 关于bean的生命周期大致分为三个类型: - bean自身的方法 ...

    spring 的两大核心,IOC与AOP,IOC主要用来管理bean的依赖,耦合代码,但是spring的bean的生命周期也是需要深入理解的,bean交给spring管理了,但是项目中难免会要在bean加载或者销毁的时候对bean做一些操作,所以更需要对bean的生命周期更深入的了解。

    Spring Bean生命周期

    关于bean的生命周期大致分为三个类型:

    • bean自身的方法
      主要配置文件的init-method和destroy-method配置的方法,以及bean对象自己调用的方法
    • bean级生命周期接口方法
      主要调用实现的一些接口方法
      InitializingBean,BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean
    • 容器级生命周期接口方法
      主要调用后置处理器实现中重写的方法

    通过代码校验bean生命周期中执行各个方法的顺序

    定义一个测试类,实现bean级生命周期的接口。

    public class SpringTest implements InitializingBean ,BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean{
    	
    	public void initMethod(){
    		System.out.println("执行配置文件中的init-method方法");
    	}
    	
    	public SpringTest(){
    		System.out.println("执行测试类的初始化方法");
    	}
    
    	@Override
    	public void afterPropertiesSet() throws Exception {
    		System.out.println("执行InitializingBean的afterProperties方法");
    	}
    
    	@Override
    	public void setBeanName(String name) {
    		System.out.println("执行BeanNameAware的setbeanName方法"+name);
    	}
    
    	@Override
    	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    		System.out.println("执行BeanFactoryAware方法");
    	}
    
    	public void testMethod() {
    		System.out.println("执行测试类自己的方法");
    		
    	}
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    		System.out.println("执行测试类的ApplicationContextAware方法");
    	}
    
    	@Override
    	public void destroy() throws Exception {
    		System.out.println("执行销毁方法");
    		
    	}
    	
    	public void destoryMethod(){
    		System.out.println("执行销毁配置文件的方法");
    	}
    }
    
    

    定义一个后置处理器

    public class MyBeanPostProcessor implements BeanPostProcessor {
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("后置处理器在init之后执行");
    		return bean;
    	}
    	
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("后置处理器在init之前执行");
    		return bean;
    	}
    
    }
    

    xml中配置bean以及后置处理器

    <bean id="myBeanPostProcessor" class="com.springmvc.MyBeanPostProcessor"></bean>
    <bean id="springTest" class="com.springmvc.SpringTest" init-method="initMethod" destroy-method="destoryMethod"></bean>
    

    定义一个main方法初始化容器,获取bean,然后销毁容器

    public static void main(String[] args) {
    		ApplicationContext context = new  ClassPathXmlApplicationContext("spring.xml");
    		SpringTest test = (SpringTest) context.getBean("springTest");
    		test.testMethod();
    		//销毁容器
    		((ClassPathXmlApplicationContext)context).registerShutdownHook();
    	}
    

    执行之后打印信息如下:
    打印信息

    根据如上打印信息,可以知道Spring Bean的生命周期:
    1.初始化bean,调用构造方法
    2.如果实现了BeanNameAware接口,调用其setBeanName方法
    3.如果实现了BeanFactoryAware接口,调用其setBeanFactory方法
    4.如果实现了ApplicationContextAware,调用其setApplicationContext方法
    5.如果配置了后置处理器,调用其postProcessBeforeInitialization方法
    6.如果实现了InitializingBean调用其afterPropertiesSet方法
    7.如果xml中配置了init方法,调用init方法
    8.如果配置了后置处理器,调用其postProcessAfterInitialization方法
    9.调用bean的自己的方法
    10销毁的时候如果实现了DisDisposableBean,则调用其destroy方法
    11如果xml中配置了的destroy方法,调用其destroy方法

    关于bean的生命周期就是以上的几个步骤,需要具体做的操作,可以根据具体的业务需求来修改bean或者context的一些属性,但是项目中一般情况是不需要修改的

    展开全文
  • Spring Bean 生命周期

    2018-10-19 11:36:10
    Spring Bean 生命周期 前言 Spring Bean生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。 首先看下生命周期图: 再谈生命周期之前有一点需要先明确: Spring 只帮我们管理...

    Spring Bean 生命周期

    前言

    Spring Bean 的生命周期在整个 Spring 中占有很重要的位置,掌握这些可以加深对 Spring 的理解。

    首先看下生命周期图:

    再谈生命周期之前有一点需要先明确:

    Spring 只帮我们管理单例模式 Bean 的完整生命周期,对于 prototype 的 bean ,Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

    • Spring从XML配置文件或注解标注的元数据加载Bean的信息,并用Spring的内部数据结构BeanDefinition储存所管理的Bean,完成元数据到内部数据结构的映射,然后将BeanDefinition注册到所属的Bean容器,也就是BeanFactory或是ApplicationContext。此时还未实例化生成Bean对象,待有对某一对象实例的请求时,Spring将利用BeanDefiniton

      实例化生成相应Bean对象。接着,就开始进入Bean的生命周期过程。概括起来,从实例化到销毁,共经过10个环节,具体流程如下

    1.Spring对Bean进行实例化,相当于new的过程。

    2.完成DI即依赖注入,将依赖的值和引用注入到Bean对应的属性中。

    3.判断当前实例化的Bean是否implements接口BeanNameAware,Spring将调用接口方法setBeanName(),传入Bean的ID;

    4.判断当前实例化的Bean是否implements接口BeanFactoryAware,Spring将调用接口方法setBeanFactory(),传入BeanFactory容器实例;

    5.判断当前实例化的Bean是否implements接口ApplicationContextAware,Spring将调用接口方法setApplicationContext(),传入Bean所在的ApplicationContext实例;

    6.判断当前实例化的Bean是否implements接口BeanPostProcessor,Spring将调用接口方法postProcessBeforeInitialization();

    7.判断当前实例化的Bean是否implements接口InitializingBean,Spring将调用接口方法afterPropertiesSet()。如果Bean的init-method属性设置了初始化方法,则该方法也会被调用;

    8.判断当前实例化的Bean是否implements接口BeanPostProcessor,Spring将调用接口方法postProcessAfterInitialization();

    9.此时,Bean已准备就绪,可以被应用程序使用,并驻留在Spring应用上下文中,直到销毁;

    10.当销毁Bean时,判断该Bean是否implements接口DisposableBean,Spring将调用接口方法destroy()。如果Bean的destroy-method属性设置了销毁方法,则该方法也会被调用。
    ---------------------

    展开全文
  • springBean生命周期

    千次阅读 多人点赞 2020-12-18 14:46:36
    一、springBean生命周期 1、 启动spring容器,也就是创建beanFactory(bean工厂), 一般用的是beanFactory的子类applicationcontext, applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。 通过...

    一、springBean的生命周期

    1、  启动spring容器,也就是创建beanFactory(bean工厂),
         一般用的是beanFactory的子类applicationcontext,
         applicationcontext比一般的beanFactory要多很多功能,比如aop、事件等。
         通过applicationcontext加载配置文件,或者利用注解的方式扫描将bean
         的配置信息加载到spring容器里面。
    
     2、  加载之后,spring容器会将这些配置信息(java bean的信息),封装成BeanDefinition对象
          BeanDefinition对象其实就是普通java对象之上再封装一层,
          赋予一些spring框架需要用到的属性,比如是否单例,是否懒加载等等。
    
    3、  然后将这些BeanDefinition对象以key为beanName,
         值为BeanDefinition对象的形式存入到一个map里面,
         将这个map传入到spring beanfactory去进行springBean的实例化。
      
    4、  传入到pring beanfactory之后,利用BeanFactoryPostProcessor接口这个扩展点
         去对BeanDefinition对象进行一些属性修改。
    
    5、  开始循环BeanDefinition对象进行springBean的实例化,springBean的实例化也就
         是执行bean的构造方法(单例的Bean放入单例池中,但是此刻还未初始化),
         在执行实例化的前后,可以通过InstantiationAwareBeanPostProcessor扩展点
         (作用于所有bean)进行一些修改。
    
    6、   spring bean实例化之后,就开始注入属性,
          首先注入自定义的属性,比如标注@autowrite的这些属性,
          再调用各种Aware接口扩展方法,注入属性(spring特有的属性),
          比如BeanNameAware.setBeanName,设置Bean的ID或者Name;
    
    7、   初始化bean,对各项属性赋初始化值,,初始化前后执行BeanPostProcessor
          (作用于所有bean)扩展点方法,对bean进行修改。
    
          初始化前后除了BeanPostProcessor扩展点还有其他的扩展点,执行顺序如下:
    
            (1). 初始化前                	   postProcessBeforeInitialization()
            (2). 执行构造方法之后                执行 @PostConstruct 的方法
            (3). 所有属性赋初始化值之后           afterPropertiesSet()
            (4). 初始化时              	       配置文件中指定的 init-method 方法
            (5). 初始化后                	   postProcessAfterInitialization()
    
    		先执行BeanPostProcessor扩展点的前置方法postProcessBeforeInitialization(),
    		再执行bean本身的构造方法
    		再执行@PostConstruct标注的方法
    		所有属性赋值完成之后执行afterPropertiesSet()
    		然后执行 配置文件或注解中指定的 init-method 方法
    		最后执行BeanPostProcessor扩展点的后置方法postProcessAfterInitialization()
    
    8、     此时已完成bean的初始化,在程序中就可以通过spring容器拿到这些初始化好的bean。
    
    9、     随着容器销毁,springbean也会销毁,销毁前后也有一系列的扩展点。
      		销毁bean之前,执行@PreDestroy 的方法
    	    销毁时,执行配置文件或注解中指定的 destroy-method 方法。
    
    
      		以上就是spring bean的整个生命周期
    
      		其实就是根据配置文件或注解信息,生成BeanDefinition,
      		循环BeanDefinition去实例化-》注入属性-》初始化-》销毁,在这4个阶段执行前后,
      		spring框架提供了一系列的扩展点。
    

    二、springBean的各种扩展点

    (1)、容器级扩展点(作用于所有bean):
    
    	BeanFactoryPostProcessor接口:
    	
    	在循环初始化springbean之前,对BeanDefinition元数据做扩展处理
    	
    	InstantiationAwareBeanPostProcessor接口:
    	
    	在对象实例化前后扩展,作用于所有bean
    	
    	BeanPostProcessor接口:
    	
    	在对象初始化化前后扩展,作用于所有bean
    
    (2)、Bean扩展点(作用于单个bean):
    
    	Aware接口:
    	
    	springBean实例化并且注入自定义属性之后
    	
    	InitializingBean接口:
    	
    	springBean初始化时,执行构造方法结束,并且属性赋初始化值结束之后执行
    	
    	DiposableBean接口:
    	
    	springBean销毁之前执行。
    
    (3)、Bean自身的方法
    
    	包括了Bean本身调用的方法
    	
    	通过配置文件中<bean>的init-method和destroy-method指定的方法(或者用注解的方式)
    	
    	(4)、包括了AspectJWeavingEnabler, 
    	 ConfigurationClassPostProcessor, 
    	 CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。
    	 工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。
    
    展开全文
  • Spring Bean生命周期详解

    万次阅读 多人点赞 2016-08-12 17:40:08
    Spring Bean生命周期详解

    Spring Bean生命周期详解


    1 本文说明

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

    2 Bean生命周期

    概述

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

    相关接口、方法说明

    1. Bean自身方法:init-method/destroy-method,通过为配置文件bean定义中添加相应属性指定相应执行方法。
    2. Bean级生命周期接口:BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法。每个Bean选择实现,可选择各自的个性化操作。
    3. 容器级生命周期接口方法:这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现(前者继承自后者),一般称它们的实现类为“后处理器”(其实我觉得这个名称对新手有误导的意思),这些接口是每个bean实例化或初始化时候都会调用。
    4. 工厂后处理器接口方法:这些方法也是容器级别的,但它们是在上下文装置配置文件之后调用,例如BeanFactoryPostProcessor、 CustomAutowireConfigurer等。
      (这里说一点,这些类名都很长,有的也挺相似,学习的话要仔细看清楚哪个是哪个。)

    Bean具体生命周期

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

    注1:这里的bean类指的是普通bean类,不包括这里实现了各类接口(就是2.2提到的这些接口)而在配置文件中声明的bean。
    注2:如果有多个BeanPostProcessor实现类,其执行顺序参考:BeanPostProcessor详解。
    注3:InstantiationAwareBeanPostProcessor接口继承自BeanPostProcessor接口,是它的子接口,扩展了两个方法,即bean实例化前后操作,当然前者也会有bean初始化前后操作,当它们两同时存在的话,开发者又同时对两者的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之前调用");
        }
    }

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

    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应用到容器销毁全过程。

    总结

    bean生命周期流程图:
    这里写图片描述

    展开全文
  • SpringBean生命周期详解

    千次阅读 2020-10-28 17:51:28
    SpringBean生命周期详解 一、简述: Spring是我们每天都在使用的框架,Bean是被Spring管理的Java对象,是Spring框架最重要的部分之一,那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从...
  • Spring bean生命周期

    2013-12-11 17:07:52
      在传统的Java应用中,Bean生命周期非常...理解Spring Bean生命周期非常重要,因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入
  • spring bean生命周期

    2014-06-03 20:50:21
    Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务Spring IOC容器对Bean的生命周期进行管理的过程: 通过构造器或工厂方法创建Bean实例为Bean的属性设置值和对其他Bean的...
  • Spring Bean生命周期理解

    千次阅读 2018-05-01 14:12:46
    Spring Bean生命周期理解 Spring Bean生命周期理解 BeanFactory接口是Spring的首要核心接口,要学习Spring必须对此接口深度理解。在阅读此接口源码的时候,刚好发现了接口文档对应的就是SpringBean的生命周期...
  • spring bean生命周期spring bean生命周期之单例spring bean生命周期之原型(prototype)spring bean生命周期之具有原型bean依赖单例beanspring bean之Request, session, application,以及WebSocket生命周期spring bean...
  • 文章目录Spring Bean 生命周期Spring 中的设计模式1. 代 理 模 式2. 单例模式3. 模板方法模式4. 前端控制器模式5. 视图帮助(View Helper )6. 依赖注入7. 工厂模式 Spring Bean 生命周期 Spring Bean的完整生命周期...
  • Spring bean 生命周期管理

    千次阅读 2016-02-08 21:20:06
    Spring bean 生命周期管理    For a bean to get into a usable state after instantiation, it needs to perform some initialization. Likewise, some clean up may be necessary when the bean is no lon
  • 谈谈我对Spring Bean 生命周期的理解 https://www.jb51.net/article/136825.htm SpringBean的作用域及生命周期 https://cloud.tencent.com/developer/article/1377825 Spring Bean生命周期在整个 Spring ...
  • Spring Bean 生命周期之destroy——终极信仰
  • 文章目录Bean生命周期概述Demo Bean生命周期概述 说到Spring Bean的生命周期,其实就是探究Spring Bean实例化经历哪些步骤了 本篇博文先给个整体的解读,下文将从源码上来探究Spring Bean的生命周期过程。 Demo ...
  • Spring5源码 - 06 Spring Bean 生命周期流程 概述 01 接上文 finishBeanFactoryInitialization /** * Finish the initialization of this context's bean factory, * initializing all remaining singleton ...
  • 在优锐课最新Java架构学习分享中,了解有关使用Aware接口访问Spring bean生命周期事件的更多信息,详细的思维导图让在迷茫中的人眼前一亮。码了很多专业的相关知识, 分享给大家参考学习。 Spring Aware界面允许你...
  • Java spring bean 生命周期

    千次阅读 2013-03-03 23:46:43
    Spring bean生命周期 在传统的Java应用中,Bean的生命周期非常简单。 Java的关键词new用来实例化Bean(或许他是非序列化的)。这样就够用了。 相反,Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的...
  • 一、Spring Bean的概念 Spring bean通常来说是指被Spring容器所管理的java对象;而spring容器就是负责实例化、配置和装配Spring bean; 二、Spring Bean容器 Spring Bean容器可以获取Spring Bean,通过BeanFacroty...
  • 目录 1 生命周期流程 2 Bean生命周期验证 1 生命周期流程 在spring中,从BeanFactory或ApplicationContext取得的实例为Singleton,也就是预设为每一个Bean的别名只能维持一...Spring Bean的完整生命周期从创建S
  • Spring ApplicationContext容器的Bean生命周期有13步,而后三步容器关闭和实现接口的destroy()方法和自定义的销毁方法是不可见的。 在前九步【new ClassPathXmlApplicationContext("xx.xml"),加载容器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,411
精华内容 30,564
关键字:

springbean生命周期

spring 订阅