Spring Boot 中管理 Bean 生命周期的 15 种方法

引言

在 Spring Boot 应用中，管理和操作 Bean 的生命周期是一项关键的任务。这不仅涉及到如何创建和销毁 Bean，还包括如何在应用的生命周期中对 Bean 进行精细控制。Spring 框架提供了多种机制来管理 Bean 的生命周期，这些机制使得开发者可以根据具体的业务需求和场景来定制 Bean 的行为。从简单的注解到实现特定的接口，每种方法都有其适用的场景和优势。

在 Spring Boot 中，操作 Bean 生命周期的方法主要包括以下：

InitializingBean 和 DisposableBean 接口： 在某些环境或特定的约束下，如果您想避免使用 JSR-250。InitializingBean 接口提供了一个方法 afterPropertiesSet()，该方法在 Bean 属性设置之后调用。DisposableBean 接口提供了一个方法 destroy()，该方法在 Bean 销毁之前调用。

<code>import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; public class MyBean implements InitializingBean, DisposableBean { @Override public void afterPropertiesSet() throws Exception { // 初始化代码 System.out.println("Bean is initialized"); } @Override public void destroy() throws Exception { // 清理代码 System.out.println("Bean is destroyed"); } }</code>

@PostConstruct 和 @PreDestroy 注解： 这两个是案例1中相对应的注解方式。@PostConstruct 注解用于在依赖注入完成后执行初始化方法。@PreDestroy 注解用于在 Bean 销毁之前执行清理方法。

<code>import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; public class MyBean { @PostConstruct public void init() { // 初始化代码 System.out.println("Bean is initialized"); } @PreDestroy public void cleanup() { // 清理代码 System.out.println("Bean is destroyed"); } }</code>

Bean 定义的 initMethod 和 destroyMethod： 第三种方式的初始化和销毁方法。在 Bean 定义中，可以通过 initMethod 和 destroyMethod 属性指定初始化和销毁方法。

<code>import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class AppConfig { @Bean(initMethod = "init", destroyMethod = "cleanup") public MyBean myBean() { return new MyBean(); } public static class MyBean { public void init() { // 初始化代码 System.out.println("Bean is initialized"); } public void cleanup() { // 清理代码 System.out.println("Bean is destroyed"); } } }</code>

实现 BeanPostProcessor 接口： BeanPostProcessor 接口提供了两个方法：postProcessBeforeInitialization 和 postProcessAfterInitialization，分别在 Bean 初始化之前和之后调用。这可以用于在 Bean 初始化的不同阶段执行自定义逻辑。

<code>import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.stereotype.Component; @Component public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) { // 在初始化之前执行的代码 return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) { // 在初始化之后执行的代码 return bean; } }</code>

实现 SmartLifecycle 接口： SmartLifecycle 是一个扩展的接口，用于更复杂的生命周期管理，特别是在有多个 Bean 依赖关系的场景中。它提供了启动和停止控制，以及对应的回调方法。

<code>import org.springframework.context.SmartLifecycle; import org.springframework.stereotype.Component; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.concurrent.atomic.AtomicBoolean; @Component public class MySmartLifecycleBean implements SmartLifecycle { private static final Logger logger = LoggerFactory.getLogger(MySmartLifecycleBean.class); private final AtomicBoolean isRunning = new AtomicBoolean(false); @Override public void start() { // 启动逻辑 if (isRunning.compareAndSet(false, true)) { // 实际的启动逻辑 initializeResources(); logger.info("Lifecycle bean started"); } } @Override public void stop() { // 停止逻辑 if (isRunning.compareAndSet(true, false)) { // 实际的停止逻辑 releaseResources(); logger.info("Lifecycle bean stopped"); } } @Override public boolean isRunning() { return isRunning.get(); } @Override public int getPhase() { // 控制启动和停止的顺序 return 0; // 默认阶段是 0，可以根据需要调整 } private void initializeResources() { // 具体的资源初始化逻辑 } private void releaseResources() { // 具体的资源释放逻辑 } }</code>

使用 ApplicationListener 或 @EventListener： 这些用于监听应用事件，如上下文刷新、上下文关闭等，可以在这些事件发生时执行特定逻辑。ApplicationListener 是一个接口，而 @EventListener 是一个注解，两者都可以用于监听应用事件。

<code>import org.springframework.context.ApplicationListener; import org.springframework.context.event.ContextRefreshedEvent; import org.springframework.stereotype.Component; @Component public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> { @Override public void onApplicationEvent(ContextRefreshedEvent event) { // 在应用上下文刷新时执行的代码 System.out.println("Application Context Refreshed"); } } // 或者使用 @EventListener @Component public class MyEventListener { @EventListener public void handleContextRefresh(ContextRefreshedEvent event) { System.out.println("Handling context refreshed event."); } }</code>

实现 ApplicationContextAware 和 BeanNameAware 接口： 这些接口允许 Bean 在其生命周期内访问 ApplicationContext 和自身的 Bean 名称。通过实现这些接口，Bean 可以获得对 Spring 容器更深层次的访问和控制。

<code>import org.springframework.beans.factory.BeanNameAware; import org.springframework.context.ApplicationContextAware; import org.springframework.context.ApplicationContext; import org.springframework.stereotype.Component; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @Component public class MyAwareBean implements ApplicationContextAware, BeanNameAware { private static final Logger logger = LoggerFactory.getLogger(MyAwareBean.class); private ApplicationContext applicationContext; private String beanName; @Override public void setApplicationContext(ApplicationContext applicationContext) { this.applicationContext = applicationContext; // 可以在这里执行与应用上下文相关的操作 logger.info("ApplicationContext has been set for Bean: {}", beanName); } @Override public void setBeanName(String name) { this.beanName = name; // 记录 Bean 名称 logger.info("Bean name set to {}", name); } // 示例方法，展示如何使用 applicationContext public void performSomeAction() { try { // 示例逻辑，例如检索其他 Bean 或环境属性 // String someProperty = applicationContext.getEnvironment().getProperty("some.property"); // ... 执行操作 } catch (Exception e) { logger.error("Error during performing some action", e); } } }</code>

使用 FactoryBean： FactoryBean 是一种特殊的 Bean，用于生成其他 Bean。可以通过实现 FactoryBean 接口来控制 Bean 的实例化过程。

<code>import org.springframework.beans.factory.FactoryBean; import org.springframework.stereotype.Component; @Component public class MyFactoryBean implements FactoryBean<MyCustomBean> { @Override public MyCustomBean getObject() throws Exception { return new MyCustomBean(); } @Override public Class<?> getObjectType() { return MyCustomBean.class; } } public class MyCustomBean { // 自定义 Bean 的逻辑 }</code>

使用 EnvironmentAware 和 ResourceLoaderAware 接口： 这些接口允许 Bean 在其生命周期内访问 Spring 的 Environment 和资源加载器（ResourceLoader）。通过实现这些接口，Bean 可以获得对环境属性和资源的访问。

<code>import org.springframework.context.EnvironmentAware; import org.springframework.core.env.Environment; import org.springframework.context.ResourceLoaderAware; import org.springframework.core.io.ResourceLoader; import org.springframework.stereotype.Component; @Component public class MyEnvironmentAwareBean implements EnvironmentAware, ResourceLoaderAware { private Environment environment; private ResourceLoader resourceLoader; @Override public void setEnvironment(Environment environment) { this.environment = environment; } @Override public void setResourceLoader(ResourceLoader resourceLoader) { this.resourceLoader = resourceLoader; } }</code>

实现 BeanFactoryAware 接口： 通过实现 BeanFactoryAware 接口，Bean 可以访问到 Spring 容器中的 BeanFactory，从而可以进行更复杂的依赖注入和管理。BeanFactoryAware 应该在需要动态访问或管理 Bean 时作为特殊用例来使用。

<code>import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.BeanFactoryAware; import org.springframework.stereotype.Component; @Component public class MyBeanFactoryAware implements BeanFactoryAware { private BeanFactory beanFactory; @Override public void setBeanFactory(BeanFactory beanFactory) { this.beanFactory = beanFactory; } }</code>

使用 @Profile 注解： @Profile 注解允许根据不同的环境配置（如开发、测试、生产）来激活或禁用特定的 Bean。这对于控制 Bean 在不同环境下的创建和管理非常有用。

<code>import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Profile; @Configuration public class MyConfiguration { @Bean @Profile("development") public MyBean devMyBean() { return new MyBean(); } @Bean @Profile("production") public MyBean prodMyBean() { return new MyBean(); } public static class MyBean { // Bean 实现 } }</code>

使用 @Lazy 注解： @Lazy 注解用于延迟 Bean 的初始化直到它被首次使用。这对于优化启动时间和减少内存占用非常有用，特别是对于那些不是立即需要的 Bean。

<code>import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Lazy; @Configuration public class MyConfiguration { @Bean @Lazy public MyBean myLazyBean() { return new MyBean(); } public static class MyBean { // Bean 实现 } }</code>

使用 @DependsOn 注解： @DependsOn 注解用于声明 Bean 的依赖关系，确保一个 Bean 在另一个 Bean 之后被初始化。这在管理 Bean 之间的依赖和初始化顺序时非常有用。

<code>import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.DependsOn; @Configuration public class MyConfiguration { @Bean @DependsOn("anotherBean") public MyBean myBean() { return new MyBean(); } @Bean public AnotherBean anotherBean() { return new AnotherBean(); } public static class MyBean { // Bean 实现 } public static class AnotherBean { // 另一个 Bean 实现 } }</code>

使用 @Order 或 Ordered 接口： 这些用于定义 Bean 初始化和销毁的顺序。@Order 注解和 Ordered 接口可以帮助确保 Bean 按照特定的顺序被创建和销毁。

<code>import org.springframework.core.Ordered; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; @Order(Ordered.HIGHEST_PRECEDENCE) @Component public class MyHighPriorityBean { // 高优先级 Bean 实现 } @Component public class MyDefaultPriorityBean { // 默认优先级 Bean 实现 }</code>

使用 @Conditional 注解： @Conditional 注解用于基于特定条件创建 Bean。你可以创建自定义条件或使用 Spring 提供的条件，如操作系统类型、环境变量、配置属性等。

<code>import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Conditional; import org.springframework.context.annotation.Configuration; import org.springframework.core.env.Environment; @Configuration public class MyConfiguration { @Bean @Conditional(MyCondition.class) public MyBean myConditionalBean() { return new MyBean(); } public static class MyBean { // Bean 实现 } public static class MyCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { Environment env = context.getEnvironment(); // 定义条件逻辑 return env.containsProperty("my.custom.condition"); } } }</code>

总结

Spring Boot 提供的这些方法使得开发者能够灵活地控制 Bean 的生命周期，从而满足不同的应用需求和场景。无论是简单的应用还是复杂的企业级系统，合理地利用这些机制可以有效地管理 Bean 的生命周期，提高应用的性能和可维护性。选择哪种方法取决于具体的需求、应用的复杂性以及开发团队的偏好。正确地使用这些工具和技术可以使 Spring Boot 应用更加健壮、灵活和高效。

来源：https://juejin.cn/post/7307598451260096522

推荐：https://chencoding.top:8090