Java Spring 框架技术从入门到放弃:Spring生态之Spring 的 IoC(控制反转)学习笔记,IoC 的实现方式,依赖注入(DI), IoC 容器

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. 具体应用方式

  • 构造器注入
  1. 原理:通过构造函数传递依赖对象,对象创建时即完成注入。
  2. 特点优点:依赖关系明确,对象创建后即可使用,避免空指针;缺点:依赖较多时构造函数参数冗长,且无法动态修改依赖。
// 定义一个接口
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 中。这种方式的优点是对象在创建时就完成了依赖注入,保证了对象的完整性;缺点是如果依赖的对象较多,构造器参数会变得很长。

  • 属性注入
  1. 原理:通过 Setter 方法动态注入依赖对象,对象创建后可修改。
  2. 特点优点:灵活性高,支持可选依赖和动态替换;缺点:依赖可能未初始化,需额外检查。
// 依赖于 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();
    }
}

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

三种常见生命周期

  1. 单例(Singleton):全局唯一实例,适合无状态服务(如日志工具)。
    案例:餐厅经理(单例)管理所有服务员。

  2. 作用域(Scoped):每个请求 / 会话创建一个实例,适合有状态服务(如用户会话管理)。
    案例:银行柜员(作用域)处理单笔业务。
  3. 瞬态(Transient):每次使用时创建新实例,适合轻量级对象(如临时计算工具)。
    案例:餐厅菜单(瞬态)每次打印新副本。

选择建议

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

五、IoC 的优势

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

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

2. 提高可测试性:可轻松替换为模拟对象(如单元测试中使用 Mock 数据库)。

由于对象的依赖可以通过外部注入,在进行单元测试时,可以很方便地使用模拟对象来替代真实的依赖对象,从而提高测试的效率和准确性。

3. 便于维护和扩展:运行时动态配置依赖,适应不同环境(如开发环境与生产环境的数据源切换)。

当系统需要添加新的功能或修改现有功能时,只需要在 IoC 容器中进行相应的配置,而不需要对大量的代码进行修改,提高了系统的可维护性和可扩展性。

通过对Spring 的 IoC 进行学习和实践,我们可以更好地理解和运用这一强大的设计思想,提高 Java 开发的效率和质量。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zl515035644

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值