《JavaEE进阶》----11.＜SpringIOC&DI【Spring容器+IOC详解+DI介绍】＞

Spring IOC 和 DI 详解

Spring 框架是当今 Java 企业级应用开发中极为流行的框架之一，其核心思想就是通过 IOC（控制反转）和 DI（依赖注入）来实现松耦合的模块化设计。本文将对这两个概念进行详细介绍，并提供相关的代码示例。

控制反转 (IOC)

控制反转（Inversion of Control，IOC）是指将对象的实例化和管理的权责从程序代码中抽离出来，由 Spring 容器进行管理。通过这种方式，我们可以降低模块之间的耦合度，提高代码的可维护性和可扩展性。

在传统的 Java 应用中，我们通常会在类内部通过 new 关键字来实例化依赖的对象，如下示例：

public class UserService {
    private UserDao userDao;

    public UserService() {
        this.userDao = new UserDao();
    }

    public void addUser(User user) {
        userDao.save(user);
    }
}

在这个例子中，UserService 直接依赖于 UserDao，这种实现方式造成了高度耦合，导致了代码的维护困难。

使用 Spring 的 IOC 容器后，我们可以将 UserDao 的实例化过程交给 Spring 来管理，如下所示：

public class UserService {
    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser(User user) {
        userDao.save(user);
    }
}

在 Spring 中，我们可以使用 XML 配置文件、Java 注解或 Java 配置类来定义和管理这些 Bean。

依赖注入 (DI)

依赖注入（Dependency Injection，DI）是控制反转的一种实现方式。在 DI 中，对象的依赖是通过构造器、Setter 方法或者接口注入的方式来提供的。

以下是使用构造器注入的示例：

@Configuration
public class AppConfig {

    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

    @Bean
    public UserService userService() {
        return new UserService(userDao());
    }
}

在这个例子中，UserService 需要一个 UserDao 作为依赖，userDao 方法定义了如何创建 UserDao 实例，而在 userService 方法中通过构造器注入将 UserDao 传递给 UserService。

除了构造器注入，Spring 还支持 Setter 注入，示例如下：

public class UserService {
    private UserDao userDao;

    // Setter方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser(User user) {
        userDao.save(user);
    }
}

在配置类中，我们可以使用如下方式实现 Setter 注入：

@Configuration
public class AppConfig {

    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

    @Bean
    public UserService userService() {
        UserService userService = new UserService();
        userService.setUserDao(userDao());
        return userService;
    }
}

总结

Spring 的 IOC 和 DI 机制通过将对象的创建和管理交给容器，使程序的结构更加清晰，各个模块之间的依赖关系更加明确，程序的可测试性和可维护性也显著提高。在实际开发中，合理使用这些特性可以有效地降低代码的耦合度，使得系统有更好的灵活性和扩展性。