@Bean 控制 Spring Bean 生命周期

1.基本用法

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

public class MyService {
    public void init() {
        // 在此添加初始化逻辑，例如资源的初始化、建立数据库连接等
        System.out.println("MyService 正在初始化...");
    }

    public void destroy() {
        // 在此添加销毁逻辑，例如关闭资源、释放数据库连接等
        System.out.println("MyService 正在销毁...");
    }
}

在上述代码中，@Configuration 注解的 AppConfig 类用于定义 Spring 的配置。

@Bean(initMethod = "init", destroyMethod = "destroy") 告诉 Spring 在创建 MyService Bean 时调用 init 方法进行初始化，在销毁 MyService Bean 时调用 destroy 方法进行清理。

可以在 init 方法中执行一些初始化操作，比如加载配置文件、创建连接、启动服务等。

在 destroy 方法中可以进行一些清理操作，比如关闭连接、释放资源、停止服务等。

2.更复杂的初始化和销毁逻辑

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Configuration
public class AppConfig {
    @Bean
    public ExecutorService executorService() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        return executorService;
    }

    @Bean(destroyMethod = "shutdown")
    public ExecutorService managedExecutorService() {
        return Executors.newFixedThreadPool(5);
    }
}

对于 executorService Bean，没有指定 destroyMethod，因为 Spring 会自动检测并调用 ExecutorService 的 shutdown 方法进行销毁。
对于 managedExecutorService Bean，明确指定了 destroyMethod = "shutdown"，确保 Spring 会调用 shutdown 方法关闭线程池。

这种方式允许你对不同的资源进行不同级别的控制，对于一些需要特殊处理的资源，可以显式指定销毁方法，而对于一些遵循 Java 标准的资源，Spring 可以自动处理。

3.结合其他 Spring 特性

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Value;
import java.io.File;

@Configuration
public class AppConfig {
    @Value("${app.file.path}")
    private String filePath;

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public File fileHandler() {
        return new File(filePath);
    }
}

public class File {
    private String filePath;

    public File(String filePath) {
        this.filePath = filePath;
    }

    public void init() {
        // 在此根据文件路径进行初始化操作，例如创建文件或检查文件是否存在等
        System.out.println("正在初始化文件处理器，文件路径: " + filePath);
    }

    public void destroy() {
        // 在此进行文件资源的清理，例如关闭文件流等
        System.out.println("正在销毁文件处理器");
    }
}

在这个例子中，@Value("${app.file.path}") 从配置文件中读取文件路径。

@Bean(initMethod = "init", destroyMethod = "destroy") 用于控制 File 类的生命周期。

在 init 方法中，可以根据文件路径进行一些操作，比如创建文件、打开文件流等。

在 destroy 方法中，可以进行一些清理操作，如关闭文件流、释放文件锁等。

4.与条件化 Bean 结合使用

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    @Conditional(MyCondition.class)
    public MyService conditionalMyService() {
        return new MyService();
    }
}

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 根据条件判断是否创建 Bean
        return true;
    }
}

@Conditional(MyCondition.class) 可以根据条件决定是否创建 MyService Bean。

可以将 @Bean 注解与条件化 Bean 结合使用，在创建 Bean 时进行条件判断，并且可以结合生命周期控制，确保只有在满足条件时才创建并控制该 Bean 的生命周期。

5.优势和注意事项

使用 @Bean 注解可以在 Spring 中对 Bean 的生命周期进行有效的控制，通过指定初始化和销毁方法，可以确保资源的正确管理和程序的健壮性。根据不同的业务需求和资源类型，可以灵活运用 @Bean 注解及其相关特性。

优势：

@Bean 注解提供了一种灵活的方式来控制 Bean 的生命周期，尤其是对于第三方库或无法修改源代码的类，可以通过 initMethod 和 destroyMethod 来添加初始化和销毁逻辑。

可以结合 Spring 的其他特性，如 @Value 进行属性注入，@Conditional 进行条件化创建等，增强了配置的灵活性和可扩展性。

注意事项：

确保 initMethod 和 destroyMethod 中执行的操作是安全的，避免在这些方法中抛出异常，以免影响整个 Spring 容器的稳定性。

对于一些资源密集型的操作，如打开文件、建立数据库连接，要确保在 destroyMethod 中正确释放资源，防止资源泄漏。

6.除 `@Bean` 外控制 Bean 生命周期的方式

6.1实现 InitializingBean 和 DisposableBean 接口

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

@Component
public class MyComponent implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        // 该方法会在 Bean 的属性设置完成后被调用，可用于执行初始化操作
        System.out.println("MyComponent is being initialized (InitializingBean)");
    }

    @Override
    public void destroy() throws Exception {
        // 该方法会在 Bean 销毁时被调用，可用于执行资源释放等操作
        System.out.println("MyComponent is being destroyed (DisposableBean)");
    }
}

InitializingBean 接口包含 afterPropertiesSet() 方法，它会在 Spring 容器完成 Bean 的属性设置后被调用，可用于执行一些初始化操作，如建立数据库连接、初始化缓存等。

DisposableBean 接口包含 destroy() 方法，它会在 Spring 容器销毁 Bean 时调用，适合执行一些清理操作，如关闭文件、释放数据库连接等。

6.2使用 JSR-250 注解：@PostConstruct 和 @PreDestroy

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @PostConstruct
    public void init() {
        // 该方法会在 Bean 的构造函数和属性注入完成后被调用，用于初始化操作
        System.out.println("MyComponent is being initialized (@PostConstruct)");
    }

    @PreDestroy
    public void cleanup() {
        // 该方法会在 Bean 销毁前被调用，用于清理操作
        System.out.println("MyComponent is being destroyed (@PreDestroy)");
    }
}

@PostConstruct 注解标记的方法会在 Bean 的构造函数和属性注入完成后调用，可进行一些初始化工作，如启动后台线程、加载配置等。

@PreDestroy 注解标记的方法会在 Bean 销毁前调用，可用于资源释放，如关闭线程池、清理临时文件等。

6.3自定义初始化和销毁方法

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {

    @Autowired
    public void customInit() {
        // 自定义的初始化方法，可以通过 @Autowired 等注入依赖，在属性注入后执行
        System.out.println("MyComponent is being initialized (custom init)");
    }

    public void customDestroy() {
        // 自定义的销毁方法，可用于资源释放等操作
        System.out.println("MyComponent is being destroyed (custom destroy)");
    }
}

可以在 Bean 中定义自定义的初始化和销毁方法，Spring 可以通过方法名约定或配置来调用它们。

对于自定义的初始化方法，还可以利用 @Autowired 等注解注入依赖，在属性注入完成后进行初始化操作。

6.4 BeanPostProcessor 接口

import org.springframework.beans.BeansException;
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) throws BeansException {
        if (bean instanceof MyComponent) {
            System.out.println("Before initialization of MyComponent");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyComponent) {
            System.out.println("After initialization of MyComponent");
        }
        return bean;
    }
}

BeanPostProcessor 接口允许你在 Bean 的初始化前后插入自定义逻辑。

postProcessBeforeInitialization 方法会在 Bean 初始化之前调用，可用于前置处理，如修改 Bean 的属性、检查 Bean 的状态等。

postProcessAfterInitialization 方法会在 Bean 初始化之后调用，可用于后置处理，如添加代理、包装 Bean 等。

6.5基于 XML 配置的方式

<beans>
    <bean id="myComponent" class="com.example.MyComponent" init-method="init" destroy-method="cleanup">
        <!-- 配置 Bean 的属性等 -->
    </bean>
</beans>

在 XML 配置中，可以使用 init-method 属性指定 Bean 的初始化方法，destroy-method 属性指定 Bean 的销毁方法。

这种方式适用于传统的 Spring 配置，对于不使用 Java 配置的项目仍然很有用。

这些不同的方式提供了丰富的手段来控制 Bean 的生命周期，你可以根据具体情况选择最适合的方法。

例如，对于标准的 Spring 组件，使用 @PostConstruct 和 @PreDestroy 可能更方便；对于需要更细粒度控制或需要处理第三方类的情况，BeanPostProcessor 或 @Bean 注解的方法属性可能更合适；对于遵循传统的 XML 配置的项目，可使用 XML 中的 init-method 和 destroy-method。