Spring Bean生命周期

Spring Bean生命周期

1. Bean的生命周期概览

Bean的生命周期包括以下几个关键阶段：

1. 实例化：当Spring容器启动时，它会首先实例化Bean对象。
2. 设置属性：通过Spring配置文件或注解，Spring容器会自动为Bean设置依赖的属性。
3. Aware接口：若Bean实现了BeanNameAware和BeanFactoryAware接口，Spring容器会在这个阶段注入Bean的名字和BeanFactory。
4. Bean后处理器的before方法执行
5. 初始化：Bean完成属性注入后，容器会调用Bean的初始化方法（无论是通过InitializingBean接口，还是通过@PostConstruct注解或者@Bean(initMethod)方法）。
6. Bean后处理器的after方法执行
7. 使用Bean
8. 销毁：当容器关闭时，Bean会调用销毁方法（通过DisposableBean接口、@PreDestroy注解或者@Bean(destroyMethod)方法）。

2. 示例解析

我们用一个简单的例子来说明Spring Bean的生命周期。

2.1 配置类 (BeanConfig.java)

首先，我们定义一个配置类BeanConfig，通过@Configuration注解标识为配置类。@Bean注解用于定义一个Bean实例，并指定初始化和销毁方法。

@Configuration
public class BeanConfig {
    @Bean(initMethod = "initBean", destroyMethod = "destoryBean")
    public User user() {
        User user = new User();
        user.setName("admin");
        return user;
    }
}

在这个类中，我们定义了一个名为user的Bean，并指定了初始化方法initBean和销毁方法destoryBean。

2.2 主应用程序 (DemoApplication.java)

主应用程序类通过SpringApplication.run()启动Spring应用，获取user Bean并在控制台输出它的名字。最后，调用context.close()关闭容器，触发销毁方法的执行。

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
        User user = context.getBean("user", User.class);
        System.out.println("7. 使用bean:" + user.getName());
        context.close();
    }
}

2.3 后处理器 (LogBeanPostProcessor.java)

LogBeanPostProcessor是一个自定义的Bean后处理器，它实现了BeanPostProcessor接口，用来在Bean初始化前后做一些额外操作。

@Component
public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof User) {
            System.out.println("4. Bean后处理器的before方法执行，即将开始初始化");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof User) {
            System.out.println("6. Bean后处理器的after方法执行，初始化完成");
        }
        return bean;
    }
}

2.4 Bean类 (User.java)

User类实现了多个Spring生命周期接口，并定义了自定义的初始化和销毁方法。

public class User implements BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean {

    private String name;

    // 构造函数
    public User() {
        System.out.println("1. 实例化Bean");
    }

    // 设置属性
    public void setName(String name) {
        this.name = name;
        System.out.println("2. 设置属性");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("3. Aware相关接口,Bean名字：" + name);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3. Aware相关接口,BeanFactory: " + beanFactory);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. 实现InitializingBean接口的afterPropertiesSet执行初始化");
    }

    @PostConstruct
    public void 自定义初始化bean() {
        System.out.println("5. 使用PostConstruct初始化bean");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("8. 实现DisposableBean接口的destroy执行销毁");
    }

    public void destoryBean() {
        System.out.println("8. 使用@Bean(destroyMethod)销毁bean");
    }

    @PreDestroy
    public void 自定义销毁bean() {
        System.out.println("8. 使用PreDestroy注解销毁bean");
    }

    public String getName() {
        return name;
    }

    private void initBean() {
        System.out.println("5. 使用@Bean(initMethod)初始化bean");
    }
}

2.5 输出结果

当你运行应用时，你将看到如下输出：

1. 实例化Bean
2. 设置属性
3. Aware相关接口,Bean名字：user
3. Aware相关接口,BeanFactory: org.springframework.beans.factory.support.DefaultListableBeanFactory@6d0e50e4
4. Bean后处理器的before方法执行，即将开始初始化
5. 使用PostConstruct初始化bean
5. 实现InitializingBean接口的afterPropertiesSet执行初始化
6. Bean后处理器的after方法执行，初始化完成
7. 使用bean:admin
8. 使用PreDestroy注解销毁bean
8. 使用@Bean(destroyMethod)销毁bean
8. 实现DisposableBean接口的destroy执行销毁