hualinux spring 4.10： Bean的生命周期

目录

一、知识点

二、例子

2.1 例1 单实例创建过程

2.1.1 实现代码

2.2 例子2 多实例

2.3 例3：InitializingBean和DisposableBean实现

2.4 例4 ：使用  @PreDestroy @PostConstruct注解

2.5 例5 Bean后置处理器BeanPostProcessor

---

本章将讲Bean的生命周期，了解Bean的生命周期也是很有必要的

一、知识点

/**
*  Bean的生命周期
*       bean创建---初始化---销毁的过程
*  容器管理bean的生命周期;
*  我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
*
*  构造（对象创建）
*       单实例：在容器启动的时候创建对象
*       多实例：在每次获取的时候创建对象
*  初始化：
*       对象创建完成，并幅值好，调用初始化方法...
*  销毁：
*       容器关闭的时候
*
*  1）、指定初始化和销毁方法；
*           指定init-method和destroy-method
*  2）、通过Bean实现InitializingBean（定义初始化逻辑）
*                 DisposableBean（定义销毁逻辑）
* 3）、可以使用JSR250
*            @PostConstruct：在bean创建完成并且属性幅值完成；来执行初始化方法
*            @PreDestroy：在容器销毁bean之前通知我们进行清理工作
* 4）、BeanPostProcessor[interface]：bean的后置处理器；
*           在bean初始化前后里德一些处理工作：
*           postProcessBeforeInitialization：在初始化之前工作
*           postProcessAfterInitialization：在初始化之后工作
*
* */

 

二、例子

2.1 例1 单实例创建过程

就是创建3个文件car、配置文件、还有一个main就行了，很简单

2.1.1 实现代码

src-->com.hualinux.spring.Car.java

package com.hualinux.spring;

import org.springframework.stereotype.Component;

@Component
public class Car {
    public Car() {
        System.out.println("car constructor...");
    }

    public void init(){
        System.out.println("car...init...");
    }

    public void destroy() {
        System.out.println("car...detory...");
    }
}

src-->conf.MainConfOfLifeCycle.java

package conf;


import com.hualinux.spring.Car;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class MainConfOfLifeCycle {

    @Bean
    public Car car(){
        return new Car();
    }
}

src-->com.hualinux.spring.OfLifeCycleMain.java

package com.hualinux.spring;

import conf.MainConfOfLifeCycle;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class OfLifeCycleMain {
    public static void main(String[] args) {
        //1.创建ioc容器，注意，这里不是ApplicationContext，以后都推荐用AnnotationConfigApplicationContext
        AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfOfLifeCycle.class);
        System.out.println("容器创建完成...");

        //2.关闭容器,容器关闭的时间会被销毁
        ctx.close();


    }
}

运行com.hualinux.spring.OfLifeCycleMain.java结果为：

car constructor...
容器创建完成...

 

ps：也可以指定初始化和销毁方法

    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car(){
        return new Car();
    }

运行结果为：

car constructor...
car...init...
容器创建完成...
car...detory...

 

2.2 例子2 多实例

如果是多实现Bean，把conf.MainConfOfLifeCycle.java代码修改为：

@Configuration
public class MainConfOfLifeCycle {

    //指定多实例
    @Scope("prototype")
    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car(){
        return new Car();
    }
}

运行结果为：

容器创建完成...

发现初始化不会被执行，也没有被销毁

 

2.3 例3：InitializingBean和DisposableBean实现

在例2的基础上进行操作

创建src-->com.hualinux.spring.Cat.java

package com.hualinux.spring;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class Cat implements InitializingBean, DisposableBean {

    public Cat() {
        System.out.println("cat constructor...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("cat...destroy...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("cat...afterPropertiesSet...");
    }
}

conf.MainConfOfLifeCycle.java配置修改如下：

@ComponentScan("com.hualinux.spring")
@Configuration
public class MainConfOfLifeCycle {

    //指定多实例
   // @Scope("prototype")
    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Car car(){
        return new Car();
    }
}

运行com.hualinux.spring.OfLifeCycleMain.java，结果如下：

car constructor...
car...init...
cat constructor...
cat...afterPropertiesSet...
容器创建完成...
cat...destroy...
car...detory...

 

2.4 例4 ：使用  @PreDestroy @PostConstruct注解

继续上面操作，上面的两个注解要用到java EE sdk，需要idea下载 

创建一个新的类Dog

src-->com.hualinux.spring.Dog.java

package com.hualinux.spring;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Dog {
    public Dog() {
        System.out.println("Dog...constructor...");
    }

    //对象创建并幅值之后调用
    @PostConstruct
    public void init() {
        System.out.println("Dog...@PostConstruct");
    }

    // 容器移除对象之前
    @PreDestroy
    public void destory() {
        System.out.println("Dog...@reDestroy");
    }
}

发现2个注解不能识别，按下面操作即可 

运行com.hualinux.spring.OfLifeCycleMain.java，结果如下：

...
Dog...constructor...
Dog...@PostConstruct
容器创建完成...
Dog...@PreDestroy
cat...destroy...
car...detory...

 

2.5 例5 Bean后置处理器BeanPostProcessor

在上面的基础上继续操作，直接建立一个新类

src-->com.hualinux.spring.MyBeanPostProcessor.java

package com.hualinux.spring;

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

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization"+s+"=>"+o);
        return o;
    }

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

}

运行com.hualinux.spring.OfLifeCycleMain.java，结果如下：