SpringBean模块（一）定义如何创建生命周期

一、介绍

1、简介

在 Spring 框架中，Bean 是指由 Spring 容器 管理的 Java 对象。Spring 负责创建、配置和管理这些对象，并在应用程序运行时对它们进行依赖注入（Dependency Injection，DI）。

通俗地讲，Spring Bean 就是 Spring 容器中的一个组件，它可以是一个普通的 Java 类，但被 Spring 管理起来后，就称为 "Bean"。

2、核心特点

由 Spring 容器管理
Bean 的生命周期由 Spring 负责，不需要手动创建和销毁。
通过依赖注入（DI）管理对象
Spring 自动为 Bean 注入所需的依赖，减少代码耦合。
可以是任何 Java 对象
普通 Java 类、Service、Repository、Controller 都可以是 Spring Bean。

二、如何创建 Spring Bean

有几下几种方法：

1、自动扫描（使用 `@Component及其派生注解`）

Spring 提供了一系列注解（@Component、@Service、@Repository、@Controller），用于标识一个类是 Spring Bean：

见注解篇

Springbean（二）@Component及其派生注解自动注入（1）介绍和规范_component 注入-CSDN博客

Springbean（二）@Component及其派生注解自动注入（2）使用注意和加载问题-CSDN博客

（1）注册

@Component 让 Spring 在 类路径扫描（Component Scanning） 时自动发现该类并注册为 Bean。

import org.springframework.stereotype.Component;

@Component // 让 Spring 扫描并管理这个类
public class MyBean {
    public void sayHello() {
        System.out.println("Hello, Spring Bean!");
    }
}

（2）使用

使用 @Autowired 注入 Bean

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Autowired
    private MyBean myBean; // 依赖注入

    public void doSomething() {
        myBean.sayHello();
    }
}

2、手动注册 Bean（使用 `@Bean`）

如果不能修改原始类（例如第三方库），可以使用 @Bean 方法在 @Configuration 类中手动注册。

（1）注册

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

@Configuration
public class MyConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean(); // 手动创建 Bean
    }
}

（2）使用

同上

3、传统方式（在 XML 配置中定义 Bean）

（1）注册

Spring 也支持 XML 方式定义 Bean：

<bean id="myBean" class="com.example.MyBean"/>

（2）使用

然后在 Java 代码中获取 Bean：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyBean myBean = context.getBean(MyBean.class);

三、生命周期

1、概述

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.stereotype.Component;

@Component
public class MyBean implements InitializingBean, DisposableBean {

    public MyBean() {
        System.out.println("1️⃣ Bean 实例化（Constructor 调用）");
    }

    // 依赖注入后执行
    @PostConstruct
    public void postConstruct() {
        System.out.println("2️⃣ @PostConstruct 方法执行");
    }

    // 实现 InitializingBean 接口
    @Override
    public void afterPropertiesSet() {
        System.out.println("3️⃣ afterPropertiesSet() 方法执行（InitializingBean）");
    }

    // Bean 可用阶段（业务方法）
    public void doSomething() {
        System.out.println("🚀 Bean 正在使用...");
    }

    // 销毁之前执行
    @PreDestroy
    public void preDestroy() {
        System.out.println("4️⃣ @PreDestroy 方法执行");
    }

    // 实现 DisposableBean 接口
    @Override
    public void destroy() {
        System.out.println("5️⃣ destroy() 方法执行（DisposableBean）");
    }
}

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class BeanLifecycleApplication {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(BeanLifecycleApplication.class, args);
        
        // 获取 Bean 并调用方法
        MyBean myBean = context.getBean(MyBean.class);
        myBean.doSomething();

        // 关闭 Spring 容器（触发 Bean 销毁）
        ((SpringApplication) context).close();
    }
}

一句话总结：Spring 负责 Bean 生命周期，开发者可以在关键阶段自定义行为！

（1）实例化（Instantiation）

Spring 通过 new 反射创建 Bean 实例。

（2）属性填充（Populate Properties）

Spring 依赖注入，设置 Bean 的 @Autowired 或 XML 配置的属性；

（3）BeanPostProcessor#postProcessBeforeInitialization()；

（4）初始化（Initialization）

调用 InitializingBean#afterPropertiesSet()（如果实现了 InitializingBean）
调用 @PostConstruct 标注的方法（如果有）

（5）BeanPostProcessor#postProcessAfterInitialization()

（6）Bean 可用（In Use）

（7）销毁（Destruction）

调用 @PreDestroy 标注的方法（如果有）
调用 DisposableBean#destroy()（如果实现了 DisposableBean）
XML 配置或 @Bean(destroyMethod="xxx") 自定义销毁方法

看下具体流程

1、创建前准备阶段

在这个阶段，Spring上下文和相关配置被解析，查找与Bean相关的配置内容，如`init-method`和`destory-method`，以及BeanFactoryPostProcessor等前置和后置处理。这些配置允许开发者在Bean加载过程中实现扩展机制。

2、实例化Bean

对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。

对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。

通过反射机制，Spring创建Bean的实例对象。在这个阶段，Spring会扫描和解析Bean声明的属性。

3、依赖注入阶段

实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息以及通过BeanWrapper提供的设置属性的接口完成属性设置与依赖注入。

4、其他处理

4.1、处理Aware接口

Spring会检测该对象是否实现了xxxAware接口，通过Aware类型的接口，可以让我们拿到Spring容器的一些资源：

①如果这个Bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，传入Bean的名字；
②如果这个Bean实现了BeanClassLoaderAware接口，调用setBeanClassLoader()方法，传入ClassLoader对象的实例。
②如果这个Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。
③如果这个Bean实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；

4.2、BeanPostProcessor前置处理：

如果想对Bean进行一些自定义的前置处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。

4.3、InitializingBean：

如果Bean实现了InitializingBean接口，执行afeterPropertiesSet()方法。

4.4、init-method：

如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。

4.5、BeanPostProcessor后置处理：

如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；

以上几个步骤完成后，Bean就已经被正确创建了，之后就可以使用这个Bean了。

5、DisposableBean：

当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；

6、destroy-method：

最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

以上生命周期包含两个重要的事件：初始化和销毁事件。初始化事件发生在Bean的属性赋值之后，在`init-method`操作之前，而销毁事件则发生在Bean在容器关闭时，内存释放之前。

2、生命周期回调方式

Spring 提供多种方式来定制 Bean 生命周期的行为：

（1）使用 `@PostConstruct` 和 `@PreDestroy`（推荐）

推荐使用 @PostConstruct 和 @PreDestroy，因为它们是标准 Java 注解，和 Spring 解耦。

@PostConstruct：Bean 初始化完成后执行
@PreDestroy：Bean 销毁前执行

@Component
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("Bean 初始化完成");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Bean 即将被销毁");
    }
}

（2）实现 `InitializingBean` 和 `DisposableBean`

Spring 提供了 InitializingBean 和 DisposableBean 两个接口，不推荐使用，因为这样会耦合 Spring 框架，影响代码的可移植性。

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

@Component
public class MyBean implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() {
        System.out.println("Bean 初始化 afterPropertiesSet()");
    }

    @Override
    public void destroy() {
        System.out.println("Bean 销毁 destroy()");
    }
}

（3）使用 `@Bean(initMethod, destroyMethod)`

如果是通过 @Configuration 手动注册 Bean，可以使用 @Bean 的 initMethod 和 destroyMethod：

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

@Configuration
public class MyConfig {
    @Bean(initMethod = "init", destroyMethod = "cleanup")
    public MyBean myBean() {
        return new MyBean();
    }
}

class MyBean {
    public void init() {
        System.out.println("Bean 初始化（initMethod）");
    }

    public void cleanup() {
        System.out.println("Bean 销毁（destroyMethod）");
    }
}

（4）使用 `BeanPostProcessor`（高级用法）

如果需要在 Bean 初始化前后进行操作，可以使用 BeanPostProcessor，适用于 AOP、代理、动态增强等高级需求。

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) {
        System.out.println("🚀 BeanPostProcessor - 初始化前：" + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("✅ BeanPostProcessor - 初始化后：" + beanName);
        return bean;
    }
}

3、什么时候会触发 Bean 的销毁

单例（Singleton）Bean：Spring 容器关闭时销毁
多例（Prototype）Bean：Spring 不会自动管理销毁，需要手动处理
Web 应用：
- request 作用域：HTTP 请求结束时销毁
- session 作用域：Session 结束时销毁
- application 作用域：Web 应用关闭时销毁