Spring與bean有關的生命週期示例詳解
阿新 • • 發佈：2020-07-27
前言
記得以前的時候，每次提起Spring中的bean相關的生命週期時，內心都無比的恐懼，因為好像有很多，自己又理不清楚：什麼beanFactory啊，aware介面啊，beanPostProcessor啊，afterPropertiesSet啊，initMethod啊等等。
今天終於理清這些關係了，並且又新增了對postConstruct和lifecycle的理解。
執行順序
- 首先是 BeanFactoryPostProcessor，它是針對所有bean的definition的，只執行一次
下面是針對每個bean的初始
- - 實現了一系列aware介面的，比如BeanNameAware，ApplicationContextAware，呼叫其set方法
- - 執行BeanPostProcessor的postProcessBeforeInitialization方法
- - 帶有@PostConstruct註解的方法
- - 實現InitializingBean介面的afterPropertiesSet方法
- - 指定的initMethod方法
- - 執行BeanPostProcessor的postProcessAfterInitialization方法
- - 實現了SmartLifecycle介面的start方法(實現Lifecycle介面的不會自動呼叫，需要顯式的呼叫start方法)
下面是針對每個bean的銷燬
- - 實現了SmartLifecycle介面的stop方法(實現Lifecycle介面的不會自動呼叫，需要顯式的呼叫stop方法)
- - 帶有@PreDestroy註解的方法
- - 實現DisposableBean介面的destroy方法
- - 指定的destroyMethod方法
目前就想到這麼多了，其他的麻煩在評論區留言呀~
程式碼例項
bean實體類
/**
* @date: 2020-07-22
*
* 一個簡單的列舉類
*/
public enum BeanType {
NORMAL,LIFECYCLE,SMART_LIFECYCLE;
}
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* @author: lihui
* @date: 2020-07-22
* 一個簡單的bean
*/
@Slf4j
public class NormalBean implements BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean {
private BeanType beanType;
public NormalBean() {
this(BeanType.NORMAL);
}
public NormalBean(BeanType beanType) {
this.beanType = beanType;
}
@PostConstruct
public void postConstruct() {
log.info("{},postConstruct",beanType);
}
@Override
public void afterPropertiesSet() throws Exception {
log.info("{},afterPropertiesSet",beanType);
}
public void initMethod() {
log.info("{},initMethod",beanType);
}
@PreDestroy
public void preDestroy() {
log.info("{},preDestroy",beanType);
}
@Override
public void destroy() throws Exception {
log.info("{},destroy",beanType);
}
public void destroyMethod() {
log.info("{},destroyMethod",beanType);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.info("setApplicationContext,applicationContext : {}",applicationContext);
}
@Override
public void setBeanName(String name) {
log.info("setBeanName,bean name : {}",name);
}
}
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.Lifecycle;
/**
* @author: lihui
* @date: 2020-07-22
* 實現了Lifecycle的一個bean
*/
@Slf4j
public class LifecycleBean extends NormalBean implements Lifecycle {
private volatile boolean running = false;
public LifecycleBean() {
super(BeanType.LIFECYCLE);
}
@Override
public void start() {
log.info("start");
running = true;
}
@Override
public void stop() {
log.info("stop");
running = false;
}
@Override
public boolean isRunning() {
return running;
}
}
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.SmartLifecycle;
/**
* @author: lihui
* @date: 2020-07-22
* 實現了SmartLifecycle的一個bean
*/
@Slf4j
public class SmartLifecycleBean extends NormalBean implements SmartLifecycle {
private volatile boolean running = false;
public SmartLifecycleBean() {
super(BeanType.SMART_LIFECYCLE);
}
@Override
public void start() {
log.info("start");
running = true;
}
@Override
public void stop() {
log.info("stop");
running = false;
}
@Override
public boolean isRunning() {
return running;
}
}配置類
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
/**
* @author: lihui
* @date: 2020-07-25
*/
@Slf4j
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
log.info("postProcessBeanFactory,beanFactory:{}",beanFactory);
}
}
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author: lihui
* @date: 2020-07-25
*/
@Slf4j
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean,String beanName) throws BeansException {
log.info("postProcessBeforeInitialization,bean:{}",beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean,String beanName) throws BeansException {
log.info("postProcessAfterInitialization,beanName);
return bean;
}
}
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.SmartLifecycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author: lihui
* @date: 2020-07-22
*/
@Configuration
@Slf4j
public class Config {
@Bean(initMethod = "initMethod",destroyMethod = "destroyMethod")
public NormalBean normalBean() {
return new NormalBean();
}
@Bean(initMethod = "initMethod",destroyMethod = "destroyMethod")
public LifecycleBean lifecycleBean() {
return new LifecycleBean();
}
@Bean(initMethod = "initMethod",destroyMethod = "destroyMethod")
public SmartLifecycle smartLifecycle() {
return new SmartLifecycleBean();
}
@Bean
public static MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
return new MyBeanFactoryPostProcessor();
}
@Bean
public static MyBeanPostProcessor myBeanPostProcessor() {
return new MyBeanPostProcessor();
}
}
Main類
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
* @author: lihui
* @date: 2020-07-22
*/
@Slf4j
public class Main {
public static void main(String[] args) throws InterruptedException {
ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
ctx.registerShutdownHook();
Thread.sleep(5000);
log.info("line ----------------------------- line");
ctx.start();
ctx.stop();
log.info("line ----------------------------- line");
}
}
結果說明
結果正如前面所說的執行順序一致，主要注意的就是Lifecycle介面和SmartLifecycle介面，只有實現了SmartLifecycle介面的bean在初始化時才會被自動呼叫，而實現了Lifecycle介面的除非顯式呼叫start和stop方法才會被呼叫。
總結
到此這篇關於Spring與bean有關的生命週期的文章就介紹到這了,更多相關Spring與bean生命週期內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！