前言
記得以前的時候，每次提起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實體類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/** * @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 */@Slf4jpublic 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 */@Slf4jpublic 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 */@Slf4jpublic 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; }} |
配置類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
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 */@Slf4jpublic 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 */@Slf4jpublic 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, bean:{}", 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@Slf4jpublic 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類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import lombok.extern.slf4j.Slf4j;import org.springframework.context.ConfigurableApplicationContext;import org.springframework.context.annotation.AnnotationConfigApplicationContext;/** * @author: lihui * @date: 2020-07-22 */@Slf4jpublic 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生命周期內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://www.cnblogs.com/eaglelihh/p/13383039.html
