Springboot - 5.Bean的生命周期

✍1. Bean的生命周期：

当然，我会详细描述每一步的作用。

🎷1. 实例化Bean:

这是Bean生命周期的第一步。Spring容器通过反射机制创建Bean的实例。
```
public class ExampleBean { 
      // ... } 
```

🎷2. 设置Bean的属性:

Spring容器将根据配置文件设置Bean的属性。这是通过调用Bean的setter方法完成的。

public class ExampleBean { 
      private String name; public void setName(String name) { 
      this.name = name; } // ... }

🎷3. 调用`BeanNameAware`的`setBeanName`方法:

如果Bean实现了BeanNameAware接口，Spring容器将调用setBeanName方法，传递Bean的ID。这允许Bean知道它在Spring容器中的ID。

public class ExampleBean implements BeanNameAware { 
      private String beanName; @Override public void setBeanName(String name) { 
      this.beanName = name; } // ... }

🎷4. 调用`BeanFactoryAware`的`setBeanFactory`方法:

如果Bean实现了BeanFactoryAware接口，Spring容器将调用setBeanFactory方法，传递自身。这允许Bean知道它所属的容器。

public class ExampleBean implements BeanFactoryAware { 
      private BeanFactory beanFactory; @Override public void setBeanFactory(BeanFactory beanFactory) { 
      this.beanFactory = beanFactory; } // ... }

🎷5. 调用`ApplicationContextAware`的`setApplicationContext`方法:

如果Bean实现了ApplicationContextAware接口，Spring容器将调用setApplicationContext方法，传递自身。这允许Bean知道它所属的应用上下文。

public class ExampleBean implements ApplicationContextAware { 
      private ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext applicationContext) { 
      this.applicationContext = applicationContext; } // ... }

🎷6. 调用`BeanPostProcessor`的`postProcessBeforeInitialization`方法:

如果Bean实现了BeanPostProcessor接口，Spring容器将在初始化方法之前调用postProcessBeforeInitialization方法。这允许对Bean的属性进行更改。

public class CustomBeanPostProcessor implements BeanPostProcessor { 
      @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
      // ... return bean; } // ... }

🎷7. 调用`InitializingBean`的`afterPropertiesSet`方法:

如果Bean实现了InitializingBean接口，Spring容器将在所有属性设置完成后调用afterPropertiesSet方法。

public class ExampleBean implements InitializingBean { 
      @Override public void afterPropertiesSet() throws Exception { 
      // ... } // ... }

🎷8. 调用自定义的初始化方法:

如果在Bean的定义中指定了自定义的初始化方法，Spring容器将调用它。

public class ExampleBean { 
      public void init() { 
      // ... } // ... }

🎷9. 调用`BeanPostProcessor`的`postProcessAfterInitialization`方法:

如果Bean实plement了BeanPostProcessor接口，Spring容器将在初始化方法之后调用postProcessAfterInitialization方法。

public class CustomBeanPostProcessor implements BeanPostProcessor { 
      @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
      // ... return bean; } // ... }

🎷10. Bean的使用:

现在，Bean已经准备好了，可以被应用程序使用。

🎷11. 调用`DisposableBean`的`destroy`方法:

如果Bean实现了DisposableBean接口，Spring容器将在容器关闭时调用destroy方法。

public class ExampleBean implements DisposableBean { 
      @Override public void destroy() throws Exception { 
      // ... } // ... }

🎷12. 调用自定义的销毁方法:

如果在Bean的定义中指定了自定义的销毁方法，Spring容器将在容器关闭时调用它。

public class ExampleBean { 
      public void destroy() { 
      // ... } // ... }

🎷13. 下面是一个简单的Java配置示例：

@Configuration public class AppConfig { 
    @Bean(initMethod = "init", destroyMethod = "destroy") public ExampleBean exampleBean() { 
    return new ExampleBean(); } }

在这个示例中，ExampleBean是一个简单的Java类，它有init和destroy方法，分别作为初始化和销毁方法。

🎷14. 流程图如下：

+-------------------+ | 实例化Bean | +-------------------+ | v +-------------------+ | 设置Bean的属性 | +-------------------+ | v +-------------------+ | 调用BeanNameAware | | 的setBeanName方法 | +-------------------+ | v +-------------------+ | 调用BeanFactoryAware| | 的setBeanFactory方法 | +-------------------+ | v +-------------------+ | 调用ApplicationContextAware| | 的setApplicationContext方法 | +-------------------+ | v +-------------------+ | 调用BeanPostProcessor | | 的postProcessBeforeInitialization方法 | +-------------------+ | v +-------------------+ | 调用InitializingBean| | 的afterPropertiesSet方法 | +-------------------+ | v +-------------------+ | 调用自定义的初始化方法 | +-------------------+ | v +-------------------+ | 调用BeanPostProcessor | | 的postProcessAfterInitialization方法 | +-------------------+ | v +-------------------+ | Bean的使用 | +-------------------+ | v +-------------------+ | 调用DisposableBean | | 的destroy方法 | +-------------------+ | v +-------------------+ | 调用自定义的销毁方法 | +-------------------+

✍2. 如何使用Bean的生命周期：

在Spring Boot中，我们可以使用Java配置、注解和自定义的BeanPostProcessor来使用Bean的生命周期。

🎷1. 使用Java配置:

我们可以使用@Bean注解的initMethod和destroyMethod属性来指定Bean的初始化和销毁方法。

@Configuration public class AppConfig { 
      @Bean(initMethod = "init", destroyMethod = "destroy") public ExampleBean exampleBean() { 
      return new ExampleBean(); } } public class ExampleBean { 
      public void init() { 
      System.out.println("ExampleBean 初始化"); } public void destroy() { 
      System.out.println("ExampleBean 销毁"); } }

在这个示例中，ExampleBean是一个简单的Java类，它有init和destroy方法，分别作为初始化和销毁方法。

🎷2. 使用`@PostConstruct`和`@PreDestroy`注解:

我们可以使用@PostConstruct注解来标记Bean的初始化方法，使用@PreDestroy注解来标记Bean的销毁方法。

@Component public class ExampleBean { 
      @PostConstruct public void init() { 
      System.out.println("ExampleBean 初始化"); } @PreDestroy public void destroy() { 
      System.out.println("ExampleBean 销毁"); } }

在这个示例中，ExampleBean是一个简单的Java类，它有init和destroy方法，分别作为初始化和销毁方法。

🎷3. 使用`InitializingBean`和`DisposableBean`接口:

我们可以让Bean实现InitializingBean接口和DisposableBean接口。

@Component public class ExampleBean implements InitializingBean, DisposableBean { 
      @Override public void afterPropertiesSet() throws Exception { 
      System.out.println("ExampleBean 初始化"); } @Override public void destroy() throws Exception { 
      System.out.println("ExampleBean 销毁"); } }

在这个示例中，ExampleBean是一个简单的Java类，它实现了InitializingBean接口和DisposableBean接口。

🎷4. 使用自定义的`BeanPostProcessor`:

我们可以创建一个自定义的BeanPostProcessor，并在postProcessBeforeInitialization方法和postProcessAfterInitialization方法中添加自定义的逻辑。

@Component public class CustomBeanPostProcessor implements BeanPostProcessor { 
      @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
      if (bean instanceof ExampleBean) { 
      System.out.println("ExampleBean 初始化之前"); } return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
      if (bean instanceof ExampleBean) { 
      System.out.println("ExampleBean 初始化之后"); } return bean; } } @Component public class ExampleBean { 
      // ... }

在这个示例中，CustomBeanPostProcessor是一个自定义的BeanPostProcessor，它在ExampleBean的初始化之前和之后添加了自定义的逻辑。

✍3. 优缺点和使用场景

当描述每个Bean的生命周期阶段时，我已经包括了各个阶段的作用、使用场景以及优缺点。每个阶段都对应着特定的操作和目的，以下是对每个阶段的描述和附加信息：

🎷 1. 实例化Bean:

作用：创建Bean的实例，使用反射机制根据配置信息生成一个新的对象。
使用场景：在这个阶段，主要是实例化对象，通常不涉及太多业务逻辑。
优缺点：这个阶段没有特定的优缺点，它是整个生命周期的起点，为后续的操作提供了基础。

🎷 2. 设置Bean的属性:

作用：根据配置文件设置Bean的属性，通过调用setter方法完成。
使用场景：在这个阶段，属性被设置为配置文件中指定的值，准备好被后续的初始化方法使用。
优缺点：这个阶段是为了确保Bean的属性已正确设置，没有明显的优缺点。

🎷 3. 调用`BeanNameAware`的`setBeanName`方法:

作用：如果Bean实现了BeanNameAware接口，容器将传递Bean的ID，让Bean知道自己在容器中的名称。
使用场景：当Bean需要知道自己在容器中的名称时，可以实现此接口。
优缺点：这个阶段可以让Bean获取自己的ID，有助于Bean在后续的操作中使用这个信息。

🎷 4. 调用`BeanFactoryAware`的`setBeanFactory`方法:

作用：如果Bean实现了BeanFactoryAware接口，容器将传递自身，让Bean知道所属的容器。
使用场景：当Bean需要与容器进行交互，例如获取其他Bean，可以实现此接口。
优缺点：这个阶段允许Bean与容器进行交互，获取其他Bean的引用，但在较新的Spring版本中，通常使用更现代的依赖注入方式。

🎷 5. 调用`ApplicationContextAware`的`setApplicationContext`方法:

作用：如果Bean实现了ApplicationContextAware接口，容器将传递应用上下文，让Bean知道所属的应用上下文。
使用场景：当Bean需要与应用上下文进行交互，例如获取消息资源、执行AOP等，可以实现此接口。
优缺点：这个阶段允许Bean与应用上下文进行交互，获取应用上下文中的各种资源和服务。

🎷 6. 调用`BeanPostProcessor`的`postProcessBeforeInitialization`方法:

作用：如果Bean实现了BeanPostProcessor接口，容器将在初始化方法之前调用此方法，允许对Bean的属性进行更改。
使用场景：当需要在Bean初始化之前对属性进行修改或处理时，可以实现此接口。
优缺点：这个阶段允许对Bean进行额外的定制和处理，但需要小心不要影响初始化流程。

🎷 7. 调用`InitializingBean`的`afterPropertiesSet`方法:

作用：如果Bean实现了InitializingBean接口，容器将在所有属性设置完成后调用此方法，用于执行额外的初始化逻辑。
使用场景：当需要在属性设置完成后执行初始化逻辑时，可以实现此接口。
优缺点：这个阶段允许在属性设置完成后执行自定义的初始化操作，但是与Spring API的耦合度较高。

🎷 8. 调用自定义的初始化方法:

作用：调用Bean定义中指定的自定义初始化方法，执行特定的初始化逻辑。
使用场景：当需要在Bean初始化阶段执行特定的业务逻辑时，可以通过配置自定义的初始化方法。
优缺点：这个阶段允许在初始化过程中执行业务逻辑，但需要谨慎处理与初始化过程的关系。

🎷 9. 调用`BeanPostProcessor`的`postProcessAfterInitialization`方法:

作用：如果Bean实现了BeanPostProcessor接口，容器将在初始化方法之后调用此方法，允许对Bean进行后处理。
使用场景：当需要在Bean初始化后对Bean进行额外的处理，例如AOP代理、属性设置等，可以实现此接口。
优缺点：这个阶段允许在Bean初始化后进行额外的处理，但需要注意不要破坏Bean的状态。

🎷 10. Bean的使用:

作用：Bean已经准备好可以被应用程序使用。
使用场景：在这个阶段，应用程序可以开始使用Bean的功能，进行业务逻辑操作。

🎷 11. 调用`DisposableBean`的`destroy`方法:

作用：如果Bean实现了DisposableBean接口，容器将在容器关闭时调用此方法，执行销毁操作。
使用场景：当需要在Bean被销毁前执行清理操作，例如释放资源、关闭连接等，可以实现此接口。
优缺点：这个阶段允许在容器关闭前执行清理操作，但与Spring API的耦合度较高。

🎷 12. 调用自定义的销毁方法:

作用：调用Bean定义中指定的自定义销毁方法，执行特定的销毁逻辑。
使用场景：当需要在Bean销毁阶段执行特定的业务逻

辑时，可以通过配置自定义的销毁方法。

优缺点：这个阶段允许在销毁过程中执行业务逻辑，但需要注意不要破坏销毁过程的完整性。

今天的文章 Springboot - 5.Bean的生命周期分享到此就结束了，感谢您的阅读。

Springboot - 5.Bean的生命周期

✍1. Bean的生命周期：

🎷1. 实例化Bean:

🎷2. 设置Bean的属性:

🎷3. 调用BeanNameAware的setBeanName方法:

🎷4. 调用BeanFactoryAware的setBeanFactory方法:

🎷5. 调用ApplicationContextAware的setApplicationContext方法:

🎷6. 调用BeanPostProcessor的postProcessBeforeInitialization方法:

🎷7. 调用InitializingBean的afterPropertiesSet方法:

🎷8. 调用自定义的初始化方法:

🎷9. 调用BeanPostProcessor的postProcessAfterInitialization方法: