依赖注入和控制反转

引入的前提：

假设我们有一个应用，需要读取用户数据、处理这些数据并最后保存处理结果

没有控制反转的实现

class UserProcessor {
    private UserDAO userDAO = new UserDAO();
    private UserValidator userValidator = new UserValidator();

    public void processUsers() {
        List<User> users = userDAO.fetchUsers();
        for (User user : users) {
            if (userValidator.isValid(user)) {
                // 处理用户数据
                System.out.println("Processing user: " + user.getName());
                // 保存数据
                userDAO.saveUser(user);
            }
        }
    }
}

在这个例子中，UserProcessor 类直接管理所有的依赖和控制流程。它需要自己创建依赖对象、管理数据的读取、验证和保存。

有控制反转的实现：

class UserProcessor {
    private UserDAO userDAO;
    private UserValidator userValidator;

    public UserProcessor(UserDAO dao, UserValidator validator) {
        this.userDAO = dao;
        this.userValidator = validator;
    }

    public void processUsers() {
        List<User> users = userDAO.fetchUsers();
        for (User user : users) {
            if (userValidator.isValid(user)) {
                // 处理用户数据
                System.out.println("Processing user: " + user.getName());
                // 保存数据
                userDAO.saveUser(user);
            }
        }
    }
}

// 在应用启动时由框架完成依赖的注入
UserDAO dao = new UserDAO();
UserValidator validator = new UserValidator();
UserProcessor processor = new UserProcessor(dao, validator);
processor.processUsers();

在这个有控制反转的实现中，UserProcessor 不再直接创建和管理依赖对象。相反，这些依赖通过构造函数注入进来，由外部（如框架或容器）负责管理。这样，UserProcessor 可以更专注于业务逻辑的实现，同时也更容易进行单元测试。