油墨香^_^头像

徒手撸一个简单的 Spring IOC:2 万字从零实现依赖注入容器

一、为什么每一个 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;
}

启动容器后,创建流程如下:

  1. 调用 getBean("a"),一级缓存没有,进入 createBean;

  2. A 实例化完成,把 ObjectFactory 放入三级缓存;

  3. populateBean(a) 时发现 a.b 需要注入 B,触发 getBean("b");

  4. 一级缓存没有 B,进入 createBean("b");

  5. B 实例化完成,把 ObjectFactory 放入三级缓存;

  6. populateBean(b) 时发现 b.a 需要注入 A,触发 getBean("a");

  7. 一级、二级缓存都没有 A,从三级缓存取出 A 的 ObjectFactory,调用后得到 A 的早期引用,并升级到二级缓存;

  8. B 拿到 A 的早期引用,完成自身创建,放入一级缓存;

  9. 回到 A 的 populateBean,b 字段注入完成,A 继续初始化;

  10. 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

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--