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 {@Autowiredprivate 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 {@Beanpublic 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 调用）");}// 依赖注入后执行@PostConstructpublic void postConstruct() {System.out.println("2️⃣ @PostConstruct 方法执行");}// 实现 InitializingBean 接口@Overridepublic void afterPropertiesSet() {System.out.println("3️⃣ afterPropertiesSet() 方法执行（InitializingBean）");}// Bean 可用阶段（业务方法）public void doSomething() {System.out.println("🚀 Bean 正在使用...");}// 销毁之前执行@PreDestroypublic void preDestroy() {System.out.println("4️⃣ @PreDestroy 方法执行");}// 实现 DisposableBean 接口@Overridepublic 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 {@PostConstructpublic void init() {System.out.println("Bean 初始化完成");}@PreDestroypublic 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 {@Overridepublic void afterPropertiesSet() {System.out.println("Bean 初始化 afterPropertiesSet()");}@Overridepublic 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 {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) {System.out.println("🚀 BeanPostProcessor - 初始化前：" + beanName);return bean;}@Overridepublic 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 应用关闭时销毁