← 课程目录 🚀 从零到一
📐 学习维度 阶段4 · 第13章 Spring 原理 🚀 从零到一 📚 课程目录 🏠 首页 🛤️ 学习路径

13.5 手写 mini-Spring:五十行理解框架

审校 2026-09-25 · 素材来源:zhouyu-mini-spring 系列、guanzi-mini-spring
📑 本篇章节导航 (共12节,点击直达)
目标与素材第一步:两个注解第二步:扫描,把类找出来第三步:依赖注入,带循环依赖处理进阶一步:生命周期回调第四步:mini AOP,代理包一层跑起来和真 Spring 对比着读练习清单踩坑清单面试怎么问一句话总结

读 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 字段在回调方法里一定是就绪的。「注入先于初始化」的时序,自己写的代码最讲道理。

第四步:mini AOP,代理包一层


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」这个约定上会师。

和真 Spring 对比着读

简化点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 源码的每层设计都能对上你要解决的问题。