一、为什么每一个 Java 开发者都应该手写一次 IOC
在 Java 后端开发中,Spring 几乎是绕不开的基础设施。大多数开发者每天都在使用 @Component、@Autowired、ApplicationContext、getBean 这些 API,但如果被追问一句:@Autowired 到底是怎么把对象注入进来的?ApplicationContext 启动时究竟做了什么?为什么 Spring 能解决循环依赖?很多人会发现自己的理解仍然停留在"能写、能跑、但说不清原理"的阶段。
面试中的高频问题,比如"Spring IOC 的原理是什么""Bean 的生命周期有哪些阶段""三级缓存分别是干什么的""一级缓存和二级缓存为什么不直接合并",本质上考察的都是同一个东西:你是否真正理解 IOC 容器的工作机制,而不只是背过结论。
只靠背八股文,很难应对连续追问。比如面试官接着问:既然一级缓存已经存了完整对象,为什么还需要二级缓存和三级缓存?可不可以只用二级缓存解决循环依赖?Bean 的代理对象是在什么时候生成的?这些问题只有当你亲手实现过一个简化版 IOC 容器之后,才能从源码思路上给出有说服力的回答。
本文不会再把 Spring 源码拆成一个个零散的知识点,而是带大家从零开始,用纯 Java 徒手实现一个可运行的简化版 IOC 容器。我们会依次完成 Bean 定义、Bean 注册、反射创建对象、依赖注入、注解扫描、生命周期扩展点、循环依赖处理,以及一个极简 AOP 代理。整个过程只依赖 JDK 自带的反射、注解和集合能力,不引入任何第三方框架。
读完本文,你会获得以下收获:
-
彻底理解控制反转(IOC)与依赖注入(DI)的本质关系和实现差异;
-
掌握
BeanDefinition、BeanFactory、BeanPostProcessor等核心概念; -
学会用反射完成 Java 对象的创建、字段赋值和方法调用;
-
理解循环依赖的产生原因,以及 Spring 三级缓存的完整设计逻辑;
-
了解注解扫描、包路径扫描和容器启动流程的简化实现;
-
为后续阅读 Spring 源码打下扎实基础。
需要提前说明的是,本文实现的容器属于教学型项目,侧重于把核心链路讲清楚。它与真实的 Spring 源码相比,在性能、健壮性、扩展性、并发处理以及生态集成方面都存在明显差距。理解本文之后再去读 Spring 源码,很多原先感到费解的设计会变得非常自然。
二、先彻底搞懂两个概念:IOC 和 DI
2.1 什么是控制反转
控制反转(Inversion of Control,IOC)是一种设计思想。它的核心是:把"对象的创建"和"对象之间依赖关系的维护"从业务代码中剥离出来,交给外部容器统一管理。
在传统写法中,如果一个 UserService 需要调用 UserDao,通常会直接在类里写 private UserDao userDao = new UserDaoImpl();。此时 UserService 自己掌控了依赖的创建时机、创建方式以及生命周期。随着系统变大,业务类之间大量使用 new 关联,代码会变得非常僵化,难以替换实现,也难以做单元测试。
在 IOC 模式下,UserService 不再主动创建 UserDao,而是声明"我需要一个 UserDao"。依赖对象何时创建、如何创建、何时销毁,全部由容器负责。控制权从调用方转移到了容器手中,这就是"控制反转"这个名称的由来。
可以这样理解:传统方式是"你渴了,自己打井、挑水、烧水";IOC 方式是"你只需要说我要喝水,自来水系统会把水送到你面前"。你只关心水能不能用,不再关心水从哪里来、经过了哪些处理环节。
2.2 什么是依赖注入
依赖注入(Dependency Injection,DI)是落实 IOC 思想的一种具体手段。它表示:当容器创建对象时,会主动把这个对象所依赖的其他对象"注入"进去。常见的注入方式有三种:构造器注入、Setter 注入、字段注入。Spring 中日常使用最多的字段注入,就是依赖注入最典型的形式。
IOC 与 DI 描述的是同一件事情的两个侧面:IOC 强调"控制权从业务代码转移到容器"这一思想;DI 强调"依赖对象如何被注入"这一动作。没有 DI,IOC 就只是空谈;而 DI 要真正落地,就必须有一个功能完整的容器作为支撑。
2.3 为什么要使用 IOC
IOC 带来的好处主要体现在四个方面:
-
解耦:类与类之间不再通过硬编码的
new绑定,而是面向接口编程,依赖关系由容器注入; -
易于测试:单测时可以方便地把真实依赖替换成 Mock 对象;
-
统一管理生命周期:单例、原型等作用域由容器统一控制,避免到处创建对象造成混乱;
-
便于扩展:通过后置处理器可以在对象创建前后插入多种能力,如代理、事务、日志等。
搞清楚这些概念后,下一步我们要先看一下真实 Spring IOC 容器的核心设计。这相当于先看一遍"商品房图纸",然后再自己动手搭建一个"模型房间"。
三、真实 Spring IOC 容器的核心设计预览
Spring IOC 并不是一个神秘黑盒,它的核心思路可以用几个关键接口概括。理解了这些组件,再写简化版就会轻松很多。
3.1 BeanDefinition:Bean 的设计图纸
BeanDefinition 用来描述一个 Bean 的元信息。实际开发中,我们配置了一个类、一个 XML 节点或一条注解,这个类要被容器管理,就必须先被解析成一条 BeanDefinition。它记录了 Bean 名称、Class 类型、作用域、是否懒加载、初始化方法、销毁方法、依赖关系等。
容器创建 Bean 时,实际上就是拿着这张"图纸"来施工。图纸越详细,容器能够完成的装配就越精细。
3.2 BeanFactory:容器的心脏
BeanFactory 是 Spring 最底层的容器接口。它最核心的方法就一个:getBean(String name)。无论上层传入什么参数,最终对象创建和获取都要经过这个入口。它负责根据 BeanDefinition 创建并返回 Bean 实例。
3.3 ApplicationContext:面向应用的完整容器
ApplicationContext 是 BeanFactory 的子接口,提供了更多面向应用的能力,例如资源加载、国际化、事件发布、自动注册后置处理器等。日常开发中我们使用的 ClassPathXmlApplicationContext、AnnotationConfigApplicationContext 都属于它的实现。
3.4 BeanPostProcessor:生命周期扩展点
BeanPostProcessor 允许开发者在 Bean 初始化前后插入自定义逻辑。它是 Spring 扩展机制的重要入口。@Autowired 字段注入、@Value 属性赋值、AOP 代理对象生成等能力,底层都依赖各类后置处理器。
3.5 三级缓存:循环依赖的经典解法
Spring 解决循环依赖的核心是三级缓存:一级缓存保存已经完整创建的单例对象;二级缓存保存提前暴露的半成品对象;三级缓存保存一个"对象工厂",可以在需要时生成代理对象或提前引用。这套设计很精妙,稍后我们会从头实现一次。
下面我们就按照这些核心组件,从零搭建一个属于自己的简化版 IOC 容器。
四、项目整体设计:这个简化版容器要完成什么
为了让这次手写实践既有教学价值,又有可运行性,我们设定以下功能目标:
-
定义
BeanDefinition,描述 Bean 类型、作用域、初始化方法等元数据; -
实现注册中心,用于保存、查找、判断所有
BeanDefinition; -
实现简化版
BeanFactory,支持按名字和按类型获取 Bean; -
支持利用反射创建对象;
-
支持字段注入与构造器注入;
-
支持
@Component、@Autowired、@Value、@Scope等注解; -
支持包扫描,自动发现并注册候选 Bean;
-
支持 Bean 生命周期回调,包括初始化方法和后置处理;
-
使用三级缓存解决循环依赖;
-
实现一个基于 JDK 动态代理的极简 AOP,演示后置处理器如何改造 Bean。
项目的包结构可以这样设计:
text
com.example.ioc
├── annotation // 自定义注解
│ ├── Component.java
│ ├── Autowired.java
│ ├── Value.java
│ └── Scope.java
├── bean
│ ├── BeanDefinition.java
│ └── PropertyValue.java
├── factory
│ ├── BeanFactory.java
│ ├── ObjectFactory.java
│ └── DefaultListableBeanFactory.java
├── processor
│ ├── BeanPostProcessor.java
│ └── AutowiredAnnotationBeanPostProcessor.java
├── scanner
│ └── ClassPathBeanDefinitionScanner.java
├── context
│ └── AnnotationApplicationContext.java
└── aop
├── MethodInterceptor.java
├── ProxyFactory.java
└── JdkDynamicAopProxy.java
这个结构对应了 Spring 的几个关键模块。下面我们按照"从简单到复杂"的顺序实现。强烈建议读者跟着从头敲一遍,只有自己写过的代码,才会真正变成自己的理解。
五、第一步:定义 BeanDefinition,给 Bean 画一张图纸
容器要创建对象,首先要回答三个问题:创建什么类型的对象?以什么作用域创建?创建完成后还要执行哪些初始化逻辑?这些信息就由 BeanDefinition 承载。
java
package com.example.ioc.bean;
/**
* Bean 定义:描述一个 Bean 的元信息
*/
public class BeanDefinition {
/** Bean 在容器中的唯一名称 */
private String beanName;
/** Bean 对应的 Class 对象 */
private Class<?> beanClass;
/** 作用域:singleton 或 prototype,默认 singleton */
private String scope = SCOPE_SINGLETON;
/** 初始化方法名 */
private String initMethodName;
/** 销毁方法名 */
private String destroyMethodName;
/** 是否懒加载 */
private boolean lazyInit = false;
public static final String SCOPE_SINGLETON = "singleton";
public static final String SCOPE_PROTOTYPE = "prototype";
public BeanDefinition() {
}
public BeanDefinition(Class<?> beanClass) {
this.beanClass = beanClass;
this.beanName = lowerFirst(beanClass.getSimpleName());
}
public BeanDefinition(String beanName, Class<?> beanClass) {
this.beanName = beanName;
this.beanClass = beanClass;
}
private String lowerFirst(String name) {
if (name == null || name.isEmpty()) {
return name;
}
char[] chars = name.toCharArray();
chars[0] = Character.toLowerCase(chars[0]);
return new String(chars);
}
public boolean isSingleton() {
return SCOPE_SINGLETON.equals(scope);
}
public boolean isPrototype() {
return SCOPE_PROTOTYPE.equals(scope);
}
// 省略 getter / setter
}
这里只保留最核心的字段。真实 Spring 的 BeanDefinition 还要复杂得多,包含父定义、工厂方法、构造器参数、属性值列表、依赖名称等。但对教学版本来说,上面的描述已经足够支撑我们实现依赖注入、生命周期和循环依赖处理。
同时我们定义一个 PropertyValue,用来描述"属性名 + 属性值"。它会在手动注册 Bean 或后续扩展属性注入时用到。
java
package com.example.ioc.bean;
/**
* 属性值:记录一个字段的名字和值,用于属性注入
*/
public class PropertyValue {
private final String name;
private final Object value;
public PropertyValue(String name, Object value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public Object getValue() {
return value;
}
}
图纸有了,下一步就需要一个仓库,把所有图纸集中管理起来。
六、第二步:实现注册中心,集中管理 BeanDefinition
注册中心的职责很简单:保存所有 BeanDefinition,支持按名字查找、按类型查找、判断是否包含某个 Bean 定义。我们使用 ConcurrentHashMap 保证并发访问安全。
同时我们会在这里提前声明三级缓存,以及当前正在创建中的 Bean 集合。虽然现在还没有使用它们,但这些字段是后面实现对象创建和循环依赖的基础。
java
package com.example.ioc.factory;
import com.example.ioc.bean.BeanDefinition;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
/**
* 默认的 BeanFactory 实现
* 同时承担 BeanDefinition 注册中心职责
*/
public class DefaultListableBeanFactory implements BeanFactory {
/** 保存所有 BeanDefinition,key 为 Bean 名称 */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
/** 一级缓存:保存完整可用的单例 Bean */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
/** 二级缓存:保存提前暴露、可能尚未填充属性的半成品 Bean */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();
/** 三级缓存:保存用于生成代理对象或提前引用的 ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new ConcurrentHashMap<>();
/** 记录当前正在创建中的 Bean,用于循环依赖检测 */
private final Set<String> singletonsCurrentlyInCreation = ConcurrentHashMap.newKeySet();
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
beanDefinition.setBeanName(beanName);
beanDefinitionMap.put(beanName, beanDefinition);
}
public BeanDefinition getBeanDefinition(String beanName) {
BeanDefinition bd = beanDefinitionMap.get(beanName);
if (bd == null) {
throw new IllegalArgumentException("找不到名为 [" + beanName + "] 的 BeanDefinition");
}
return bd;
}
public boolean containsBeanDefinition(String beanName) {
return beanDefinitionMap.containsKey(beanName);
}
public String[] getBeanDefinitionNames() {
return beanDefinitionMap.keySet().toArray(new String[0]);
}
}
注册中心的本质就是一个"图纸仓库"。无论我们通过哪种方式配置 Bean,最终都要把 BeanDefinition 塞进这个 beanDefinitionMap。后面容器所有创建动作,都会先到这里取图纸。
七、第三步:定义 BeanFactory 接口,打通对象创建入口
我们把 BeanFactory 接口保持得足够简单,只暴露最常用的三个方法。后续所有增强,都可以在实现类内部完成。
java
package com.example.ioc.factory;
/**
* 容器核心接口:负责根据名称或类型获取 Bean
*/
public interface BeanFactory {
Object getBean(String name);
<T> T getBean(Class<T> requiredType);
boolean containsBean(String name);
}
配套定义一个 ObjectFactory 函数式接口,用于在三级缓存中延迟创建对象:
java
package com.example.ioc.factory;
@FunctionalInterface
public interface ObjectFactory<T> {
T getObject();
}
ObjectFactory 是三级缓存的灵魂。我们把"生成早期引用的动作"包装成工厂放进三级缓存,只有真正需要提前暴露时才会调用它,这就实现了延迟决策——Spring 也正是靠这一点保证普通 Bean 不会提前被代理。
八、第四步:反射创建对象,从图纸到实例
BeanDefinition 描述了"创建什么",接下来要回答"怎么创建"。这一步的核心是反射。
java
package com.example.ioc.factory;
import com.example.ioc.bean.BeanDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class BeanInstanceCreator {
/**
* 使用无参构造器创建一个实例
*/
public static Object instantiate(BeanDefinition bd) {
Class<?> beanClass = bd.getBeanClass();
try {
Constructor<?> constructor = beanClass.getDeclaredConstructor();
constructor.setAccessible(true);
return constructor.newInstance();
} catch (NoSuchMethodException e) {
throw new IllegalStateException("Bean " + bd.getBeanName() + " 缺少无参构造器", e);
} catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
throw new IllegalStateException("Bean " + bd.getBeanName() + " 实例化失败", e);
}
}
}
真实 Spring 在这一步会处理工厂方法、Supplier、构造器参数解析等复杂逻辑。教学版先做最简单的无参构造器实例化,把核心链路走通。后面注入字段时,我们再用反射给属性赋值。
九、第五步:定义注解,让容器认识它们
要实现注解驱动的容器,先得定义这些注解。它们是容器扫描和注入的"信号灯"。
java
package com.example.ioc.annotation;
import java.lang.annotation.*;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
String value() default "";
}
java
package com.example.ioc.annotation;
import java.lang.annotation.*;
@Target({ElementType.FIELD, ElementType.CONSTRUCTOR})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
boolean required() default true;
}
java
package com.example.ioc.annotation;
import java.lang.annotation.*;
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {
String value();
}
java
package com.example.ioc.annotation;
import java.lang.annotation.*;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {
String value() default "singleton";
}
这几个注解的设计和 Spring 中同名注解在语义上保持一致:@Component 声明 Bean、@Autowired 声明注入点、@Value 用于字符串属性、@Scope 声明作用域。简化版只需实现它们最核心的语义。
十、第六步:包扫描,把注解变成 BeanDefinition
有了注解,下一步就是让容器自动扫描指定包下的类,找出带 @Component 的类并注册为 BeanDefinition。这里要用到类加载器和资源遍历。
java
package com.example.ioc.scanner;
import com.example.ioc.annotation.Component;
import com.example.ioc.annotation.Scope;
import com.example.ioc.bean.BeanDefinition;
import java.io.File;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
public class ClassPathBeanDefinitionScanner {
public List<BeanDefinition> scan(String basePackage) {
List<BeanDefinition> result = new ArrayList<>();
String path = basePackage.replace('.', '/');
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
URL resource = classLoader.getResource(path);
if (resource == null) {
return result;
}
File dir = new File(resource.getFile());
scanDir(basePackage, dir, result);
return result;
}
private void scanDir(String basePackage, File dir, List<BeanDefinition> result) {
File[] files = dir.listFiles();
if (files == null) {
return;
}
for (File file : files) {
if (file.isDirectory()) {
scanDir(basePackage + "." + file.getName(), file, result);
continue;
}
String fileName = file.getName();
if (!fileName.endsWith(".class")) {
continue;
}
String className = basePackage + "." + fileName.substring(0, fileName.length() - 6);
registerIfCandidate(className, result);
}
}
private void registerIfCandidate(String className, List<BeanDefinition> result) {
try {
Class<?> clazz = Class.forName(className);
if (!clazz.isAnnotationPresent(Component.class)) {
return;
}
Component component = clazz.getAnnotation(Component.class);
String beanName = component.value().isEmpty()
? lowerFirst(clazz.getSimpleName())
: component.value();
BeanDefinition bd = new BeanDefinition(beanName, clazz);
Scope scope = clazz.getAnnotation(Scope.class);
if (scope != null) {
bd.setScope(scope.value());
}
result.add(bd);
} catch (ClassNotFoundException ignored) {
}
}
private String lowerFirst(String name) {
if (name == null || name.isEmpty()) {
return name;
}
char[] chars = name.toCharArray();
chars[0] = Character.toLowerCase(chars[0]);
return new String(chars);
}
}
扫描的关键步骤分三步:把包名转成路径、用类加载器找到目录资源、递归遍历目录并加载 .class。每个类加载后检查是否带 @Component,带则生成一个 BeanDefinition 并读取 @Scope 信息。真实 Spring 的扫描器还要处理 Jar 包、嵌套类、条件注解、元注解等,教学版只需要处理最常见的目录扫描即可。
十一、第七步:BeanPostProcessor,生命周期扩展点
BeanPostProcessor 是理解 Spring 扩展机制最关键的一环。简化版只保留初始化前后两个回调,足以支撑依赖注入和 AOP 两件事。
java
package com.example.ioc.processor;
public interface BeanPostProcessor {
/**
* 初始化前回调
*/
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
/**
* 初始化后回调
*/
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
把这个接口设计成默认方法,是因为大多数后置处理器只会覆写其中一两个方法。接下来我们要实现的最关键的一个处理器,就是 @Autowired 和 @Value 的注入处理器。
十二、第八步:实现 AutowiredAnnotationBeanPostProcessor
这个处理器的核心逻辑是:拿到 Bean 后,遍历它的所有字段,凡是标注了 @Autowired 的,就从容器中取出对应 Bean 并注入;凡是标注了 @Value 的,就把字符串值注入。
java
package com.example.ioc.processor;
import com.example.ioc.annotation.Autowired;
import com.example.ioc.annotation.Value;
import com.example.ioc.factory.BeanFactory;
import java.lang.reflect.Field;
public class AutowiredAnnotationBeanPostProcessor implements BeanPostProcessor {
private final BeanFactory beanFactory;
public AutowiredAnnotationBeanPostProcessor(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
Class<?> clazz = bean.getClass();
while (clazz != null && clazz != Object.class) {
for (Field field : clazz.getDeclaredFields()) {
injectAutowired(bean, field);
injectValue(bean, field);
}
clazz = clazz.getSuperclass();
}
return bean;
}
private void injectAutowired(Object bean, Field field) {
if (!field.isAnnotationPresent(Autowired.class)) {
return;
}
field.setAccessible(true);
try {
Object dependency = beanFactory.getBean(field.getType());
field.set(bean, dependency);
} catch (IllegalAccessException e) {
throw new IllegalStateException("注入字段失败: " + field.getName(), e);
}
}
private void injectValue(Object bean, Field field) {
if (!field.isAnnotationPresent(Value.class)) {
return;
}
Value value = field.getAnnotation(Value.class);
field.setAccessible(true);
try {
field.set(bean, value.value());
} catch (IllegalAccessException e) {
throw new IllegalStateException("注入 @Value 失败: " + field.getName(), e);
}
}
}
这里的 injectAutowired 递归到父类,是为了支持继承场景下父类字段也能被注入。beanFactory.getBean(field.getType()) 会触发依赖 Bean 的创建——如果此时发生循环依赖,就会进入三级缓存的逻辑。
十三、第九步:核心容器实现,串联整个创建流程
现在我们把前面所有组件组合起来,实现 DefaultListableBeanFactory 的 getBean、doCreateBean、populateBean、initializeBean 等方法。
13.1 getBean 主入口
java
@Override
public Object getBean(String name) {
BeanDefinition bd = getBeanDefinition(name);
if (bd.isSingleton()) {
Object singleton = getSingleton(name);
if (singleton != null) {
return singleton;
}
return createBean(name, bd);
}
return createBean(name, bd);
}
@Override
public <T> T getBean(Class<T> requiredType) {
for (String beanName : getBeanDefinitionNames()) {
BeanDefinition bd = getBeanDefinition(beanName);
if (requiredType.isAssignableFrom(bd.getBeanClass())) {
return (T) getBean(beanName);
}
}
throw new IllegalArgumentException("找不到类型为 " + requiredType + " 的 Bean");
}
13.2 单例获取:三级缓存的读取顺序
java
private Object getSingleton(String beanName) {
Object singleton = singletonObjects.get(beanName);
if (singleton != null) {
return singleton;
}
singleton = earlySingletonObjects.get(beanName);
if (singleton != null) {
return singleton;
}
ObjectFactory<?> factory = singletonFactories.get(beanName);
if (factory != null) {
Object earlyBean = factory.getObject();
earlySingletonObjects.put(beanName, earlyBean);
singletonFactories.remove(beanName);
return earlyBean;
}
return null;
}
这个读取顺序就是三级缓存的访问顺序:先查一级,再查二级,最后查三级。三级缓存中存的是 ObjectFactory,调用它拿到早期引用后立刻升级到二级缓存,并清除三级。这样做的目的是避免同一个 Bean 的早期引用被重复创建。
13.3 createBean:完整创建流程
java
private Object createBean(String beanName, BeanDefinition bd) {
Object bean = null;
try {
// 标记为"正在创建",用于循环依赖检测
beforeSingletonCreation(beanName);
// 1. 实例化
bean = BeanInstanceCreator.instantiate(bd);
// 2. 提前暴露工厂到三级缓存(用于解决循环依赖)
Object finalBean = bean;
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, finalBean));
// 3. 属性填充
populateBean(beanName, bd, bean);
// 4. 初始化
bean = initializeBean(beanName, bean);
// 5. 放入一级缓存
if (bd.isSingleton()) {
singletonObjects.put(beanName, bean);
earlySingletonObjects.remove(beanName);
singletonFactories.remove(beanName);
}
} finally {
afterSingletonCreation(beanName);
}
return bean;
}
private void beforeSingletonCreation(String beanName) {
singletonsCurrentlyInCreation.add(beanName);
}
private void afterSingletonCreation(String beanName) {
singletonsCurrentlyInCreation.remove(beanName);
}
private void addSingletonFactory(String beanName, ObjectFactory<?> factory) {
singletonFactories.put(beanName, factory);
}
private Object getEarlyBeanReference(String beanName, Object bean) {
// 这里可以扩展为返回代理对象
return bean;
}
这段代码是循环依赖解决的核心。注意第 2 步:实例化完成后马上把 ObjectFactory 放入三级缓存,这就是"提前暴露"的时机。
13.4 populateBean:属性填充
java
private void populateBean(String beanName, BeanDefinition bd, Object bean) {
for (BeanPostProcessor processor : beanPostProcessors) {
if (processor instanceof AutowiredAnnotationBeanPostProcessor) {
((AutowiredAnnotationBeanPostProcessor) processor)
.postProcessBeforeInitialization(bean, beanName);
}
}
}
这里为了简化,我们把字段注入直接委托给 AutowiredAnnotationBeanPostProcessor。真实 Spring 中 populateBean 会分多个阶段,处理 InstantiationAwareBeanPostProcessor、属性值解析、依赖注入等。
13.5 initializeBean:初始化阶段
java
private Object initializeBean(String beanName, Object bean) {
Object result = bean;
// 前置处理
for (BeanPostProcessor processor : beanPostProcessors) {
result = processor.postProcessBeforeInitialization(result, beanName);
}
// 自定义初始化方法(如果有)
invokeInitMethod(beanName, result);
// 后置处理,AOP 代理主要在这里生成
for (BeanPostProcessor processor : beanPostProcessors) {
result = processor.postProcessAfterInitialization(result, beanName);
}
return result;
}
private void invokeInitMethod(String beanName, Object bean) {
BeanDefinition bd = getBeanDefinition(beanName);
String methodName = bd.getInitMethodName();
if (methodName == null || methodName.isBlank()) {
return;
}
try {
Method method = bean.getClass().getDeclaredMethod(methodName);
method.setAccessible(true);
method.invoke(bean);
} catch (Exception e) {
throw new IllegalStateException("调用初始化方法失败: " + methodName, e);
}
}
至此,容器已经具备了完整的创建、注入、初始化能力。接下来我们要实现 AOP 代理和上下文启动流程。
十四、第十步:极简 AOP 代理
AOP 代理通过后置处理器在初始化后生成。我们先定义一个最简单的 MethodInterceptor,然后通过 ProxyFactory 用 JDK 动态代理创建代理对象。
java
package com.example.ioc.aop;
public interface MethodInterceptor {
Object invoke(Object proxy, Method method, Object[] args, Object target) throws Throwable;
}
java
package com.example.ioc.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyFactory {
public static Object createProxy(Object target, Class<?>[] interfaces, MethodInterceptor interceptor) {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
interfaces,
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return interceptor.invoke(proxy, method, args, target);
}
});
}
}
配套一个 AopBeanPostProcessor,它会在初始化后判断 Bean 是否需要代理:
java
package com.example.ioc.processor;
import com.example.ioc.aop.MethodInterceptor;
import com.example.ioc.aop.ProxyFactory;
public class AopBeanPostProcessor implements BeanPostProcessor {
private final MethodInterceptor interceptor;
public AopBeanPostProcessor(MethodInterceptor interceptor) {
this.interceptor = interceptor;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
Class<?>[] interfaces = bean.getClass().getInterfaces();
if (interfaces.length == 0) {
return bean;
}
return ProxyFactory.createProxy(bean, interfaces, interceptor);
}
}
这个后置处理器演示了 Spring AOP 的核心思想:后置处理器在 Bean 初始化完成后返回代理对象,后续容器和调用方看到的都是代理。
十五、第十一步:应用上下文,串起整个启动流程
最后我们实现一个 AnnotationApplicationContext,作为容器面向用户的入口。它的职责是:扫描指定包、注册 BeanDefinition、注册内置后置处理器、提前初始化单例 Bean。
java
package com.example.ioc.context;
import com.example.ioc.bean.BeanDefinition;
import com.example.ioc.factory.DefaultListableBeanFactory;
import com.example.ioc.processor.AutowiredAnnotationBeanPostProcessor;
import com.example.ioc.processor.BeanPostProcessor;
import com.example.ioc.scanner.ClassPathBeanDefinitionScanner;
import java.util.List;
public class AnnotationApplicationContext {
private final DefaultListableBeanFactory beanFactory;
public AnnotationApplicationContext(String basePackage) {
beanFactory = new DefaultListableBeanFactory();
// 1. 扫描并注册 BeanDefinition
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner();
List<BeanDefinition> definitions = scanner.scan(basePackage);
for (BeanDefinition bd : definitions) {
beanFactory.registerBeanDefinition(bd.getBeanName(), bd);
}
// 2. 注册内置后置处理器
beanFactory.addBeanPostProcessor(new AutowiredAnnotationBeanPostProcessor(beanFactory));
// 3. 提前初始化所有非懒加载单例
for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
if (bd.isSingleton() && !bd.isLazyInit()) {
beanFactory.getBean(beanName);
}
}
}
public Object getBean(String name) {
return beanFactory.getBean(name);
}
public <T> T getBean(Class<T> requiredType) {
return beanFactory.getBean(requiredType);
}
}
对应的 DefaultListableBeanFactory 需要补上一个 addBeanPostProcessor 方法,把后置处理器保存起来,供创建 Bean 时按顺序调用。
十六、第十二步:三级缓存如何解决循环依赖
现在用具体例子验证循环依赖是否真的能解开。
定义两个相互依赖的 Bean:
java
@Component
public class A {
@Autowired
private B b;
}
@Component
public class B {
@Autowired
private A a;
}
启动容器后,创建流程如下:
-
调用
getBean("a"),一级缓存没有,进入createBean; -
A实例化完成,把ObjectFactory放入三级缓存; -
populateBean(a)时发现a.b需要注入B,触发getBean("b"); -
一级缓存没有
B,进入createBean("b"); -
B实例化完成,把ObjectFactory放入三级缓存; -
populateBean(b)时发现b.a需要注入A,触发getBean("a"); -
一级、二级缓存都没有
A,从三级缓存取出A的ObjectFactory,调用后得到A的早期引用,并升级到二级缓存; -
B拿到A的早期引用,完成自身创建,放入一级缓存; -
回到
A的populateBean,b字段注入完成,A继续初始化; -
A初始化完成后,从二级缓存移除,放入一级缓存。
整个流程之所以能解开循环,核心在于两点:实例化和属性填充分离、提前暴露早期引用。只要 A 被实例化出来,即使属性还没填充,它的引用就已经可以交给 B 使用。
十七、为什么要三级缓存,而不是二级
这是面试中最常被追问的问题。从上面的例子看,二级缓存(earlySingletonObjects)已经能解决普通循环依赖,为什么还要三级缓存?
关键差别在于 AOP 代理。假设 A 需要被代理,那么暴露给 B 的应该是 A 的代理对象,而不是原始对象。但 A 此刻还没走到 initializeBean,代理还没生成。三级缓存中的 ObjectFactory 恰好提供了延迟决策能力:
-
如果不需要代理,
ObjectFactory.getObject()直接返回原始对象; -
如果需要代理,可以在
getObject()里提前生成代理对象返回。
如果把三级缓存去掉,只用二级缓存,就不得不面临二选一:要么提前创建代理导致重复代理,要么暴露原始对象导致 AOP 语义被破坏。三级缓存的设计本质上是把"是否提前代理"这个决策推迟到真正需要暴露的那一刻,这是非常优雅的取舍。
十八、常见坑与排查
18.1 循环依赖仍然抛异常
如果 A 和 B 都使用构造器注入,那么上述三级缓存方案也会失败。因为构造器注入要求 B 在 A 实例化之前就必须存在,而 A 甚至还没有被 new 出来,自然无法提前暴露引用。这就是 Spring 官方建议"用 setter 或字段注入代替构造器注入"的原因之一。
18.2 @Autowired 注入失败
常见原因有三个:目标类型没有注册为 Bean、被注入类不是单例、字段是 final 或 static。教学版容器只支持可写字段,final 字段无法通过反射赋值。
18.3 包扫描找不到类
多半是包名拼错,或者类没有 @Component 注解,或者在 IDE 中未编译产生 .class 文件。用 classLoader.getResource(path) 调试可以快速定位。
18.4 多个候选 Bean 时按类型注入失败
教学版按类型查找时返回第一个匹配项。真实 Spring 会用 @Primary、@Qualifier、名称匹配等多种手段消歧。这也是从教学版走向生产版本时需要补齐的能力。
十九、总结
手写一次 IOC 容器最大的价值,不是造出一个能用的框架,而是把 Spring 的核心链路走一遍,从此看源码时不再依赖"背结论"。
本文实现的容器覆盖了以下关键能力:
-
BeanDefinition 与 BeanFactory:图纸与仓库,把配置和对象创建解耦;
-
反射实例化与字段注入:用 JDK 反射完成对象创建和依赖装配;
-
注解与包扫描:把
@Component自动变成 BeanDefinition; -
BeanPostProcessor:为容器注入扩展能力,字段注入与 AOP 都靠它实现;
-
三级缓存解决循环依赖:实例化后立即暴露工厂,用延迟决策保证 AOP 语义;
-
极简 AOP 代理:演示后置处理器如何把原始对象替换为代理对象。
学完这一遍后再回头看 Spring 的源码,你会发现那些原先费解的设计都有非常自然的解释:为什么有 BeanDefinition 和 getMergedBeanDefinition 的区分?为什么 getSingleton 要先查一级再查二级最后才查三级?为什么构造器注入无法解决循环依赖?这些问题的答案,其实在你亲手写下这段代码之后,就已经刻在脑子里了。
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/qq_41581588/article/details/166992117



