Java Spring 框架技术从入门到放弃：Spring生态之Spring 的 IoC（控制反转）学习笔记，IoC 的实现方式，依赖注入（DI）， IoC 容器-优快云博客

本文链接：https://blog.youkuaiyun.com/beijing_oracle/article/details/146610695

Java Spring 框架技术从入门到放弃：Spring生态之Spring 的 IoC（控制反转）学习笔记

一、IoC 基础概念

1. 定义

IoC（Inversion of Control）即控制反转，它是一种设计思想，并非具体的技术。核心在于将对象的创建、依赖关系的管理从代码内部转移到外部容器。在传统编程中，对象由自身或调用者创建和管理，而在 IoC 模式下，这些工作由 IoC 容器负责，实现了对象控制权的反转。

2. 生活案例

想象你要举办一场婚礼。传统方式下，你得亲自去安排婚礼的各个环节，比如预订场地、安排餐饮、布置现场等，所有的控制权都在你自己手中。但如果你选择找一家专业的婚礼策划公司，把这些事情都交给他们处理，你只需要在最后参加婚礼就行。这里，婚礼策划公司就相当于 IoC 容器，原本由你控制的婚礼筹备工作，现在交给了外部的容器来完成，这就是控制权的反转。

二、依赖注入（DI）：IoC 的实现方式

1. 概念

依赖注入（Dependency Injection，简称 DI）是 IoC 的具体实现方式。当一个对象需要依赖另一个对象时，不是由该对象自己去创建依赖对象，而是通过外部容器将依赖对象注入到该对象中。

2. 生活案例

以组装电脑为例，你要组装一台电脑，电脑需要硬盘、CPU、内存条等组件。在传统方式下，你要自己去市场购买这些组件，然后进行组装。而在 IoC 模式下，你可以告诉电脑组装店你的需求，他们会帮你采购合适的硬盘、CPU、内存条等组件，并将它们组装到电脑中。这里，电脑组装店就是 IoC 容器，它将硬盘、CPU 等依赖组件注入到电脑这个对象中。

3. 具体应用方式

构造器注入

原理：通过构造函数传递依赖对象，对象创建时即完成注入。
特点：优点：依赖关系明确，对象创建后即可使用，避免空指针；缺点：依赖较多时构造函数参数冗长，且无法动态修改依赖。

// 定义一个接口
interface MessageService {
    String getMessage();
}

// 实现接口
class EmailService implements MessageService {
    @Override
    public String getMessage() {
        return "这是一封邮件消息";
    }
}

// 依赖于 MessageService 的类
class MessagePrinter {
    private MessageService service;

    // 通过构造器注入依赖
    public MessagePrinter(MessageService service) {
        this.service = service;
    }

    public void printMessage() {
        System.out.println(service.getMessage());
    }
}

代码解释：在上述代码中，MessagePrinter 类依赖于 MessageService 接口，通过构造器将 MessageService 的实现类（如 EmailService）注入到 MessagePrinter 中。这种方式的优点是对象在创建时就完成了依赖注入，保证了对象的完整性；缺点是如果依赖的对象较多，构造器参数会变得很长。

属性注入

原理：通过 Setter 方法动态注入依赖对象，对象创建后可修改。
特点：优点：灵活性高，支持可选依赖和动态替换；缺点：依赖可能未初始化，需额外检查。

// 依赖于 MessageService 的类
class MessagePrinter {
    private MessageService service;

    // 通过 setter 方法注入依赖
    public void setService(MessageService service) {
        this.service = service;
    }

    public void printMessage() {
        System.out.println(service.getMessage());
    }
}

这里，MessagePrinter 类通过 setService 方法将 MessageService 的实现类注入。属性注入的优点是可以在对象创建后动态地修改依赖对象；缺点是对象在创建后可能处于不完整的状态，直到依赖对象被注入。

接口注入（Interface Injection）

原理：通过实现特定接口声明依赖，容器通过接口方法注入。

特点：优点：高度解耦，支持插件化扩展；缺点：需定义额外接口，增加代码复杂度。

// 注入接口
public interface PowerSupply {
    void connect(ElectricSocket socket);
}

// 设备类
public class MobilePhone implements PowerSupply {
    private ElectricSocket socket;
    
    // 接口注入
    public void connect(ElectricSocket socket) {
        this.socket = socket;
    }
    
    public void charge() {
        socket.providePower();
    }
}

手机充电器需适配不同接口（Type-C、Lightning），通过接口协议动态适配。

三、Spring 中的 IoC 容器

1. 容器类型

Spring提供了两种主要的 IoC 容器：BeanFactory 和 ApplicationContext。

BeanFactory

它是 Spring 最底层的 IoC 容器接口，提供了基本的对象创建和管理功能。它采用懒加载的方式，即只有在需要获取对象时才会创建对象。

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class BeanFactoryExample {
    public static void main(String[] args) {
        // 加载配置文件
        BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        // 获取对象
        MessagePrinter printer = (MessagePrinter) factory.getBean("messagePrinter");
        printer.printMessage();
    }
}

ApplicationContext

它是 BeanFactory 的子接口，在 BeanFactory 的基础上提供了更多的功能，如国际化支持、事件发布等。它采用预加载的方式，在容器启动时就会创建所有的单例对象。

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

public class ApplicationContextExample {
    public static void main(String[] args) {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取对象
        MessagePrinter printer = context.getBean("messagePrinter", MessagePrinter.class);
        printer.printMessage();
    }
}

2. 配置方式

Spring 中的 IoC 容器可以通过 XML 配置文件、注解或 Java 配置类来进行配置。

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">

    <!-- 定义 MessageService 的实现类 -->
    <bean id="emailService" class="com.example.EmailService"/>

    <!-- 定义 MessagePrinter 类，并通过构造器注入依赖 -->
    <bean id="messagePrinter" class="com.example.MessagePrinter">
        <constructor-arg ref="emailService"/>
    </bean>
</beans>

注解配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// 配置类
@Configuration
public class AppConfig {

    // 定义 MessageService 的实现类
    @Bean
    public MessageService emailService() {
        return new EmailService();
    }

    // 定义 MessagePrinter 类，并通过构造器注入依赖
    @Bean
    public MessagePrinter messagePrinter() {
        return new MessagePrinter(emailService());
    }
}

Java 配置类

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        // 加载配置类
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 获取对象
        MessagePrinter printer = context.getBean(MessagePrinter.class);
        printer.printMessage();
        context.close();
    }
}

四、依赖注入的生命周期管理

三种常见生命周期：

单例（Singleton）：全局唯一实例，适合无状态服务（如日志工具）。
案例：餐厅经理（单例）管理所有服务员。
作用域（Scoped）：每个请求 / 会话创建一个实例，适合有状态服务（如用户会话管理）。
案例：银行柜员（作用域）处理单笔业务。
瞬态（Transient）：每次使用时创建新实例，适合轻量级对象（如临时计算工具）。
案例：餐厅菜单（瞬态）每次打印新副本。

选择建议：

无状态服务 → Singleton
有状态且需隔离 → Scoped
频繁创建销毁 → Transient

五、IoC 的优势

1. 降低耦合度：对象间依赖由容器管理，修改实现无需改动调用方代码。

通过将对象的创建和依赖关系的管理交给 IoC 容器，各个对象之间的耦合度大大降低。例如，在上述 MessagePrinter 和 MessageService 的例子中，MessagePrinter 只依赖于 MessageService 接口，而不依赖于具体的实现类。当需要更换 MessageService 的实现类时，只需要在容器中进行配置，而不需要修改 MessagePrinter 类的代码。