Spring注解驱动第八讲--容器中bean的生命周期

bean的生命周期指的就是bean在容器中的:

  创建-->初始化-->销毁;

以上的过程都是由容器来进行管理.

我们可以自定义初始化和销毁方法,的那个进行到当前bean的生命周期的时候,调用我们自己定义的初始化方法和销毁方法.那么自定义初始化和销毁方法有以下四种方式:

1,指定初始化和销毁方法:

  在以往使用xml配置文件的时候可以在<bean>标签中加上"init-method"和"destory-method"属性来指定自定义的初始化和销毁方法,本文将不进行详细介绍;

2,使用@Bean注解的initMethod属性和destoryMethod属性来指定初始化方法和销毁方法

创建主配置类

@Configuration
public class MyconfigOfLifeCycle {
    @Bean(initMethod="init",destroyMethod="destory")//指定销毁和初始化方法,初始化方法是在创建对象之后执行,销毁方法是在容器关闭时执行
    public Mouse mouse() {
        return new Mouse() ;
    }
}

创建Mouse的类

public class Mouse {
    public Mouse() {
        System.out.println("构造器创建Mouse...........");
    }
    public void init() {
        System.out.println("初始化Mouse...........");
    }
    public void destory() {
        System.out.println("销毁Mouse...........");
    }
}

测试类:

public class IOCTest_lifeCycle {
    @Test
    public void test01(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyconfigOfLifeCycle.class);
        System.out.println("容器创建完成.........");
        applicationContext.close();//关闭容器,关闭容器时,才会调用destory方法
    }
}

运行结果:

七月 23, 2019 9:15:52 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext prepareRefresh
信息: Refreshing org.spring[email protected]311d617d: startup date [Tue Jul 23 21:15:52 CST 2019]; root of context hierarchy
构造器创建Mouse...........
初始化Mouse...........
容器创建完成.........
七月 23, 2019 9:15:52 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.spring[email protected]311d617d: startup date [Tue Jul 23 21:15:52 CST 2019]; root of context hierarchy
销毁Mouse...........

可以观察到,容器先去创建bean实体,然后进行初始化方法,当容器销毁时,对象也随之销毁.

注:在多实例的情况下,容器不会去创建bean,只有在调用时才会执行,创建方法和初始化方法,而关闭容器时容器也不会销毁对象实例.

2,将Bean的类实现InitializingBean和DisposableBean接口.

/**
 * InitializingBean接口中含有afterPropertiesSet方法,即在bean进行创建之后开始执行
 * DisposableBean接口中含有destroy方法,即在BeanFatory销毁的时候开始执行销毁方法
 *
 */
@Component//让容器可以扫描到
public class Cat implements InitializingBean,DisposableBean{
    public Cat() {
        System.out.println("创建Cat............");
    }
    public void destroy() throws Exception {
        System.out.println("初始化Cat............");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("销毁Cat............");
    }

}

在主配置类中通过@ComponentScan注解扫描包下的bean

再一次执行测试类,运行结果如下:

创建Cat............
销毁Cat............
构造器创建Mouse...........
初始化Mouse...........
容器创建完成.........
七月 23, 2019 9:31:27 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.spring[email protected]311d617d: startup date [Tue Jul 23 21:31:26 CST 2019]; root of context hierarchy
销毁Mouse...........
初始化Cat............

细心的读者可以发现,我竟然把吧打印的语句写反了^~^!!!!

3,可以使用JSR250提供的@PostConstruct在bean创建完成并属性值赋值完成后执行;@PreDestory在容器销毁bean之前执行.(两个注解都是加在方法上)

创建bean

@Component
public class Dog {

    public Dog() {
        System.out.println("Dog创建.......");
    }
    @PostConstruct
    public void init() {
        System.out.println("Dog初始化[email protected]");
    }
    @PreDestroy
    public void destory() {
        System.out.println("Dog销毁[email protected]");
    }
}

运行结果:

创建Cat............
销毁Cat............
Dog创建.......
Dog初始化[email protected]
构造器创建Mouse...........
初始化Mouse...........
容器创建完成.........
七月 23, 2019 9:58:30 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.spring[email protected]311d617d: startup date [Tue Jul 23 21:58:30 CST 2019]; root of context hierarchy
销毁Mouse...........
Dog销毁[email protected]
初始化Cat............

4,BeanPostProcessor:bean的后置处理器,在bean的初始化前后进行一些处理工作

首先创建自定义的类实现BeanPostProcessor接口

@Component
public class MyBeanPostProcessor implements BeanPostProcessor{

    /**
     * 该方法在初始化之前执行
     * beanName:初始化当前bean对象的名字,
     * bean:初始化当前的bean对象
     *
     * 返回的Object为初始化前在该方法中经过处理之后的对象(可原样返回)
     */
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization...." +beanName + "=>" + bean);
        return bean;
    }
    /**
     * 该方法在初始化之后执行
     * beanName:初始化当前bean对象的名字,
     * bean:初始化当前的bean对象
     *
     * 返回的Object为初始化之后在该方法中经过处理之后的对象(可原样返回)
     */
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization...." +beanName + "=>" + bean);
        return bean;
    }

}

之后在执行测试类,观察运行结果

创建Cat............
postProcessBeforeInitialization....cat=>[email protected]
初始化Cat............
postProcessAfterInitialization....cat=>[email protected]
Dog创建.......
postProcessBeforeInitialization....dog=>[email protected]
Dog初始化[email protected]
postProcessAfterInitialization....dog=>[email protected]
构造器创建Mouse...........
postProcessBeforeInitialization....mouse=>[email protected]
初始化Mouse...........
postProcessAfterInitialization....mouse=>[email protected]
容器创建完成.........
七月 23, 2019 10:57:35 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.spring[email protected]311d617d: startup date [Tue Jul 23 22:57:35 CST 2019]; root of context hierarchy
销毁Mouse...........
Dog销毁[email protected]
销毁Cat............

通过观察结果可以看到,在每个bean初始化之前,都会先执行postProcessBeforeInitialization方法,而在初始化完成之后,会执行postProcessAfterInitialization方法.

注意:如果后置器处理中返回的为null,那么容器不会把使用@Bean注解的bean,加载到容器中

原文地址:https://www.cnblogs.com/xingjia/p/11235114.html

时间: 2024-10-12 08:54:58

Spring注解驱动第八讲--容器中bean的生命周期的相关文章

spring IOC 容器中 Bean 的生命周期

IOC 容器中 Bean 的生命周期: 1.通过构造器或工厂方法创建 Bean 实例2.为 Bean 的属性设置值和对其他 Bean 的引用3.调用 Bean 后置处理器接口(BeanPostProcessor),进行初始化前处理4.调用 Bean 的初始化方法5.调用 Bean 后置处理器接口(BeanPostProcessor),进行初始化后处理6.Bean 可以使用了7.当容器关闭时, 调用 Bean 的销毁方法8.在 Bean 的声明里设置 init-method 和 destroy-m

Spring容器中Bean的生命周期

日出日落,春去秋来,花随流水,北雁南飞,世间万物皆有生死轮回.从调用XML中的Bean配置信息,到应用到具体实例中,再到销毁,Bean也有属于它的生命周期. 人类大脑对图像的认知能力永远高于文字,因此,闲言少叙,书归正传,上图先: 步骤很多,切莫惊慌,我们可以把上面的步骤归纳如下: 1-2:创建实例: 现在假设spring就是个容器,而配置文件中配置的bean属性才是我们真正需要的东西.创建实例就是说,我把配置文件中的bean信息取出来化作一个真正的bean并放到容器中. 3-4:注入依赖关系:

IOC容器中bean的生命周期

一.Bean生命周期 Spring IOC容器可以管理Bean的生命周期,允许在Bean生命周期的特定点执行定制的任务. Spring IOC容器对Bean的生命周期进行管理的过程如下: 通过构造器或工厂方法创建Bean实例 为Bean的属性设置值和对其它Bean的引用 调用Bean的初始化方法 Bean可以使用了 当容器关闭时,调用Bean的销毁方法 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法. 下面通过示例

Spring4学习回顾之路06- IOC容器中Bean的生命周期方法

SpringIOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行特定的任务! Spring IOC容器对Bean的生命周期进行管理的过程: -通过构造器或者工厂方法创建Bean实例 -为Bean的属性设置值和对其他Bean的引用 -调用Bean的初始化方法 -Bean可以使用了 -当容器关闭了,调用Bean的销毁方法 在Bean的声明中设置init-method和destory-method属性,为Bean指定初始化和销毁方法:如图: <bean id="s

IOC容器中Bean的生命周期方法

一Spring IOC容器可以管理Bean的生命周期,Spring允许在Bean生命周期的特定点执行定制的任务. 二.Spring IOC容器对Bean的生命周期进行管理的过程: -通过构造器或工厂方法创建Bean的实例 -为Bean的属性设置值和对其他的Bean的引用 -调用Bean的初始化方法 -Bean可以用了 -当容器关闭是吗,调用Bean的销毁方法 三.在bean的声明里设置init-method和destroy-method属性.为Bean指定初始化和销毁方法.

Spring笔记——6.容器中bean的生命周期

spring可以管理单例bean的生命周期,知道何时被创建,核实初始化,何时销毁,也可以进行某些通用资源申请,销毁前资源回收.对于prototype,容器只负责创建,之后就撒手不管自生自灭.容器不知道一共创建了多少prototype,也不知道他们什么时候会被销毁,所以容器没法管理prototype. 管理bean的生命周期有如下两个时机: 注入依赖关系后 即将销毁bean前 依赖关系注入后的行为 通过设定init-method属性指定某个方法或者实现InitializingBean接口指定需要实

[原创]java WEB学习笔记101:Spring学习---Spring Bean配置:IOC容器中bean的声明周期,Bean 后置处理器

本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱好者,互联网技术发烧友 微博:伊直都在0221 QQ:951226918 -----------------------------------------------------------------------------------------------------------------

《Spring揭秘》(八)---- IoC容器及Bean的生命周期

Spring的IoC容器会以某种方式加载配置信息,然后根据这些信息绑定整个系统的对象,最终组装成一个可用的基于轻量级容器的应用系统.实现以上功能,分为两个阶段:容器启动阶段和Bean实例化阶段.而且Spring的IoC容器在每个阶段都加入了相应的扩展点,以便根据具体场景的需要加入自定义的扩展逻辑. 1 容器启动阶段 首先会通过某种途径加载配置信息,大部分情况下,容器需要依赖某些工具类(BeanDefinitionReader)对加载的配置信息进行解析和分析,并将分析后的信息编组为相应的BeanD

Spring中Bean的生命周期

Spring中Bean的生命周期过程: 1.Spring对Bean进行实例化(相当于程序中的new Xx()) 2.Spring将值和Bean的引用注入进Bean对应的属性中 3如果Bean实现了BeanNameAware接口,Spring将Bean的ID传递给setBeanName()方法 (实现BeanNameAware清主要是为了通过Bean的引用来获得Bean的ID,一般业务中是很少有在Bean的ID的) 4.如果Bean实现了BeanFactoryAware接口,Spring将调用se