Bean 的生命周期总结

%20 %20

1. 执行各种通知(BeanNameAware、BeanFactoryAware)等接口方法
2. 初始化的前置方法(PostConstruct)
3. 初始化方法
4. 初始化的后置方法(PreDestroy)

下面用代码演示整个Bean的生命周期:
我们用构造方式来展示实例化的效果 ,实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改  所以下面没有演示设置属性

1. package com.example.bean.test;
3. import org.springframework.beans.factory.BeanNameAware;
4. import org.springframework.stereotype.Component;
6. import javax.annotation.PostConstruct;
7. import javax.annotation.PreDestroy;
9. @Component
10. public class BeanLifeComponent implements BeanNameAware {
12. private String name;
14. public BeanLifeComponent() {
15. System.out.println("实例化方法执行拉");
16. }
19. public void setBeanName(String s) {
20. System.out.println("执行 BeanName 的通知方法");
21. }
23. @PostConstruct
24. public void postConstruct() {
25. System.out.println("初始化方法执行");
26. }
28. public void use() {
29. System.out.println("使用 Bean");
30. }
32. @PreDestroy
33. public void preDestroy() {
34. System.out.println("销毁方法执行");
35. }
36. }

因为初始化的前置方法和后置方法是为所有 Bean 服务的，而非为某一个 Bean 服务的，所以这两个方法不能写在某个具体的 Bean 中，否则（这两个方法）不会执行。 所以我们另外创建一个类来实现这两个方法

1. package com.example.bean.test;
3. import org.springframework.beans.BeansException;
4. import org.springframework.beans.factory.config.BeanPostProcessor;
5. import org.springframework.stereotype.Component;
7. @Component
8. public class MyBeanPostProcessor implements BeanPostProcessor {
9. @Override
10. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
11. if (beanName.equals("beanLifeComponent")) {
12. System.out.println("初始化前置方法执行");
13. }
14. return bean;
15. }
17. @Override
18. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
19. if (beanName.equals("beanLifeComponent")) {
20. System.out.println("初始化后置方法执行");
21. }
22. return bean;
23. }
24. }

 在得到上下文对象这里  因为我们是使用springboot演示的 所以我们使用ConfigurableApplicationContext 来得到上下文对象

1. package com.example.bean.test;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. import org.springframework.context.ConfigurableApplicationContext;
7. @SpringBootApplication
8. public class DemoApplication {
9. public static void main(String[] args) {
10. // 得到上下文对象，并启动 Spring Boot 项目
11. ConfigurableApplicationContext context =
12. SpringApplication.run(DemoApplication.class, args);
13. // 获取 Bean
14. BeanLifeComponent component = context.getBean(BeanLifeComponent.class);
15. // 使用 Bean
16. component.use();
17. // 停止 Spring Boot 项目
18. context.close();
19. }
20. }

结果如下: 

二、@PostConstruct 和 @PreDestroy 各自的效果

1. 当Bean被容器初始化之后，会调用@PostConstruct的注解方法。
2. 当Bean在容器销毁之前，调用被@PreDestroy注解的方法

代码如下:所以，PostConstruct 注释用于在依赖关系注入完成之后需要执行的方法上，以执行任何初始化。此方法必须在将类放入服务之前调用。支持依赖关系注入的所有类都必须支持此注释。即使类没有请求注入任何资源，用PostConstruct 注释的方法也必须被调用。只有一个方法可以用此注释进行注释。

1. @PostConstruct
2. public void doPostConstruct(){
3. System.out.println("执行了 新版本@PostConstruct 前置初始化方法");
4. }
5. @PreDestroy
6. public void doPreDestroy(){
7. System.out.println("执行新版本 @PreDestroy 销毁方法");
9. }

PreDestroy 用与在依赖注入完成之前的方法前面执行，遵守准则：

1. 该方法不得有任何参数
2. 该方法的返回类型必须为 void；
3. 该方法不得抛出已检查异常；
4. 应用 PostConstruct 的方法可以是 public、protected、package private 或 private；
5. 该方法不能是 static；该方法可以是 final；
6. 该方法只会被执行一次

三、 实例化和初始化的区别

实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改；⽽初始化是给开发者提供的，可以在实例化之后，类加载完成之前进⾏⾃定义“事件”处理。

四、为什么要先设置属性在进⾏初始化呢？

仔细观察下面代码:

1. @Service
2. public class UserService {
3. public UserService(){
4. System.out.println("调⽤ User Service 构造⽅法");
5. }
6. public void sayHi(){
7. System.out.println("User Service SayHi.");
8. }
9. }
10. @Controller
11. public class UserController {
12. @Resource
13. private UserService userService;
14. @PostConstruct
15. public void postConstruct() {
16. userService.sayHi();
17. System.out.println("执⾏ User Controller 构造⽅法");
18. }
19. }

我们可以发现很是为了避免空指针异常。