spring中的bean的生命周期

bean的生命周期：bean的创建 —— 初始化 ——销毁的过程

容器管理bean的生命周期，我们可以自定义初始化和销毁方法，容器在bean进行到当前生命周期就会调用我们的方法

在xml配置文件中是在bean的标签内使用init-method和destroy-method

<bean id="person" class="com.springbean.Person" init-method="" destroy-method="" >

这里我们使用注解的方法

第一种指定初始化和销毁方法

首先创建一个bean

public class Foo {

    public Foo(){
        System.out.println("bean的创建");
    }

    public void init(){
        System.out.println("bean的初始化");
    }

    public void destroy(){
        System.out.println("bean的销毁");
    }
} 

创建一个配置类：

@Bean注解上指定初始化和销毁方法

@Configuration
public class MainBeanConfig  {

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

测试：

public class BeanTest {

    @Test
    public void  test(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainBeanConfig.class);
    }
}

bean如果没有指定作用域，就是单例的，就在容器加载的时候就会创建bean,所以打印的结果是：

bean的创建
bean的初始化

销毁：当容器关闭的时候，就会调用destroy方法，打印 bean的销毁

applicationContext.close();

如果要指定bean的作用域为prototype，就需要在配置类中MainBeanConfig,加上注解@Scope("prototype")，如

@Bean
@Scope("prototype")
public Foo foo(){
   return new Foo();
}

指定bean的作用域为@Scope("prototype")，这时候容器加载的时候就不会创建和初始化bean，而是在获取bean的时候。

容器关闭的时候也不会去调用destroy方法，需要自己手动调用。


第二种我们通过bean实现InitializingBean（定义初始化逻辑）和DisposableBean（定义销毁逻辑）
创建一个类Hero，实现InitializingBean,DisposableBean接口，加上注解@Component

@Component
public class Hero implements InitializingBean,DisposableBean {

    public Hero(){
        System.out.println("创建");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("销毁");
    }

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

在配置中加上注解ComponentScan去扫描包,也可以使用@Import来将组件加入容器中

如：@Import({Hero.class})

@ComponentScan("com.springbean")
public class MainBeanConfig  {

测试：

 @Test
    public void  test(){
        AnnotationConfigApplicationContext  applicationContext = new AnnotationConfigApplicationContext(MainBeanConfig.class);
        applicationContext.close();
    }

打印结果：

创建
初始化
销毁

第三种使用@PostConstruct（构造器创建之后）和@PreDestroy（容器销毁之前）两个注解，这是JSR250的两个注解。

  @PostConstruct
    public void init(){
        System.out.println("bean的初始化");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("bean的销毁");
    }

第四种使用BeanPostProcessor后置处理器，这个接口中有两个方法postProcessBeforeInitialization和postProcessAfterInitialization：

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;

    Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;
}

分别在bean初始化之前执行这个方法，这个类似aop里面的前后通知，写一个实现类MyBeanPostProcesser

/**
 *后置处理器，处理前后初始化的工作
 */
@Component
public class MyBeanPostProcesser implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println(" postProcessBeforeInitialization ...beanname="+s+",bean="+o);
        return o;
    }

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

加入到配置类中MainBeanConfig

@Configuration
@Import({Hero.class, MyBeanPostProcesser.class})
public class MainBeanConfig  {

测试：输出结果，是在bean的初始化的前后操作

 postProcessBeforeInitialization ...beanname=com.springbean.Hero,bean=com.springbean.Hero@4ba2ca36
初始化
postProcessAfterInitialization.... beanname=com.springbean.Hero,bean=com.springbean.Hero@4ba2ca36