Spring框架实现原理详解：从概念到Bean生命周期与核心设计思想
1. 概念与作用：什么是Spring？
Spring 是一个开源的、轻量级的、用于构建企业级应用的 控制反转（Inversion of Control, IoC） 和 面向切面编程（Aspect-Oriented Programming, AOP） 的框架。
核心思想：控制反转（IoC）
传统开发中，我们通过 new 关键字手动创建对象，依赖关系由程序员直接管理。这种方式导致代码耦合度高，难以测试和维护。
IoC 的本质是：将对象的创建和依赖关系的管理，交给框架来完成，而不是由程序员自己编写。
比如，没有Spring时：
public class UserService {
private UserDao userDao = new UserDao(); // 硬编码依赖，无法替换或测试
public void saveUser() {
userDao.save();
}
}
使用Spring后：
@Service
public class UserService {
@Autowired
private UserDao userDao; // 依赖由Spring注入，解耦了对象创建与使用
public void saveUser() {
userDao.save();
}
}
Spring容器负责创建 UserDao 实例，并将其注入到 UserService 中。这就是 控制反转 的体现：控制权从程序员转移到了Spring框架。
2. Spring解决了哪些问题？
| 问题 | 传统方式 | Spring解决方案 |
|---|---|---|
| 对象创建复杂 | 手动 new，逻辑分散 | 通过IoC容器统一管理对象生命周期 |
| 依赖关系混乱 | 硬编码，耦合度高 | 使用 @Autowired 自动注入，解耦 |
| 测试困难 | 依赖具体实现类 | 可注入模拟对象（Mock）进行单元测试 |
| 配置繁琐 | 代码中嵌入配置 | 支持XML、Java Config、注解等多种配置方式 |
3. Bean的完整生命周期
Spring对每个 Bean 的创建都有一套完整的生命周期管理流程，主要包括以下阶段：
- 实例化（Instantiation）：通过反射调用构造函数创建对象。
- 属性填充（Populate Properties）：将配置的依赖（通过
@Autowired、<property>等）注入到对象中。 - 设置Bean名称与容器（Set Bean Name & Container）：如果实现了
BeanNameAware接口，会调用setBeanName()。 - 设置上下文（Set ApplicationContext）：如果实现了
ApplicationContextAware接口，会调用setApplicationContext()。 - 前置处理（PostProcessBeforeInitialization）：调用所有
BeanPostProcessor的postProcessBeforeInitialization方法。 - 初始化（Initialization）：
- 调用
InitializingBean接口的afterPropertiesSet()方法。 - 调用自定义的
init-method方法（如init()）。
- 调用
- 后置处理（PostProcessAfterInitialization）：调用所有
BeanPostProcessor的postProcessAfterInitialization方法。 - 就绪可用（Ready for Use）：此时
Bean已完全初始化，可以被应用程序使用。 - 销毁（Destruction）：当容器关闭时，调用
DisposableBean接口的destroy()方法，或自定义的destroy-method。
4. 核心代码解析：Bean 创建过程关键逻辑（简化版）
Spring 创建 Bean 的核心逻辑主要在 DefaultSingletonBeanRegistry 和 AbstractAutowireCapableBeanFactory 中。以下是精简的核心伪代码逻辑（模拟真实流程）：
// 1. 检查是否已存在（单例缓存）
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null) {
return sharedInstance;
}
// 2. 生成 BeanDefinition 并解析依赖（此处省略详细解析）
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 3. 尝试创建单例 Bean
Object bean = createBean(beanName, bd, args);
// 4. 内部创建逻辑（关键步骤）
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 1. 生成实例（反射）
Object instance = instantiateBean(beanName, mbd);
// 2. 属性填充（依赖注入）
populateBean(beanName, mbd, instance);
// 3. 初始化（回调、Aware 接口等）
exposeBean(beanName, instance);
return initializeBean(beanName, instance, mbd);
}
// 5. 属性填充示例（依赖注入）
private void populateBean(String beanName, RootBeanDefinition mbd, Object instance) {
// 1. 找到所有需要注入的字段/方法（通过注解或XML）
PropertyValues pvs = mbd.getPropertyValues();
if (!pvs.isEmpty()) {
// 2. 递归获取依赖的 Bean（可能触发循环依赖检测）
for (PropertyValue pv : pvs.getPropertyValueList()) {
String propertyName = pv.getName();
Object value = pv.getValue();
if (value instanceof BeanReference) {
BeanReference ref = (BeanReference) value;
Object dependentBean = getBean(ref.getBeanName());
// 递归调用 getBean()，形成循环依赖链路检测
pv.setValue(dependentBean);
}
}
}
}
// 6. 循环依赖解决机制（核心！）
// Spring 使用三级缓存解决循环依赖问题：
// - singletonObjects：一级缓存，存放完全初始化好的 Bean
// - earlySingletonObjects：二级缓存，存放提前暴露的原始对象（未完成初始化）
// - singletonFactories：三级缓存，存放创建工厂（用于生成早期引用）
// 例如：A 依赖 B，B 依赖 A
// 步骤：
// 1. A 开始创建 → 放入 singletonFactories（三级缓存）
// 2. A 创建过程中需注入 B → B 开始创建 → 放入 singletonFactories
// 3. B 创建中需注入 A → 从 singletonFactories 取出 A 工厂 → 生成 A 原型 → 注入给 B
// 4. B 创建完成，放入 singletonObjects
// 5. A 继续创建，使用已注入的 B → A 创建完成，放入 singletonObjects
// 简化逻辑如下：
public Object getEarlyBeanReference(String beanName, Object bean, RootBeanDefinition mbd) {
// 仅在需要解决循环依赖时启用提前暴露机制
if (isSingletonCurrentlyInCreation(beanName)) {
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, bean));
return bean;
}
return bean;
}
5. Spring的核心设计思想与常用设计模式
Spring框架的设计大量借鉴了经典的设计模式，使其结构清晰、可扩展性强。
5.1 工厂模式（Factory Pattern）
Spring的 BeanFactory 和 ApplicationContext 就是典型的工厂模式。它们负责生产（创建）各种类型的 Bean，而客户端（我们的代码）无需关心具体的创建逻辑。
// 伪代码：Spring内部的Bean创建逻辑核心部分
public Object getBean(String beanName) {
// 1. 从缓存中获取（一级缓存：singletonObjects）
Object bean = singletonObjects.get(beanName);
if (bean != null) return bean;
// 2. 生成Bean定义（BeanDefinition）
BeanDefinition bd = getBeanDefinition(beanName);
// 3. 创建Bean（调用构造函数等）
Object instance = createBeanInstance(bd);
// 4. 填充属性（依赖注入）
populateBean(instance, bd);
// 5. 初始化（执行初始化方法）
initializeBean(instance, bd);
// 6. 注册到单例池（一级缓存）
singletonObjects.put(beanName, instance);
return instance;
}
5.2 单例模式（Singleton Pattern）
Spring默认的 Bean 作用域是单例（Singleton），即同一个 Bean 在整个应用上下文中只存在一个实例。这保证了资源的高效利用，也符合大多数业务场景的需求。
5.3 代理模式（Proxy Pattern）
AOP功能的核心就是基于代理模式。当我们在方法上加上 @Transactional、@Cacheable 等注解时，Spring会为该方法生成一个代理对象，在执行前/后插入额外的逻辑（如开启事务、缓存读写）。
📌 注意：以上生命周期在实际代码中由
AbstractAutowireCapableBeanFactory类中的createBean()方法驱动，是Spring最核心的逻辑之一。
5. 一个简单示例：如何使用Spring管理一个简单的业务类
// 1. 定义一个服务类，被Spring管理
@Service
public class OrderService {
// 2. 通过@Autowired自动注入依赖（遵循依赖注入原则）
@Autowired
private PaymentService paymentService;
public void placeOrder() {
System.out.println("开始下单...");
paymentService.pay();
System.out.println("订单已成功创建！");
}
}
// 3. 定义一个支付服务类，同样被Spring管理
@Service
public class PaymentService {
public void pay() {
System.out.println("正在支付...支付成功！");
}
}
// 4. 启动类（主类）
@SpringBootApplication
public class SpringDemoApplication {
public static void main(String[] args) {
// 5. 启动Spring应用上下文（容器）
ApplicationContext context = SpringApplication.run(SpringDemoApplication.class, args);
// 6. 从容器中获取Bean
OrderService orderService = context.getBean(OrderService.class);
// 7. 调用方法，观察依赖注入的效果
orderService.placeOrder();
}
}
输出结果：
开始下单...
正在支付...支付成功！
订单已成功创建！
这个例子完美展示了Spring的核心能力：
- IoC：
OrderService不需要自己去new PaymentService，而是由Spring注入。 - DI：
@Autowired实现了依赖注入，让代码更简洁、可维护。 - 容器管理：
ApplicationContext是整个应用的“大脑”，负责管理所有Bean的生命周期。
6. 总结：为什么学习Spring？
Spring不仅仅是一个框架，它代表了一种现代化的、解耦的、可维护的软件设计思想。理解其背后的实现原理，不仅能帮助你写出更好的代码，更能让你在面对复杂系统时，拥有更强的架构能力和解决问题的能力。
✅ 掌握Spring，就是掌握现代Java开发的“金钥匙”。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
