弄浪的鱼

Bean的生命周期指 Bean创建、初始化、销毁的过程。我们可以自定义Bean初始化和销毁方法。容器在bean进行到当前生命周期的时候, 来调用自定义的初始化和销毁方法。

  • 指定 init-method 和 destory-method
  • 实现 InitializingBean 和 DisposableBean 接口
  • JSR250 规范,使用 @PostConstruct 和 @PreDestroy
  • 使用后置处理器 BeanPostProcessor

指定 init-method 和 destory-method

@Bean(initMethod="init", destroyMethod="destory")主要通过 initMethod 和 destroyMethod 来指定 Bean 初始化和销毁的方法。

注: 对于单例的 bean, 可以正常调用初始化和销毁方法、对于多实例的 bean,容器只负责初始化, 但不会管理bean, 容器关闭时不会调用销毁方法

1
2
3
4
5
6
7
@Configuration
public class Cap7MainConfigOfLifeCycle {
@Bean(initMethod="init", destroyMethod="destory")
public Bike bike(){
return new Bike();
}
}

具体的方法在类中自己自定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Bike {
// 构造方法,单例作用域下,在创建容器的时候就会调用
public Bike(){
System.out.println("Bike constructor..............");
}
// 初始化的方法
public void init(){
System.out.println("Bike .....init.....");
}
// 销毁方法
public void destory(){
System.out.println("Bike.....destory");
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
public class Cap7Test {
@Test
public void test01(){
AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(Cap7MainConfigOfLifeCycle.class);

System.out.println("IOC容器创建完成........");
// 关闭容器,销毁 bean
app.close();
}
}

实现 InitializingBean 和 DisposableBean 接口

  • 实现 InitializingBean 接口的 afterPropertiesSet() 方法,当 beanFactory 创建好对象,且把 bean 所有属性设置好之后,会调这个方法,相当于初始化方法
  • 实现 DisposableBean 的 destory() 方法,当 bean 销毁时,会把单实例 bean 进行销毁
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component
public class Train implements InitializingBean, DisposableBean{

public Train(){
System.out.println("Train......constructor............");
}
//当我们bean销毁时,调用此方法
@Override
public void destroy() throws Exception {
System.out.println("Train......destory......");
//logger.error
}
//当我们的bean属性赋值和初始化完成时调用
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("Train.......afterPropertiesSet()...");

}
}

使用 @PostConstruct 和 @PreDestroy

可以使用 JSR250 规则定义的(java规范)两个注解来实现

  • @PostConstruct: 在Bean创建完成,且属于赋值完成后进行初始化,属于JDK规范的注解
  • @PreDestroy: 在bean将被移除之前进行通知, 在容器销毁之前进行清理工作

提示: JSR是由JDK提供的一组规范

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Component
public class Jeep {
public Jeep(){
System.out.println("Jeep.....constructor........");
}
@PostConstruct
public void init(){
System.out.println("Jeep.....@PostConstruct........");
}

@PreDestroy
public void destory(){
System.out.println("Jeep.....@PreDestroy......");
}
}

使用后置处理器 BeanPostProcessor

bean 的后置处理器,在 bean 初始化之前调用进行拦截,在 bean 初始化前后进行一些处理工作。使用BeanPostProcessors 如何控制 Bean 的生命周期;实现 BeanPostProcessors 的两个接口 postProcessBeforeInitialization()postProcessAfterInitialization()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Component
public class JamesBeanPostProcessor implements BeanPostProcessor{
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//返回一个的对象(传过来的对象)
//在初始化方法调用之前进行后置处理工作,
//什么时候调用它: init-method=init之前调用
System.out.println("postProcessBeforeInitialization...."+beanName+"..."+bean);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization...."+beanName+"..."+bean);
return bean;
}
}