- 前面讲了bean的创建和注入，这一节将介绍bean的生命周期。
- bean的生命周期过程：
bean创建---初始化----销毁的过程
- spring中bean的生命周期由容器管理，我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法。
一、实现自定义初始化和销毁方法的几种方法
1、通过@Bean指定init-method和destroy-method
//1、定义bean类
public class Car {
public Car(){
System.out.println("car constructor...");
}
public void init(){
System.out.println("car ... init...");
}
public void detory(){
System.out.println("car ... detory...");
}
}
//2、配置类中
@Bean(initMethod="init",destroyMethod="detory")
public Car car(){
return new Car();
}
2、Bean实现InitializingBean和DisposableBean接口
//1、实现InitializingBean和DisposableBean接口
public class Bus implements InitializingBean,DisposableBean {
public Bus(){
System.out.println("bus constructor...");
}
//DisposableBean接口的方法，定义销毁逻辑
public void destroy() throws Exception {
System.out.println("bus...destroy...");
}
//InitializingBean接口的方法，定义初始化逻辑
public void afterPropertiesSet() throws Exception {
System.out.println("bus...afterPropertiesSet...");
}
}
//2、配置文件注入bean
@Bean
public Bus bus() {
return new Bus();
}
3、使用@PostConstruct和@PreDestroy注解
@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
@PreDestroy：在容器销毁bean之前通知我们进行清理工作
public class Train {
public Train (){
System.out.println("train constructor...");
}
//对象创建并赋值之后调用
@PostConstruct
public void init(){
System.out.println("train....@PostConstruct...");
}
//容器移除对象之前
@PreDestroy
public void detory(){
System.out.println("train....@PreDestroy...");
}
}
4、BeanPostProcessor接口，bean的后置处理器
public class MyBeanPostProcessor implements BeanPostProcessor {
//在初始化之前工作(会环绕所有的bean）
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean);
return bean;
}
//在初始化之后工作
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean);
return bean;
}
}
bean生命周期过程总结：
- 创建
- BeanPostProcessor.postProcessBeforeInitialization
- 初始化
- BeanPostProcessor.postProcessAfterInitialization
- 销毁
二、单实例和多实例对生命周期的影响
- 构建对象的时候
单实例：在容器启动的时候创建对象
多实例：在每次获取的时候创建对象
- 初始化时候
对象创建完成，并赋值好，调用初始化方法
- 销毁时候
单实例：容器关闭的时候
多实例：容器不会管理这个bean；容器不会调用销毁方法
三、BeanPostProcessor原理
- 前面知道BeanPostProcessor是一个后置处理器接口，源码：
public interface BeanPostProcessor {
//方法在初始化之前执行，
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
//方法在初始化之后执行，
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
- BeanPostProcessor接口有很多的实现了，这些实现类很多非常重要，想bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async等等功能的完成都和相应的实现了有关系。
1、ApplicationContextAwareProcessor实现类
- 继承该类，并重写相应的方法可以获取ApplicationContext对象
- 使用：
@Component
public class Train implements ApplicationContextAware {
//通过在实现ApplicationContextAware在组件bean初始化的时候传入
//ApplicationContext，这样可以根据ApplicationContext中的一些数据进行一些自定义的操作
private ApplicationContext applicationContext;
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}
- 源码
class ApplicationContextAwareProcessor implements BeanPostProcessor {
private final ConfigurableApplicationContext applicationContext;
private final StringValueResolver embeddedValueResolver;
/**
* Create a new ApplicationContextAwareProcessor for the given context.
*/
public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
this.applicationContext = applicationContext;
this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
}
//实现类，在bean初始化之前执行
@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
//判断bean是不是属性系列的aware实现类
if (System.getSecurityManager() != null &&
(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareInterfaces(bean);
return null;
}
}, acc);
}
else {
//调用相应的aware继承类
invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof Aware) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
