bean的生命周期就是 bean的创建----->初始化----->销毁方法
由容器管理Bean的生命周期,我们可以通过自己指定bean的初始化方法和bean的销毁方法
主要知识点:
1. 在主配置类中定义一个类的init()方法和destory()方法,destory()方法只有在单例模式下才有效。其中的init方法会在BeanPostProcessor接口的postProcessBeforeInitialization()方法之后,postProcessAfterInitialization方法之前被调用。destory()方法会在容器销毁时被调用。
@Bean(initMethod = "init",destroyMethod = "destroy")
public Car car() {
return new Car();
}
再Car中定义init和destroy方法
package com.tuling.testbeanlifecycle;
public class Car {
public Car() {
System.out.println("Car == 的构造方法..........");
}
public void init() {
System.out.println("Car == init() 方法......");
}
public void destroy() {
System.out.println("Car == destroy() 方法,单例模式下会被调用.....");
}
}
2. 设置bean的Scope,默认是singleton。只有singleton的bean生命周期才会被spring容器管理。针对多实例bean的话,容器启动的时候,bean是不会被创建的而是在获取bean的时候被创建,而且bean的销毁不受IOC容器的管理.
@Scope(value = "prototype"), @Scope(value = "singleton")
@Bean
@Scope(value = "prototype")
public Person person() {
return new Person();
}
3. 类A实现 了InitializingBean接口,会默认重写afterPropertiesSet()方法,此方法会在BeanPostProcessor 接口的postProcessBeforeInitialization()方法后,该类A的init()方法前执行。
package com.tuling.testbeanlifecycle;
import org.springframework.beans.factory.InitializingBean;
public class TulingLog implements InitializingBean {
public TulingLog() {
System.out.println("TulingLog -InitializingBean == 构造方法");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("TulingLog -InitializingBean == afterPropertiesSet() 方法");
}
public void init() {
System.out.println("TulingLog -InitializingBean == init()方法");
}
}
4.实现了DisposableBean接口,会默认重写destroy()方法,该方法会在容器销毁时被调用。同样只有单例的bean该方法才会被调用。多例的bean的生命周期不受spring控制。
package com.tuling.testbeanlifecycle;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class Person implements InitializingBean,DisposableBean {
public Person() {
System.out.println("Person -- 的构造方法");
}
@Override
public void destroy() throws Exception {
System.out.println("Person -- DisposableBean === destroy()方法 ");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("Person -- InitializingBean === afterPropertiesSe()t方法");
}
}
5.通过JSR250规范 提供的注解,@PostConstruct注解,@PreDestroy注解。@PostConstruct注解的方法, 会在默认的init方法之前执行。@PreDestroy注解定义的方法会在默认的destory方法之前执行,具体顺序如下:
@PostConstruct
public void init() {
System.out.println("Book == 的 @PostConstruct 标志的方法");
}
@PreDestroy
public void destory() {
System.out.println("Book == 的 @PreDestroy 标注的方法,单例模式下会被调用..... ");
}
6. 实现了BeanPostProcessor的类,会默认重写postProcessBeforeInitialization() 方法和postProcessAfterInitialization()方法,容器中的每个类在初始化之前都会被这连个方法所拦截。这两个方法一般在init()的前后被执行。
package com.tuling.testbeanlifecycle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* 后置处理器 在bean调用初始化方法前后进行调用
*/
public class TulingBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("------------- PostProcessor...BeforeInitial :"+beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("------------- PostProcessor...AfterInitial :"+beanName);
return bean;
}
}
所具体类如下:
Book 类,用来观察以上所有钩子的执行顺序。。。
package com.tuling.testbeanlifecycle;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Book {
public Book() {
System.out.println("Book == 的构造方法");
}
@PostConstruct
public void init() {
System.out.println("Book == 的 @PostConstruct 标志的方法");
}
@PreDestroy
public void destory() {
System.out.println("Book == 的 @PreDestroy 标注的方法,单例模式下会被调用..... ");
}
public void defaultInit(){
System.out.println("Book == 的 init() 方法 ... ");
}
public void defaultDestory(){
System.out.println("Book == 的 destory() 方法 ... ");
}
}
主配置类:
package com.tuling.testbeanlifecycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
@ComponentScan(basePackages = "com.tuling.testbeanlifecycle")
public class MainConfig {
@Bean(initMethod = "init",destroyMethod = "destroy")
public Car car() {
return new Car();
}
@Bean(initMethod = "init")
public TulingLog tulingLog() {
return new TulingLog();
}
@Bean
public TulingBeanPostProcessor tulingBeanPostProcessor() {
return new TulingBeanPostProcessor();
}
@Bean(initMethod = "defaultInit",destroyMethod = "defaultDestory")
public Book book() {
return new Book();
}
@Bean
@Scope(value = "prototype")
public Person person() {
return new Person();
}
}
main方法类:
package com.tuling.testbeanlifecycle;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
ed by smlz on 2019/5/24.
*/
public class MainClass {
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
Car car = ctx.getBean(Car.class);
Book book = ctx.getBean(Book.class);
Person person = ctx.getBean(Person.class);
TulingLog log = ctx.getBean(TulingLog.class);
ctx.close();
}
}
执行结果: