读 Spring 源码像走迷宫,自己写个五十行的 mini 版是更好的入口:注解扫描、Bean 容器、依赖注入、简单 AOP 各来一份。写完回头再看 13.1、13.2 的概念,全部从名词变成手感。
实现四样东西:@MyComponent 标记 Bean、@MyAutowired 注入依赖、一个扫描创建的容器、一个 JDK 代理版 AOP。约定优于配置:只扫一个包,只支持单例。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyComponent {}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyAutowired {}
注解本身只是标记,真正的戏在容器扫描时开演——和 Spring 一样,注解是钩子,容器是发动机。
public class MiniIoC {
private final Map<String, Object> beans = new ConcurrentHashMap<>();
public void scan(String basePackage) throws Exception {
// 简化:拿类路径目录,递归收 .class 文件名
List<Class<?>> classes = ClassScanner.scan(basePackage);
for (Class<?> clazz : classes) {
if (clazz.isAnnotationPresent(MyComponent.class)) {
beans.put(beanName(clazz), clazz.getDeclaredConstructor().newInstance());
}
}
}
private String beanName(Class<?> c) { // 首字母小写,对齐 Spring 默认
String s = c.getSimpleName();
return Character.toLowerCase(s.charAt(0)) + s.substring(1);
}
}
ClassScanner 扫包可以手写(File 递归 + classLoader.loadClass),也可以偷懒传一个 Class 列表。Spring 的 BeanDefinitionMap 在这里被简化成一个 Map——图纸和成品合一,因为 mini 版没有懒加载和作用域要支持。每简化掉一个特性,就看清了 Spring 为什么要留那层设计。
public void inject() throws Exception {
for (Object bean : beans.values()) {
for (Field f : bean.getClass().getDeclaredFields()) {
if (!f.isAnnotationPresent(MyAutowired.class)) continue;
Class<?> type = f.getType();
f.setAccessible(true);
f.set(bean, getBean(type)); // 递归获取依赖并塞进去
}
}
}
public Object getBean(Class<?> type) throws Exception {
Object bean = beans.values().stream()
.filter(b -> type.isInstance(b)).findFirst().orElse(null);
if (bean == null) throw new RuntimeException("找不到Bean: " + type);
return bean;
}
按类型匹配是 @Autowired 的默认玩法(13.2 的注入原理)。注意这里「先全部实例化、再统一注入」的两段式——正是这个拆分给了 Spring 用「半成品引用」解决循环依赖的空间。极端循环在 mini 版会 StackOverflow,想升阶就照 13.2 的三级缓存补一个「创建中」标记。
再花十行给容器加个 @MyPostConstruct:注入完成后,扫描带注解的方法调一遍。
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyPostConstruct {}
// inject() 末尾追加:
for (Object bean : beans.values())
for (Method m : bean.getClass().getDeclaredMethods())
if (m.isAnnotationPresent(MyPostConstruct.class)) {
m.setAccessible(true);
m.invoke(bean); // 初始化回调统一在此执行
}
这几行循环就是 13.2 十步生命周期里的「初始化」环节——Spring 把它做成 Aware、前置、后置一整条流水线,mini 版压缩成一个注解。加完这步有个立竿见影的体感:@MyAutowired 字段在回调方法里一定是就绪的。「注入先于初始化」的时序,自己写的代码最讲道理。
public <T> T getProxy(Class<T> iface, T target) {
return (T) Proxy.newProxyInstance(
iface.getClassLoader(),
new Class<?>[]{iface},
(p, method, args) -> {
System.out.println("[LOG] before " + method.getName());
Object ret = method.invoke(target, args); // 真实逻辑
System.out.println("[LOG] after " + method.getName());
return ret;
});
}
JDK 动态代理(12.3 手写 RPC 同款)前后各塞一行日志,这就是 AOP 的全部本质——横切逻辑包在方法调用外。Spring 的增强版是:自动判断哪些 Bean 需要代理(切点匹配)、在生命周期后置阶段把代理放进容器(13.2/13.3 的锚点在这汇合)。
想再像一点,加个 @MyAspect 注解当切点标记:扫描时发现类上标了它,就把容器里这个 Bean 换成代理再放回去。Spring 的切点表达式(execution 一长串)是把「哪些方法要增强」的描述力做到极致;mini 版退化为「类上有注解就代理」——表达力差了几个量级,机制却是同一个:先描述、再匹配、最后包代理。
public class Main {
public static void main(String[] args) throws Exception {
MiniIoC ctx = new MiniIoC();
ctx.scan("com.demo"); // 1. 扫描出所有 @MyComponent
ctx.inject(); // 2. 字段注入 @MyAutowired
OrderService svc = ctx.getBean(OrderService.class);
svc.createOrder(); // 3. 正常使用,全程无 new
}
}
全程没有一个 new OrderService()——控制反转这个抽象词,从这一刻变成肌肉记忆。
这个容器还能和 12.3 的 RPC 拼起来:mini 容器负责装配,RPC 代理负责远程。把 getService 造出来的代理用 @MyAutowired 注进使用方,一个「会调远程的 mini 框架」就成了。Dubbo 和 Spring 的集成本质上就是这一步的工业版:RPC 框架造代理,IoC 容器管生命周期,两边在「代理也是 Bean」这个约定上会师。
| 简化点 | mini 版 | Spring 为什么需要 |
|---|---|---|
| 图纸层 | 无,Map 直存 | BeanDefinition 支持懒加载/作用域/条件装配 |
| 循环依赖 | 不处理 | 三级缓存 + ObjectFactory 延迟代理 |
| AOP 时机 | 手动调用 | 后置处理器自动包代理,切点匹配 |
| 生命周期 | 无回调 | Aware/前置/初始化/后置十步扩展点 |
每一行简化省掉的,恰好是 Spring 源码里最值得读的段落——带着「我知道这里缺什么」去读,效率翻倍。
最后送一条源码阅读路线,写完 mini 版再走效率最高。第一站 AbstractApplicationContext 的 refresh:十几个模板方法,对着 13.1 的五步逐个认领。第二站 AbstractAutowireCapableBeanFactory 的 doCreateBean:createBeanInstance 与 populateBean 两截,正是 13.2 的「实例化与初始化」。第三站 DefaultSingletonBeanRegistry:三个 Map 字段,三级缓存的原名 singletonObjects、earlySingletonObjects、singletonFactories 亲眼认一遍。第四站 AnnotationConfigApplicationContext 的构造器:看注解如何变成图纸。四站走完,Spring 核心源码的骨架就攥在手里了。
想把手感再夯实,按难度递进做四个小练习。练习一:给 getBean 加按名字查询——两个实现类同类型注入的歧义,Spring 用 @Primary 和 @Qualifier 解,你也会撞上。练习二:加个 @MyScope("prototype"),getBean 时现场新建——作用域的本质,就是「图纸能不能复用成品」。练习三:把统一注入改成「创建时递归注入」,亲手撞一次 StackOverflow,再加「创建中」标记解掉它——三级缓存的手感就到手了。练习四:给代理包上 try-catch 模拟回滚——13.3 的三步环绕,自己写一遍。四个练习做完,本章知识点全部从「听过」变成「写过」。
五十行 mini-Spring 把「扫描成图纸、反射造实例、代理加横切」三件事走通——框架祛魅之后,Spring 源码的每层设计都能对上你要解决的问题。