SpringBoot中操作Bean的生命周期的方法總結(jié)

更新時(shí)間：2023年12月03日 14:17:21 作者：一只愛擼貓的程序猿

在SpringBoot應(yīng)用中,管理和操作Bean的生命周期是一項(xiàng)關(guān)鍵的任務(wù),這不僅涉及到如何創(chuàng)建和銷毀Bean,還包括如何在應(yīng)用的生命周期中對(duì)Bean進(jìn)行精細(xì)控制,本文給大家總結(jié)了SpringBoot中操作Bean的生命周期的方法,需要的朋友可以參考下

引言
1. InitializingBean 和 DisposableBean 接口：
2. @PostConstruct 和 @PreDestroy 注解：
3. Bean 定義的 initMethod 和 destroyMethod：
4. 實(shí)現(xiàn) BeanPostProcessor 接口：
5. 實(shí)現(xiàn) SmartLifecycle 接口：
6. 使用 ApplicationListener 或 @EventListener：
7. 實(shí)現(xiàn) ApplicationContextAware 和 BeanNameAware 接口：
8. 使用 FactoryBean：
9. 使用 EnvironmentAware 和 ResourceLoaderAware 接口：
10. 實(shí)現(xiàn) BeanFactoryAware 接口：
11. 使用 @Profile 注解：
12. 使用 @Lazy 注解：
13. 使用 @DependsOn 注解：
14. 使用 @Order 或 Ordered 接口：
15. 使用 @Conditional 注解：
總結(jié)

引言

在 Spring Boot 應(yīng)用中，管理和操作 Bean 的生命周期是一項(xiàng)關(guān)鍵的任務(wù)。這不僅涉及到如何創(chuàng)建和銷毀 Bean，還包括如何在應(yīng)用的生命周期中對(duì) Bean 進(jìn)行精細(xì)控制。Spring 框架提供了多種機(jī)制來(lái)管理 Bean 的生命周期，這些機(jī)制使得開發(fā)者可以根據(jù)具體的業(yè)務(wù)需求和場(chǎng)景來(lái)定制 Bean 的行為。從簡(jiǎn)單的注解到實(shí)現(xiàn)特定的接口，每種方法都有其適用的場(chǎng)景和優(yōu)勢(shì)。

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

1. InitializingBean 和 DisposableBean 接口：

在某些環(huán)境或特定的約束下，如果您想避免使用 JSR-250

InitializingBean 接口提供了一個(gè)方法 afterPropertiesSet()，該方法在 Bean 屬性設(shè)置之后調(diào)用。
DisposableBean 接口提供了一個(gè)方法 destroy()，該方法在 Bean 銷毀之前調(diào)用。

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");
    }
}

2. @PostConstruct 和 @PreDestroy 注解：

這兩個(gè)是案例1中相對(duì)應(yīng)的注解方式

@PostConstruct 注解用于在依賴注入完成后執(zhí)行初始化方法。
@PreDestroy 注解用于在 Bean 銷毀之前執(zhí)行清理方法。

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");
    }
}

3. Bean 定義的 initMethod 和 destroyMethod：

第三種方式的初始化和銷毀方法

在 Bean 定義中，可以通過 initMethod 和 destroyMethod 屬性指定初始化和銷毀方法。

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");
        }
    }
}

4. 實(shí)現(xiàn) BeanPostProcessor 接口：

BeanPostProcessor 接口提供了兩個(gè)方法：postProcessBeforeInitialization 和 postProcessAfterInitialization，分別在 Bean 初始化之前和之后調(diào)用。
這可以用于在 Bean 初始化的不同階段執(zhí)行自定義邏輯。

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) {
        // 在初始化之前執(zhí)行的代碼
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 在初始化之后執(zhí)行的代碼
        return bean;
    }
}

5. 實(shí)現(xiàn) SmartLifecycle 接口：

SmartLifecycle 是一個(gè)擴(kuò)展的接口，用于更復(fù)雜的生命周期管理，特別是在有多個(gè) Bean 依賴關(guān)系的場(chǎng)景中。
它提供了啟動(dòng)和停止控制，以及對(duì)應(yīng)的回調(diào)方法。

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() {
        // 啟動(dòng)邏輯
        if (isRunning.compareAndSet(false, true)) {
            // 實(shí)際的啟動(dòng)邏輯
            initializeResources();
            logger.info("Lifecycle bean started");
        }
    }

    @Override
    public void stop() {
        // 停止邏輯
        if (isRunning.compareAndSet(true, false)) {
            // 實(shí)際的停止邏輯
            releaseResources();
            logger.info("Lifecycle bean stopped");
        }
    }

    @Override
    public boolean isRunning() {
        return isRunning.get();
    }

    @Override
    public int getPhase() {
        // 控制啟動(dòng)和停止的順序
        return 0; // 默認(rèn)階段是 0，可以根據(jù)需要調(diào)整
    }

    private void initializeResources() {
        // 具體的資源初始化邏輯
    }

    private void releaseResources() {
        // 具體的資源釋放邏輯
    }
}

6. 使用 ApplicationListener 或 @EventListener：

這些用于監(jiān)聽?wèi)?yīng)用事件，如上下文刷新、上下文關(guān)閉等，可以在這些事件發(fā)生時(shí)執(zhí)行特定邏輯。
ApplicationListener 是一個(gè)接口，而 @EventListener 是一個(gè)注解，兩者都可以用于監(jiān)聽?wèi)?yīng)用事件。

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) {
        // 在應(yīng)用上下文刷新時(shí)執(zhí)行的代碼
        System.out.println("Application Context Refreshed");
    }
}

// 或者使用 @EventListener
@Component
public class MyEventListener {

    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        System.out.println("Handling context refreshed event.");
    }
}

7. 實(shí)現(xiàn) ApplicationContextAware 和 BeanNameAware 接口：

這些接口允許 Bean 在其生命周期內(nèi)訪問 ApplicationContext 和自身的 Bean 名稱。
通過實(shí)現(xiàn)這些接口，Bean 可以獲得對(duì) Spring 容器更深層次的訪問和控制。

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;
        // 可以在這里執(zhí)行與應(yīng)用上下文相關(guān)的操作
        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 或環(huán)境屬性
            // String someProperty = applicationContext.getEnvironment().getProperty("some.property");
            // ... 執(zhí)行操作
        } catch (Exception e) {
            logger.error("Error during performing some action", e);
        }
    }
}

8. 使用 FactoryBean：

FactoryBean 是一種特殊的 Bean，用于生成其他 Bean。
可以通過實(shí)現(xiàn) FactoryBean 接口來(lái)控制 Bean 的實(shí)例化過程。

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 的邏輯
}

9. 使用 EnvironmentAware 和 ResourceLoaderAware 接口：

這些接口允許 Bean 在其生命周期內(nèi)訪問 Spring 的 Environment 和資源加載器（ResourceLoader）。
通過實(shí)現(xiàn)這些接口，Bean 可以獲得對(duì)環(huán)境屬性和資源的訪問。

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;
    }
}

10. 實(shí)現(xiàn) BeanFactoryAware 接口：

通過實(shí)現(xiàn) BeanFactoryAware 接口，Bean 可以訪問到 Spring 容器中的 BeanFactory，從而可以進(jìn)行更復(fù)雜的依賴注入和管理，BeanFactoryAware 應(yīng)該在需要?jiǎng)討B(tài)訪問或管理 Bean 時(shí)作為特殊用例來(lái)使用。

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;
    }
}

11. 使用 @Profile 注解：

@Profile 注解允許根據(jù)不同的環(huán)境配置（如開發(fā)、測(cè)試、生產(chǎn)）來(lái)激活或禁用特定的 Bean。
這對(duì)于控制 Bean 在不同環(huán)境下的創(chuàng)建和管理非常有用。

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 實(shí)現(xiàn)
    }
}

12. 使用 @Lazy 注解：

@Lazy 注解用于延遲 Bean 的初始化直到它被首次使用。
這對(duì)于優(yōu)化啟動(dòng)時(shí)間和減少內(nèi)存占用非常有用，特別是對(duì)于那些不是立即需要的 Bean。

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 實(shí)現(xiàn)
    }
}

13. 使用 @DependsOn 注解：

@DependsOn 注解用于聲明 Bean 的依賴關(guān)系，確保一個(gè) Bean 在另一個(gè) Bean 之后被初始化。
這在管理 Bean 之間的依賴和初始化順序時(shí)非常有用。

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 實(shí)現(xiàn)
    }

    public static class AnotherBean {
        // 另一個(gè) Bean 實(shí)現(xiàn)
    }
}

14. 使用 @Order 或 Ordered 接口：

這些用于定義 Bean 初始化和銷毀的順序。
@Order 注解和 Ordered 接口可以幫助確保 Bean 按照特定的順序被創(chuàng)建和銷毀。

import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(Ordered.HIGHEST_PRECEDENCE)
@Component
public class MyHighPriorityBean {
    // 高優(yōu)先級(jí) Bean 實(shí)現(xiàn)
}

@Component
public class MyDefaultPriorityBean {
    // 默認(rèn)優(yōu)先級(jí) Bean 實(shí)現(xiàn)
}

15. 使用 @Conditional 注解：

@Conditional 注解用于基于特定條件創(chuàng)建 Bean。
你可以創(chuàng)建自定義條件或使用 Spring 提供的條件，如操作系統(tǒng)類型、環(huán)境變量、配置屬性等。

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 實(shí)現(xiàn)
    }

    public static class MyCondition implements Condition {

        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
            Environment env = context.getEnvironment();
            // 定義條件邏輯
            return env.containsProperty("my.custom.condition");
        }
    }
}

總結(jié)

Spring Boot 提供的這些方法使得開發(fā)者能夠靈活地控制 Bean 的生命周期，從而滿足不同的應(yīng)用需求和場(chǎng)景。無(wú)論是簡(jiǎn)單的應(yīng)用還是復(fù)雜的企業(yè)級(jí)系統(tǒng)，合理地利用這些機(jī)制可以有效地管理 Bean 的生命周期，提高應(yīng)用的性能和可維護(hù)性。選擇哪種方法取決于具體的需求、應(yīng)用的復(fù)雜性以及開發(fā)團(tuán)隊(duì)的偏好。正確地使用這些工具和技術(shù)可以使 Spring Boot 應(yīng)用更加健壯、靈活和高效。

以上就是SpringBoot中操作Bean的生命周期的方法總結(jié)的詳細(xì)內(nèi)容，更多關(guān)于SpringBoot操作Bean生命周期的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: