Spring注解式开发（二）:组件生命周期

引言

上篇文章介绍的是spring注解式开发的组件注入，这篇文章将介绍一个bean组件的生命周期内我们可以对bean组件做什么。

使用场景（这里只是举一个简单的例子）：

1. 可以通过bean的初始化方法来指定数据源的创建
2. 也可以通过bean的销毁方法指定数据源的连接关闭也可以通过bean的销毁方法指定数据源的连接关闭

1.在@Bean标签中指定初始化和销毁方法

在要注入放入bean组件中定义initMethod方法和destroyMethod方法

public class BeanInitAndDestroy {
    public BeanInitAndDestroy() {
        System.out.println("创建了");
    }
    public void init(){
        System.out.println("bean初始化了");
    }
    protected void destroy(){
        System.out.println("bean销毁了");
    }
}

在bean注解中声明要使用的initMethod方法和destroyMethod方法

@Configuration
public class BeanInitAndDestroyConfig {
	//initMethod、destroyMethod的值为组件中对应的方法名
    @Bean(initMethod = "init",destroyMethod = "destroy")
    @Lazy
    public BeanInitAndDestroy beanInitAndDestory(){
        return new BeanInitAndDestroy();
    }
}

使用主函数测试

public class TestBeanInitAndDestroy {
    public static void main(String[] args) {
    	//启动IOC容器
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanInitAndDestroyConfig.class);
        System.out.println("IOC容器启动了");
        System.out.println("开始获取bean组件了");
        BeanInitAndDestroy bean = applicationContext.getBean(BeanInitAndDestroy.class);
        System.out.println("IOC容器开始关闭");
        applicationContext.close();
    }
}

运行结果

IOC容器启动了
开始获取bean组件了
创建了
bean初始化了
IOC容器开始关闭
bean销毁了

通过上面的测试可以看出当获取bean组件时bean开始创建和执行初始化方法，当容器关闭时bean开始执行销毁方法
注意：这里只是针对单实例的bean并且是懒加载，如果是多实例的bean容器是不负责销毁的，也就是当容器关闭时bean的销毁方法 是不会执行的，如果没有启用懒加载，当容器 启动时bean就会创建并且执行初始化方法

2.通过实现InitializingBean,DisposableBean接口指定bean的初始化和销毁方法

首先自定义一个bean组件并且实现InitializingBean,DisposableBean接口

@Component
public class Car implements InitializingBean,DisposableBean {

    public Car() {
        System.out.println("car 创建了");
    }

    public void destroy() throws Exception {
        System.out.println("car 销毁了");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("car 初始化le");
    }
}

创建一个配置类，并且指定要扫描的包

@Configuration
@ComponentScan({"com.wmq.spring.entry"})
public class BeanInitAndDestroyConfig {    
}

使用 主函数测试

public class TestBeanInitAndDestroy {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanInitAndDestroyConfig.class);
        System.out.println("IOC容器启动了");
        System.out.println("开始获取bean组件了");
        BeanInitAndDestroy bean = applicationContext.getBean(BeanInitAndDestroy.class);
        System.out.println("IOC容器开始关闭");
        applicationContext.close();
    }
}

运行结果

car 创建了
car 初始化le
IOC容器启动了
开始获取bean组件了
IOC容器开始关闭
car 销毁了

3.@PostConstruct和@PreDestroy控制bean的初始化和销毁

@PostConstruct：在bean创建完成并且属性赋值完成来初始化bean
@PreDestroy：在容器销毁bean之前来通知我们进行清理工作

创建一个bean组件

@Component
public class Dog {
    public Dog() {
    	System.out.println("dog 创建了");
    }
	//对象创建并赋值之后创建
    @PostConstruct
    public void init(){
        System.out.println("dog 初始化了");
    }
	//对象销毁后回调更改方法
    @PreDestroy
    public void destroy(){
        System.out.println("dog 销毁了");
    }
}

配置类代码和测试代码同上

4.使用bean后置处理器 自定义一个BeanPostProcessor

postProcessBeforeInitialization:在bean初始化之前工作
postProcessAfterInitialization：在bean初始化之后工作

定义一个后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * 可以对bean做统一的包装
     * @param o
     * @param s
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization=============" + o.getClass());
        return o;
    }

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

定义配置类，注意要将自定义的后置处理器注入到容器中

@Configuration
@ComponentScan({"com.wmq.spring.beanPostProcessor"})
public class TestBeanPostProcessorConfig {
}

测试

@Test
public void testTestBeanPostProcessor(){
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestBeanPostProcessorConfig .class);
}

测试结果

car 创建了
postProcessBeforeInitialization=============class com.wmq.spring.entry.Car
car 初始化le
postProcessAfterInitialization=============class com.wmq.spring.entry.Car
dog 创建了
postProcessBeforeInitialization=============class com.wmq.spring.entry.Dog
dog 初始化了
postProcessAfterInitialization=============class com.wmq.spring.entry.Dog

通过测试结果可以看出当bean初始化之情会执行postProcessBeforeInitialization方法，当 bean初始化之后会执行postProcessAfterInitialization方法

5.总结

下面来总结一下一个bean在创建到销毁会经历哪些过程

创建一个bean组件，拥有上面介绍的特性

public class Car implements InitializingBean,DisposableBean {

    public Car() {
        System.out.println("car 创建了");
    }

    public void destroy() throws Exception {
        System.out.println("DisposableBean car 销毁了");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean car 初始化le");
    }
    @PostConstruct
    public void init(){
        System.out.println(" PostConstruct dog 初始化了");
    }

    @PreDestroy
    public void destroy1(){
        System.out.println("@PreDestroy dog 销毁了");
    }
    public void destroy2() throws Exception {
        System.out.println("手动car 销毁了");
    }

    public void init1() throws Exception {
        System.out.println("手动car 初始化le");
    }
}

定义一个配置类

@Configuration
@ComponentScan({"com.wmq.spring.beanPostProcessor"})
public class BeanInitAndDestroyConfig {
    @Bean(initMethod = "init1",destroyMethod = "destroy2")
    //@Lazy
    public Car beanInitAndDestory(){
        return new Car();
    }
}

测试

public class TestBeanInitAndDestroy {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanInitAndDestroyConfig.class);
        System.out.println("IOC容器启动了");
        System.out.println("开始获取bean组件了");
        Car bean = applicationContext.getBean(Car.class);

        applicationContext.close();
        System.out.println("IOC容器开始关闭");
    }
}

测试结果

car 创建了
postProcessBeforeInitialization=============class com.wmq.spring.entry.Car
 PostConstruct dog 初始化了
InitializingBean car 初始化le
手动car 初始化le
postProcessBeforeInitialization=============class com.wmq.spring.entry.Car
IOC容器启动了
开始获取bean组件了
@PreDestroy dog 销毁了
DisposableBean car 销毁了
手动car 销毁了
IOC容器开始关闭

根据测试结果可以看出一个bean组件的生命周期经历如下流程

Created with Raphaël 2.2.0 容器开始启动 bean执行构造方法创建对象 执行postProcessBeforeInitialization方法 执行bean组件中@PostConstruct 注解方法 执行InitializingBean.afterPropertiesSet方法 执行@Bean注解中指定的initMethod方法 执行postProcessAfterInitialization方法 容器启动完成 容器开始关闭 执行bean组件中@PreDestroy注解方法 执行bean组件中destroy注解方法 执行@Bean注解中指定的destroyMethod方法 容器关闭完成

结束语

关于bean组件生命周期的方法就介绍到此，下篇文章将介绍 BeanPostProcessor的工作原理