一、为何要手写Spring IoC框架？

Spring IoC（控制反转）作为Spring框架的核心模块，通过容器管理Bean的生命周期与依赖关系，实现了组件解耦与灵活配置。然而，直接阅读Spring源码往往因复杂度高而难以快速掌握核心逻辑。手写简化版IoC框架具有三重价值：

1. 理解设计本质：剥离Spring的复杂功能（如AOP、事务），聚焦IoC的核心机制——依赖查找与依赖注入。
2. 提升编码能力：通过实现Bean定义解析、依赖注入、循环依赖处理等关键功能，掌握框架级代码的编写技巧。
3. 优化问题解决：深入理解IoC原理后，能更高效地调试Spring应用中的配置错误或依赖冲突问题。

以一个简单场景为例：当Spring容器启动时，需加载@Component注解的类，通过反射创建实例，并根据@Autowired注解注入依赖。手写框架需实现这一完整流程。

二、手写IoC框架的核心实现步骤

1. 定义Bean元数据模型

IoC容器的核心是管理Bean的定义与实例。首先需设计一个BeanDefinition类，存储Bean的类信息、属性、依赖关系等元数据：

public class BeanDefinition {
    private Class<?> beanClass;
    private Map<String, Object> properties = new HashMap<>();
    private Set<String> dependencies = new HashSet<>();
    // 构造方法与Getter/Setter
    public BeanDefinition(Class<?> beanClass) {
        this.beanClass = beanClass;
    }
    public void addProperty(String name, Object value) {
        properties.put(name, value);
    }
    public void addDependency(String dependencyName) {
        dependencies.add(dependencyName);
    }
}

此模型用于抽象Bean的配置信息，后续解析XML或注解时将填充此对象。

2. 实现Bean定义解析器

解析器需从配置源（如XML、注解）中提取Bean定义。以注解解析为例，实现一个AnnotationBeanDefinitionParser：

public class AnnotationBeanDefinitionParser {
    public Map<String, BeanDefinition> parse(Class<?>[] annotatedClasses) {
        Map<String, BeanDefinition> definitions = new HashMap<>();
        for (Class<?> clazz : annotatedClasses) {
            if (clazz.isAnnotationPresent(Component.class)) {
                BeanDefinition definition = new BeanDefinition(clazz);
                // 解析字段上的@Autowired注解
                for (Field field : clazz.getDeclaredFields()) {
                    if (field.isAnnotationPresent(Autowired.class)) {
                        definition.addDependency(field.getName());
                    }
                }
                definitions.put(clazz.getSimpleName().toLowerCase(), definition);
            }
        }
        return definitions;
    }
}

此解析器扫描带有@Component的类，并记录需注入的字段名（实际Spring会通过类型匹配，此处简化处理）。

3. 构建IoC容器核心

容器需管理Bean定义与实例，并提供依赖注入功能。实现一个SimpleIoCContainer：

public class SimpleIoCContainer {
    private Map<String, BeanDefinition> beanDefinitions;
    private Map<String, Object> singletonBeans = new HashMap<>();
    public SimpleIoCContainer(Map<String, BeanDefinition> definitions) {
        this.beanDefinitions = definitions;
    }
    public Object getBean(String beanName) {
        if (singletonBeans.containsKey(beanName)) {
            return singletonBeans.get(beanName);
        }
        BeanDefinition definition = beanDefinitions.get(beanName);
        if (definition == null) {
            throw new IllegalArgumentException("Bean not found: " + beanName);
        }
        try {
            Object instance = definition.getBeanClass().getDeclaredConstructor().newInstance();
            // 依赖注入
            for (Field field : instance.getClass().getDeclaredFields()) {
                if (definition.getDependencies().contains(field.getName())) {
                    field.setAccessible(true);
                    Object dependency = getBean(field.getName()); // 简化处理，实际需按类型匹配
                    field.set(instance, dependency);
                }
            }
            singletonBeans.put(beanName, instance);
            return instance;
        } catch (Exception e) {
            throw new RuntimeException("Failed to create bean", e);
        }
    }
}

此容器通过反射创建实例，并递归注入依赖（实际Spring使用三级缓存解决循环依赖）。

4. 测试与验证

编写测试类验证容器功能：

@Component
public class UserService {
    @Autowired
    private UserRepository repository;
    public String findUser() {
        return repository.getUserName();
    }
}
@Component
public class UserRepository {
    public String getUserName() {
        return "Alice";
    }
}
public class IoCTest {
    public static void main(String[] args) {
        Map<String, BeanDefinition> definitions = new AnnotationBeanDefinitionParser()
            .parse(new Class[]{UserService.class, UserRepository.class});
        SimpleIoCContainer container = new SimpleIoCContainer(definitions);
        UserService service = (UserService) container.getBean("userService");
        System.out.println(service.findUser()); // 输出 "Alice"
    }
}

测试通过即证明基础IoC功能已实现。

三、对比Spring源码的优化点

1. Bean作用域：Spring支持singleton、prototype等多种作用域，手写框架仅实现了单例。
2. 依赖匹配：Spring通过BeanFactory按类型匹配依赖，而非字段名，更灵活。
3. 循环依赖：Spring使用三级缓存（singletonFactories、earlySingletonObjects、singletonObjects）解决循环依赖，手写框架未处理。
4. 配置源：Spring支持XML、Java Config、注解等多种配置方式，手写框架仅实现注解解析。

四、学习建议与进阶方向

1. 阅读Spring源码：从DefaultListableBeanFactory和AutowiredAnnotationBeanPostProcessor入手，理解完整流程。
2. 扩展功能：尝试实现@Value注入、@PostConstruct初始化等方法，贴近Spring特性。
3. 性能优化：分析手写框架的反射调用开销，对比Spring的CGLIB代理优化。
4. 实践应用：在小型项目中替换Spring IoC，验证自定义容器的稳定性。

通过手写简化版IoC框架，开发者能深入理解“控制反转”的本质——将对象创建与依赖管理的权力从业务代码转移到容器。这一过程不仅提升了框架设计能力，更为后续学习Spring Cloud、Spring Boot等生态工具奠定了坚实基础。