深入理解Spring容器：从基础到原理（六）

一、引言

在之前的系列文章中，我们详细剖析了Spring容器从配置文件加载到解析和注册BeanDefinitions的一系列过程，这一系列操作就像是为Spring应用搭建了坚实的骨架。而今天，我们将深入探讨Spring容器在完成这些准备工作后，如何将注册的BeanDefinitions转化为实际可用的Bean实例，以及Bean实例在容器中的生命周期管理。这部分内容是Spring容器实现的关键环节，深入理解它们将有助于我们更好地把握Spring框架如何在运行时管理和协调各个组件，为开发健壮、高效的Java应用提供更坚实的理论基础。

二、实例化Bean：从定义到实例的蜕变

（一）实例化时机的抉择

  1. 在Spring容器中，Bean的实例化时机是一个值得深入探讨的问题。对于单例Bean（默认情况下），通常在容器启动时就会进行实例化。这就好比在一个工厂中，对于那些经常使用且整个生产过程中只需要一个实例的工具（类比单例Bean），工厂会在开工前就准备好，以提高生产效率。例如，在一个Web应用中，数据库连接池通常被设计为单例Bean，因为在整个应用的生命周期内，只需要一个连接池实例来管理数据库连接。

  2. 然而，对于非单例Bean（如原型模式的Bean），情况则有所不同。它们的实例化是在每次获取Bean时进行的。这类似于工厂中的一次性模具，每次生产特定产品（获取Bean实例）时才创建新的模具（实例化Bean）。例如，在一个订单处理系统中，如果订单对象被设计为原型Bean，那么每次创建新订单时，都会创建一个全新的订单对象实例。

  3. Spring容器通过对BeanDefinition的解析和配置信息的读取，来确定每个Bean的实例化时机。在DefaultListableBeanFactory中，有一系列复杂的逻辑来处理这个过程，涉及到对Bean的作用域（如单例、原型等）、依赖关系以及容器的初始化状态等多方面因素的综合考量。

（二）实例化的核心方法

  1. 当确定需要实例化一个Bean时，Spring容器会调用AbstractAutowireCapableBeanFactory类中的createBean方法。这个方法就像是一个魔法盒，里面包含了一系列复杂而有序的操作，将BeanDefinition转化为真实的Bean实例。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
RootBeanDefinition mbdToUse = mbd;
// 确保BeanDefinition已被解析
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass!= null &&!mbd.hasBeanClass() && mbd.getBeanClassName()!= null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 准备方法覆盖
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 给BeanPostProcessors一个机会返回代理对象，而不是实际的Bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean!= null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 真正的实例化操作
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
}
catch (BeanCreationException | ImplicitlyCreatedBeanWithConstructorArgsException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"Unexpected exception during bean creation", ex);
}
}
  1. 在这个方法中，首先会对BeanDefinition进行一些预处理工作，如解析Bean的类（如果尚未解析）、准备方法覆盖等。然后，会给BeanPostProcessors一个机会，看它们是否需要返回代理对象来代替实际的Bean实例。这就像是在创建产品之前，先询问一些专家（BeanPostProcessors）是否有特殊的处理或优化建议。如果没有特殊情况，最终会调用doCreateBean方法来完成实际的实例化操作。

（三）实例化的具体过程

  1. doCreateBean方法是实例化过程的核心，它包含了多个关键步骤。首先，通过反射创建Bean的实例，这就像是根据产品的设计图纸（Bean的类信息）使用模具（反射机制）制造出产品的毛坯（Bean实例）。例如，对于一个简单的用户服务类UserService，Spring会找到对应的UserService类，通过反射调用其构造函数创建实例。
// 使用合适的构造函数实例化Bean
beanInstance = instantiateBean(beanName, mbd);

  1. 接着，会处理循环依赖的情况。循环依赖是指多个Bean之间相互依赖，形成一个闭环。Spring通过一系列巧妙的缓存和提前暴露机制来解决这个问题，确保在存在循环依赖的情况下，每个Bean都能正确地获取到其依赖的实例。这就像是在一个复杂的机械装置中，各个零件之间可能存在相互依赖关系，Spring能够巧妙地安排组装顺序，避免出现死锁或错误的依赖关系。

  2. 然后，填充Bean的属性。这一步会根据BeanDefinition中定义的属性信息，将相应的值注入到Bean实例中。例如，如果UserService依赖于UserDao，在这一步会查找已经实例化的UserDao实例，并将其注入到UserService实例中。

// 填充Bean的属性
populateBean(beanName, mbd, instanceWrapper);
  1. 最后，会执行一些初始化回调方法，如init-method指定的方法（如果有的话）。这就像是在产品组装完成后，进行一些最后的调试和初始化操作，确保Bean实例处于可用状态。

（四）实例化的代码示例

  1. 假设我们有一个简单的用户管理系统，其中包含UserService和UserDao两个类。UserService依赖于UserDao来获取用户数据。首先，定义UserDao接口及其实现类UserDaoImpl：
public interface UserDao {
User getUserById(int id);
}
public class UserDaoImpl implements UserDao {
@Override
public User getUserById(int id) {
// 模拟从数据库获取用户数据
User user = new User();
user.setId(id);
user.setName("User " + id);
return user;
}
}
  1. 然后，定义UserService类：
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public User getUserById(int id) {
return userDao.getUserById(id);
}
}
  1. 在Spring配置文件中配置这两个Bean：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.Springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.Springframework.org/schema/beans
http://www.Springframework.org/schema/beans/Spring-beans.xsd">
<bean id="userDao" class="com.example.UserDaoImpl" />
<bean id="userService" class="com.example.UserService">
<property name="userDao" ref="userDao" />
</bean>
</beans>
  1. 当Spring容器启动时，会按照上述实例化流程创建UserService和UserDao的实例。首先，在实例化UserService时，发现它依赖于UserDao，会先去实例化UserDao。然后，将UserDao的实例注入到UserService中，完成UserService的实例化过程。我们可以通过以下方式获取UserService的实例并调用其方法：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
User user = userService.getUserById(1);
System.out.println(user.getName());
}
}

三、Bean的生命周期管理

（一）生命周期的各个阶段

  1. Bean的生命周期在Spring容器中经历了多个阶段，从创建到销毁，每个阶段都有特定的操作和回调机制。首先是实例化阶段，我们刚刚详细介绍过，通过反射创建Bean的实例。这就像是一个新生命的诞生，为后续的发展奠定了基础。

  2. 接着是属性填充阶段，将依赖的Bean实例注入到当前Bean中，使Bean能够正常工作。这类似于为一个人提供必要的资源和工具，让他能够在社会中发挥作用。

  3. 然后是初始化阶段，在这个阶段会执行一系列初始化操作，包括调用init-method指定的方法（如果有）、执行BeanPostProcessors的postProcessBeforeInitialization和postProcessAfterInitialization方法等。这就像是一个人在成长过程中接受教育和培训，为未来的发展做好准备。例如，在一个Web应用中，可能会在初始化阶段配置一些过滤器、监听器等组件。

  4. 最后是销毁阶段，当容器关闭或Bean不再需要时，会执行销毁操作，如调用destroy-method指定的方法（如果有）。这就像是一个人退休或结束生命时，进行一些收尾工作，释放资源。

（二）相关接口和方法的作用

  1. InitializingBean和DisposableBean接口为Bean提供了一种简单的方式来参与生命周期管理。如果一个Bean实现了InitializingBean接口，其afterPropertiesSet方法会在属性填充后、初始化回调之前被调用。这就像是一个人在获得了必要的资源后，进行自我检查和准备工作。例如，在一个数据库连接池的Bean实现中，可能会在afterPropertiesSet方法中进行一些连接测试和初始化操作。

  2. 同样，如果一个Bean实现了DisposableBean接口，其destroy方法会在容器关闭时被调用，用于释放资源。这就像是一个人在退休时，清理自己的工作空间和归还工具。

  3. 除了这些接口，BeanPostProcessors在Bean的生命周期中也扮演着重要的角色。它们可以在Bean的初始化前后进行额外的处理，如修改Bean的属性、替换Bean实例等。这就像是在一个人的成长过程中，有一些外部的导师或顾问可以对他进行指导和干预。例如，在一个安全框架中，可能会有一个BeanPostProcessor在Bean初始化后对其进行安全增强，如添加权限检查等功能。

（三）生命周期管理的代码示例

  1. 继续以上面的用户管理系统为例，假设我们希望在UserService初始化时打印一些日志信息，在销毁时释放一些资源。我们可以让UserService实现InitializingBean和DisposableBean接口：
public class UserService implements InitializingBean, DisposableBean {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public User getUserById(int id) {
return userDao.getUserById(id);
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("UserService初始化完成，准备提供服务。");
}
@Override
public void destroy() throws Exception {
System.out.println("UserService正在销毁，释放相关资源。");
}
}
  1. 当Spring容器启动和关闭时，会自动调用UserService的afterPropertiesSet和destroy方法。我们可以通过以下方式测试：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
userService.getUserById(1);
// 关闭容器，触发Bean的销毁方法
((ClassPathXmlApplicationContext) context).close();
}
}

在这个示例中，我们可以看到UserService在初始化时打印了日志信息，在容器关闭时也正确地执行了销毁操作，释放了相关资源。

四、总结与展望

通过对Spring容器中Bean实例化和生命周期管理的深入剖析，我们全面了解了Spring如何将注册的BeanDefinitions转化为实际可用的Bean实例，并在其整个生命周期中进行有效的管理和协调。从实例化的时机选择、复杂的创建过程到生命周期的各个阶段以及相关接口和方法的运用，每一个环节都体现了Spring框架的强大和灵活。在后续的学习中，我们将进一步探索Spring容器在面对复杂的依赖关系、多线程环境以及与其他框架集成时的更多特性和最佳实践。希望本文能够帮助码龄1 - 5年的程序员更加深入地理解Spring容器的内部机制，为开发高质量、高性能的Java应用提供有力的支持。让我们共同期待下一次的深入探索之旅，继续挖掘Spring框架的更多奥秘。

# spring # java # 后端 # rpc # kafka # spring boot # spring cloud
Logo
魔乐社区

魔乐社区（Modelers.cn) 是一个中立、公益的人工智能社区，提供人工智能工具、模型、数据的托管、展示与应用协同服务，为人工智能开发及爱好者搭建开放的学习交流平台。社区通过理事会方式运作，由全产业链共同建设、共同运营、共同享有，推动国产AI生态繁荣发展。

更多推荐

cover

工业物联网时序数据库选型指南：Apache IoTDB 技术架构与实战解析

avatar 魔乐社区
cover

面向未来的工业大数据架构：时序数据库（TSDB）选型避坑指南和国产化思考

avatar 魔乐社区
cover

宇树G1-D：人形机器人下一步方向！

avatar 魔乐社区