从 0 开始理解 Spring 的核心思想 —— IoC 和 DI(1)

从 0 开始理解 Spring 的核心思想 —— IoC 和 DI（1）

Spring 是一个开源的企业级应用开发框架，它通过控制反转（Inversion of Control，IoC）和依赖注入（Dependency Injection，DI）等设计理念来简化开发，提高开发效率。Spring 的核心思想围绕着IoC 和 DI，这两者是Spring框架的基础。

本篇文章将从零开始，带你一步步理解Spring的核心思想，首先介绍IoC和DI是什么，如何在Spring中实现，以及它们如何改变我们编写程序的方式。

一、什么是 IoC（控制反转）？

1.1 控制反转（IoC）的定义

控制反转（Inversion of Control，IoC） 是一种设计原则，它的核心思想是将控制权从程序中某些部分转移给外部容器。简而言之，IoC的基本理念是将对象的创建和依赖关系的管理从应用程序中提取出来，让外部容器来管理。

在传统的编程中，你需要自己创建对象并管理对象之间的关系。这就好比你负责一个团队的每个成员的工作，任务的分配和人员管理完全由你自己决定。

IoC的好处：

降低了类与类之间的耦合。
提高了模块化和可测试性。
增加了灵活性，可以根据需要替换或配置不同的实现。

1.2 IoC 是如何工作的？

IoC 的核心在于控制权的反转，即程序不再控制对象的创建和生命周期管理，而是将这些操作交给外部容器来管理。在Spring中，IoC 容器通常是 Spring 容器（如 ApplicationContext 或 BeanFactory）。

传统方式：

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine();  // 创建 Engine 对象
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

在上面的代码中，Car 类创建了 Engine 对象，控制了 Engine 对象的生命周期和管理，Car 类和 Engine 类之间高度耦合。

使用 IoC 后：

public class Car {
    private Engine engine;

    // Spring 会自动注入 Engine 对象
    public Car(Engine engine) {
        this.engine = engine;  // IoC 容器提供的 Engine 对象
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

在这种方式下，Car 类不再负责 Engine 对象的创建，而是通过构造函数或其他方式将 Engine 对象注入给 Car类，这种依赖的注入方式就交由 Spring IoC 容器来处理，解耦了 Car 类和 Engine 类之间的关系。

二、什么是 DI（依赖注入）？

2.1 依赖注入（Dependency Injection，DI）的定义

依赖注入（Dependency Injection，DI） 是一种实现 IoC 的方式，是一种通过外部容器来自动提供类所依赖对象的设计模式。简而言之，依赖注入就是把需要的依赖（对象）从外部“注入”到类中，而不是由类自己创建。

依赖注入有三种常见的方式：

构造器注入（Constructor Injection）
Setter 注入（Setter Injection）
字段注入（Field Injection）

2.2 DI 在 Spring 中是如何工作的？

Spring 提供了多种方式来实现依赖注入，最常见的是通过构造器、Setter 方法或字段注解来注入依赖。

构造器注入（Constructor Injection）：

构造器注入是通过类的构造方法将依赖注入给类。Spring 会自动调用构造方法来注入依赖。

public class Car {
    private Engine engine;

    // 通过构造器注入 Engine 依赖
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

在 Spring 中，构造器注入会自动传递一个 Engine 类型的对象给 Car 类。

Setter 注入（Setter Injection）：

Setter注入通过类的 Setter 方法注入依赖对象。Spring 会在初始化对象后，调用Setter方法来注入依赖。

public class Car {
    private Engine engine;

    // 通过Setter方法注入 Engine 依赖
    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

在Spring中，使用 @Autowired 注解标记setEngine方法，Spring 会自动为 Car 类注入 Engine 类型的对象。

字段注入（Field Injection）：

字段注入是通过注解 @Autowired 直接在类的成员变量上注入依赖。这是最简洁的方式，但也可能在测试时带来一些不便。

public class Car {
    @Autowired
    private Engine engine;

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

Spring 会自动扫描 @Autowired 注解的字段，并注入匹配的依赖。

三、IoC 和 DI 在 Spring 中的应用

在 Spring 框架中，IoC 容器（通常是 ApplicationContext）负责创建和管理对象的生命周期，DI 则用于将这些对象之间的依赖关系注入到目标对象中。

Spring IoC 容器：IoC 容器负责实例化、配置和组装应用中的对象。它读取配置文件或注解信息，创建对象并将依赖关系注入。
DI：DI 是 IoC 的一种实现方式，它通过不同的方式将对象的依赖关系注入到目标对象中。

四、Spring 容器的两种类型

Spring 提供了两种 IoC 容器：

BeanFactory：提供基本的 IoC 功能，适用于简单的应用程序。
ApplicationContext：继承自 BeanFactory，是 Spring 提供的更完整的 IoC 容器，支持更多的功能，如事件发布、国际化等。

通常情况下，开发者会使用 ApplicationContext，因为它是更为常见和强大的选择。

五、Spring 中 IoC 和 DI 的实现方式

Spring 提供了两种方式来配置和管理 Bean：

XML 配置方式：通过 XML 配置文件来配置 Spring 容器的 Bean。
注解方式：通过注解（如 @Component、@Autowired 等）来配置 Bean 和依赖关系。

5.1 XML 配置方式

在 XML 配置中，我们需要在 applicationContext.xml 中定义 Bean，并手动配置依赖注入：

<bean id="engine" class="com.example.Engine"/>
<bean id="car" class="com.example.Car">
    <constructor-arg ref="engine"/>
</bean>

5.2 注解方式

在注解方式中，我们使用 @Component 和 @Autowired 注解来标记类和字段：

@Component
public class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

@Component
public class Car {
    @Autowired
    private Engine engine;

    public void drive() {
        engine.start();
        System.out.println("Car is driving...");
    }
}

在 Spring Boot 项目中，通常会使用注解方式，Spring 容器会自动扫描和管理这些标注了 @Component 注解的类。

六、总结

IoC（控制反转） 是 Spring 的核心思想，它将对象的创建和管理从代码中反转出来，由 Spring 容器来管理。
DI（依赖注入） 是 IoC 的一种实现方式，它通过构造器、Setter 方法或字段注解将对象的依赖关系注入到目标对象中，从而解耦了类与类之间的关系。
Spring 提供了两种配置方式：XML 配置和注解配置，注解配置是目前开发中更常用的方式。

通过 IoC 和 DI，Spring 简化了对象之间的依赖关系，增强了模块化和可测试性，使得开发人员可以专注于业务逻辑，而不需要管理对象的创建和生命周期。

从 0 开始理解 Spring 的核心思想 —— IoC 和 DI(1)