依赖注入与控制反转（IoC）容器的原理

依赖注入（DI）和控制反转（IoC）是后端框架中实现松耦合设计的核心机制。虽然我们之前讨论过基本概念，但这次我们将深入探讨IoC容器的具体实现原理和工作流程。

1. 问题背景：紧耦合的依赖关系
假设我们有一个UserService类，它依赖于UserRepository类：

// 紧耦合的实现
class UserRepository {
    public void save(User user) {
        // 数据库操作
    }
}

class UserService {
    private UserRepository userRepo = new UserRepository(); // 直接实例化依赖
    
    public void createUser(User user) {
        userRepo.save(user);
    }
}

这种实现的问题：UserService直接创建UserRepository实例，两者紧密耦合，难以测试和扩展。

2. 依赖注入的基本形式
通过构造函数注入依赖：

class UserService {
    private UserRepository userRepo;
    
    // 依赖通过构造函数注入
    public UserService(UserRepository repo) {
        this.userRepo = repo;
    }
    
    public void createUser(User user) {
        userRepo.save(user);
    }
}

现在依赖关系由外部控制，但需要手动管理对象创建：

UserRepository repo = new UserRepository();
UserService service = new UserService(repo); // 手动装配依赖

3. IoC容器的核心职责
IoC容器自动化管理依赖关系，主要功能包括：

• 注册：记录组件类型及其依赖关系
• 解析：自动构建对象及其依赖树
• 生命周期管理：控制对象的创建和销毁

4. 简单IoC容器的实现步骤

步骤1：定义容器接口

interface Container {
    void register(Class<?> type); // 注册组件
    <T> T resolve(Class<T> type); // 解析实例
}

步骤2：实现依赖解析逻辑

class SimpleContainer implements Container {
    private Map<Class<?>, Class<?>> registry = new HashMap<>();
    
    @Override
    public void register(Class<?> type) {
        registry.put(type, type);
    }
    
    @Override
    public <T> T resolve(Class<T> type) {
        return createInstance(type);
    }
    
    private <T> T createInstance(Class<T> type) {
        // 获取类的所有构造函数
        Constructor<?>[] constructors = type.getConstructors();
        
        if (constructors.length != 1) {
            throw new RuntimeException("必须有且只有一个公共构造函数");
        }
        
        Constructor<?> constructor = constructors[0];
        // 获取构造函数的参数类型
        Class<?>[] paramTypes = constructor.getParameterTypes();
        // 递归解析所有依赖
        Object[] dependencies = Arrays.stream(paramTypes)
                                    .map(this::createInstance)
                                    .toArray();
        
        try {
            return (T) constructor.newInstance(dependencies);
        } catch (Exception e) {
            throw new RuntimeException("创建实例失败", e);
        }
    }
}

步骤3：使用容器管理依赖

// 注册组件
Container container = new SimpleContainer();
container.register(UserRepository.class);
container.register(UserService.class);

// 自动解析依赖树
UserService service = container.resolve(UserService.class);
service.createUser(new User());

5. 高级特性实现原理

单例管理：

class SingletonContainer extends SimpleContainer {
    private Map<Class<?>, Object> singletons = new HashMap<>();
    
    @Override
    public <T> T resolve(Class<T> type) {
        if (!singletons.containsKey(type)) {
            singletons.put(type, super.resolve(type));
        }
        return (T) singletons.get(type);
    }
}

接口绑定：

interface IRepository {}
class SqlRepository implements IRepository {}

container.registerInterface(IRepository.class, SqlRepository.class);

6. 现代IoC容器的增强功能

• 注解驱动：使用@Inject、@Singleton等注解
• 条件装配：根据配置条件决定是否创建bean
• AOP集成：与面向切面编程无缝集成
• 生命周期回调：支持@PostConstruct等回调方法

7. 设计要点总结

• 控制反转：将对象创建的控制权从业务代码转移到容器
• 依赖查找：容器负责查找并注入依赖关系
• 配置方式：支持XML、注解、代码配置等多种方式
• 延迟加载：某些实现支持需要时才创建实例

通过IoC容器，应用程序获得了更好的灵活性、可测试性和可维护性，这是现代后端框架架构设计的基石之一。