Spring 中 IoC 与 DI 实现原理详解

dsq_MaDing

于 2025-02-21 01:49:04 发布

阅读量501

点赞数 17

文章标签： spring java 后端

本文链接：https://blog.youkuaiyun.com/dsq_MaDing/article/details/145767277

版权

一、引言

IoC（Inversion of Control，控制反转）和 DI（Dependency Injection，依赖注入）是两个至关重要的概念，它们是 Spring 框架等众多 Java 框架的核心思想，能够有效提升代码的可维护性、可测试性和可扩展性。

二、IoC（控制反转）

2.1 概念理解

传统的软件开发中，对象的创建和依赖关系的管理通常由对象自身或调用者负责，这使得代码之间的耦合度较高。而 IoC 的核心思想是将对象的创建和依赖关系的管理从代码内部转移到外部容器中，实现了控制权的反转。简单来说，就是由容器来负责对象的创建、初始化和依赖关系的注入，而不是由对象自己来完成这些工作。

2.2 作用

降低耦合度：对象之间的依赖关系由容器管理，对象只需关注自身的业务逻辑，无需关心依赖对象的创建和获取，从而降低了代码之间的耦合度。
提高可维护性：当依赖关系发生变化时，只需在容器中进行配置修改，而不需要修改大量的业务代码，提高了代码的可维护性。
增强可测试性：在进行单元测试时，可以方便地替换依赖对象，模拟不同的测试场景，增强了代码的可测试性。

2.3 实现方式

IoC 的实现方式主要有两种：依赖查找（Dependency Lookup）和依赖注入（Dependency Injection）。依赖查找是指对象主动从容器中查找所需的依赖对象；而依赖注入是指容器将依赖对象注入到目标对象中，下面重点介绍依赖注入。

三、DI（依赖注入）

3.1 概念

依赖注入是 IoC 的一种具体实现方式，它是指在创建对象时，将对象所依赖的其他对象通过构造函数、方法参数或属性等方式注入到对象中。

3.2 注入方式

3.2.1 构造函数注入

通过构造函数将依赖对象传递给目标对象。这种方式确保了对象在创建时就具备所需的依赖，保证了对象的完整性。

// 依赖对象
class Dependency {
    public void doSomething() {
        System.out.println("Dependency is doing something.");
    }
}

// 目标对象
class Target {
    private Dependency dependency;

    // 构造函数注入
    public Target(Dependency dependency) {
        this.dependency = dependency;
    }

    public void performAction() {
        dependency.doSomething();
    }
}

// 使用示例
public class ConstructorInjectionExample {
    public static void main(String[] args) {
        Dependency dependency = new Dependency();
        Target target = new Target(dependency);
        target.performAction();
    }
}

3.2.2 Setter 方法注入

通过 Setter 方法将依赖对象注入到目标对象中。这种方式允许在对象创建后动态地修改依赖关系。

// 依赖对象
class Dependency {
    public void doSomething() {
        System.out.println("Dependency is doing something.");
    }
}

// 目标对象
class Target {
    private Dependency dependency;

    // Setter 方法注入
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }

    public void performAction() {
        if (dependency != null) {
            dependency.doSomething();
        }
    }
}

// 使用示例
public class SetterInjectionExample {
    public static void main(String[] args) {
        Target target = new Target();
        Dependency dependency = new Dependency();
        target.setDependency(dependency);
        target.performAction();
    }
}

3.2.3 接口注入

目标对象实现一个特定的接口，该接口定义了注入依赖对象的方法，容器通过调用该接口方法进行依赖注入。这种方式在实际开发中使用相对较少。

3.3 实现原理

3.3.1 反射机制

反射是 Java 的一个强大特性，它允许程序在运行时动态地获取类的信息、创建对象、调用方法等。在依赖注入中，反射机制起到了关键作用。容器通过反射创建对象实例，并通过反射调用构造函数或 Setter 方法进行依赖注入。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

// 依赖对象
class Dependency {
    public void doSomething() {
        System.out.println("Dependency is doing something.");
    }
}

// 目标对象
class Target {
    private Dependency dependency;

    public Target(Dependency dependency) {
        this.dependency = dependency;
    }

    public void performAction() {
        if (dependency != null) {
            dependency.doSomething();
        }
    }
}

// 模拟容器进行依赖注入
public class ReflectionInjectionExample {
    public static void main(String[] args) {
        try {
            // 创建依赖对象
            Dependency dependency = new Dependency();

            // 获取目标对象的构造函数
            Constructor<Target> constructor = Target.class.getConstructor(Dependency.class);

            // 使用反射创建目标对象并注入依赖
            Target target = constructor.newInstance(dependency);

            // 调用目标对象的方法
            target.performAction();
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

3.3.2 配置文件

为了实现对象的管理和依赖关系的配置，通常会使用配置文件，如 XML 或注解。以 Spring 框架为例，XML 配置文件可以定义对象的创建和依赖关系，Spring 容器在启动时会解析配置文件，根据配置信息创建对象并进行依赖注入。

<!-- Spring XML 配置文件示例 -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义依赖对象 -->
    <bean id="dependency" class="com.example.Dependency"/>

    <!-- 定义目标对象，并通过构造函数注入依赖 -->
    <bean id="target" class="com.example.Target">
        <constructor-arg ref="dependency"/>
    </bean>
</beans>

在 Java 代码中，可以通过 Spring 容器加载配置文件并获取对象：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringExample {
    public static void main(String[] args) {
        // 加载 Spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取目标对象
        Target target = (Target) context.getBean("target");

        // 调用目标对象的方法
        target.performAction();
    }
}