游乐游手机版
首页/编程语言/文章详情

Spring IoC与DI依赖注入实战指南

时间：2026-07-22 22:20
Spring框架通过控制反转（IoC）思想实现对象由容器统一管理，依赖注入（DI）在运行时动态提供所需资源，从而降低耦合度。以汽车组装为例，传统代码层层依赖导致修改困难，IoC反转控制权后依赖类变化不影响调用链。使用@Component和@Autowired注解即可将对象交由Spring容器管理并注入依赖。

Spring框架的依赖注入（DI）和控制反转（IoC）这两个核心概念，几乎是每一位Java开发者都绕不开的关键话题。它们究竟如何实现解耦、提升代码的可维护性？今天，我们就从实战角度出发，把这些知识点掰开揉碎，讲清楚讲透彻。

一、IoC & DI入门

1.1 再次认识Spring

Spring是一个开源框架，这一点众所周知。但更准确地说，Spring是一个包含了众多工具方法的IoC容器——容器里装的就是各式各样的对象。换句话说，你无需自己管理对象的生命周期，交给Spring就行了。

1.2 什么是IoC

IoC是Spring的核心思想。之前我们使用过@RestController，加上这个注解其实就是把对象交给Spring管理。Spring框架启动时加载该类，并将对象交给Spring容器——这就是IoC思想。

IoC（Inversion of Control，控制反转），意味着Spring是一个“控制反转”的容器。所谓控制反转，就是控制权发生了反转：获得依赖对象的过程被反转了。传统开发中，需要某个对象时得自己new一个；而现在，只需要把创建对象的任务交给容器，在程序中通过依赖注入（DI）使用即可。这个容器就是IoC容器，Spring也因此被称为Spring容器。

1.2.1 通过实例来认识IoC（造汽车）

SpringIoC与DI实战指南

先看传统代码：

public class CarExample {
    public static void main(String[] args) {
        Car car=new Car();
        car.run();
    }
    static class Car{
        public Framework framework;
        public Car(){
            framework=new Framework();
            System.out.print("Car init...");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }
    static class Framework {
        public Bottom bottom;
    public Framework() {
        bottom = new Bottom();
        System.out.println("Framework init...");
    }
}
static class Bottom {
    public Tire tire;
    public Bottom(){
        this.tire=new Tire();
        System.out.println("Bottom init...");
    }
}
static class Tire {
    public int size;
    public Tire(){
        this.size=16;
        System.out.println("轮胎尺寸是"+size);
    }
}
}

这段代码表面上看没什么问题，但实际可维护性很低。如果我们想给Tire的size传参，就会发现从Bottom到Framework到Car，整个调用链都得跟着改：

public class CarExample {
    public static void main(String[] args) {
        Car car=new Car(9);
        car.run();
    }
    static class Car{
        public Framework framework;
        public Car(int size){
            framework=new Framework(size);
            System.out.print("Car init...");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }
    static class Framework {
        public Bottom bottom;
    public Framework(int size) {
        bottom = new Bottom(size);
        System.out.println("Framework init...");
    }
}
static class Bottom {
    public Tire tire;
    public Bottom(int size){
        this.tire=new Tire(size);
        System.out.println("Bottom init...");
    }
}
static class Tire {
    public int size;
    public Tire(int size){
        this.size=size;
        System.out.println("轮胎尺寸是"+size);
    }
}
}

不难看出：最底层的代码一改动，整个调用链上的所有类都得跟着修改——这耦合度，谁维护谁知道。

但按照IoC的思想调整一下：

public class CarExample {
    public static void main(String[] args) {
        Tire tire=new Tire(20);
        Bottom bottom=new Bottom(tire);
        Framework framework=new Framework(bottom);
        Car car=new Car(framework);
        car.run();
    }
    static class Car{
        public Framework framework;
        public Car(Framework framework){
            this.framework=framework;
            System.out.print("Car init...");
        }
        public void run(){
            System.out.println("Car run...");
        }
    }
    static class Framework {
        public Bottom bottom;
    public Framework(Bottom bottom) {
        this.bottom =bottom;
        System.out.println("Framework init...");
    }
}
static class Bottom {
    public Tire tire;
    public Bottom(Tire tire){
        this.tire=tire;
        System.out.println("Bottom init...");
    }
}
static class Tire {
    public int size;
    public Tire(int size){
        this.size=size;
        System.out.println("轮胎尺寸是"+size);
    }
}
}

这样一来，无论底层类怎么变化，整个调用链都不用做任何改变——解耦完成了。

1.2.2 IoC的优势

传统代码创建顺序：Car → Framework → Bottom → Tire
IoC代码创建顺序：Tire → Bottom → Framework → Car

发现规律了吗？改进之后，类的创建顺序完全反过来了。传统代码是Car控制和创建Framework，Framework再创建Bottom，依次往下；而改进之后，控制权发生了反转——不再是当前类创建并控制依赖对象，而是把依赖对象注入到当前类中。依赖对象的控制权不再由当前类掌握。这样一来，依赖类发生任何变化，当前类都不受影响。这就是典型的控制反转，也就是IoC的实现思想。

这部分代码就是IoC容器做的工作：

SpringIoC与DI实战指南

IoC容器的好处很明显：资源不由使用资源的双方管理，而由第三方（容器）统一管理。这带来了很多好处：

  • 资源集中管理，实现资源的可配置和易管理。
  • 降低了使用资源双方的依赖程度，也就是耦合度。

1.3 什么是DI

DI：Dependency Injection（依赖注入），在容器运行期间，动态地为应用程序提供运行时所需的资源，这叫做依赖注入。

程序运行时需要某个资源，容器就给它提供这个资源。依赖注入（DI）和控制反转（IoC）是从不同角度描述同一件事：DI是从应用程序的角度来说的——通过引入IoC容器，利用依赖关系注入的方式，实现对象之间的解耦。

SpringIoC与DI实战指南

上图箭头部分就是在执行注入。

IoC是一种思想，也是“目标”；而思想只是指导原则，最终还需要可行的落地方案。DI就是具体的实现。也可以说，DI是IoC的一种实现。

举个接地气的例子：今天想奖励自己吃顿好的——“吃顿好的”是思想（IoC），但最终决定吃臭粉还是臭榴莲，这就是具体实现（DI）。

二、IoC & DI使用

既然Spring是一个IoC容器，那它就必须具备存和取两个功能。Spring容器管理的主要是对象，这些对象我们称为“Bean”。我们把对象交给Spring管理，由Spring负责对象的创建和销毁，程序只需要告诉Spring哪些需要存，以及如何从Spring中取出对象。

核心步骤：

Service层及Dao层的实现类，交给Spring管理；使用注解@Component

在Controller层和Service层注入运行时依赖对象；使用注解@Autowired

2.1 完整示例：图书管理系统

下面通过一个完整的图书管理系统示例，演示如何用@Component和@Autowired实现IoC和DI。

2.1.1 实体类定义

先定义图书实体类：

public class BookInfo {
    private Integer id;
    private String bookName;
    private String author;
    private Integer count;
    private BigDecimal price;
    private String publish;
    private Integer status;
    private String statusCN;
// 省略getter和setter方法
// 实际开发中应使用Lombok或手动生成
}

2.1.2 Dao层实现

创建BookDao类，使用@Repository注解交给Spring管理：

import org.springframework.stereotype.Repository;
import ja va.math.BigDecimal;
import ja va.util.ArrayList;
import ja va.util.List;
import ja va.util.Random;
@Repository
public class BookDao {
/**
 * 模拟数据获取图书信息
 * @return 图书列表
 */
public List mockData() {
    List books = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
        BookInfo book = new BookInfo();
        book.setId(i);
        book.setBookName("书籍" + i);
        book.setAuthor("作者" + i);
        book.setCount(i * 5 + 3);
        book.setPrice(new BigDecimal(new Random().nextInt(100)));
        book.setPublish("出版社" + i);
        book.setStatus(1);
        books.add(book);
    }
    return books;
}
}

2.1.3 Service层实现

创建BookService类，使用@Service注解交给Spring管理，并通过@Autowired注入BookDao：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import ja va.util.List;
@Service
public class BookService {
@Autowired
private BookDao bookDao;
/**
获取图书列表并处理状态显示
@return 处理后的图书列表
*/
public List getBookList() {
List books = bookDao.mockData();
for (BookInfo book : books) {
if (book.getStatus() == 1) {
book.setStatusCN("可借阅");
} else {
book.setStatusCN("不可借阅");
}
}
return books;
}
}

2.1.4 Controller层实现

创建BookController类，使用@RestController注解，并通过@Autowired注入BookService：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import ja va.util.List;
@RestController
@RequestMapping("/book")
public class BookController {
@Autowired
private BookService bookService;
@RequestMapping("/getList")
public List getList() {
// 通过注入的bookService获取数据
List books = bookService.getBookList();
return books;
}
}

2.1.5 启动类配置

创建Spring Boot启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class LibraryApplication {
public static void main(String[] args) {
SpringApplication.run(LibraryApplication.class, args);
}
}

2.1.6 运行与测试

启动应用程序后，访问https://localhost:8080/book/getList即可获取图书列表数据。

2.2 示例解析

通过这个完整示例，可以直观看到IoC和DI在实际项目中的应用：

  1. Bean存储：
    • BookDao使用@Repository，表示数据访问层组件
    • BookService使用@Service，表示业务逻辑层组件
    • BookController使用@RestController，表示控制层组件
  2. 依赖注入：
    • BookService中通过@Autowired注入BookDao
    • BookController中通过@Autowired注入BookService
  3. 控制反转：
    • 所有对象的创建和管理都由Spring容器负责
    • 各层之间通过接口依赖，而不是直接创建对象
    • 当需要修改实现时，只需修改对应的Bean配置，不影响其他层

2.3 与传统方式的对比

如果没有使用Spring IoC和DI，传统代码通常是这样的：

// 传统方式：手动创建对象
public class TraditionalBookController {
public List getList() {
    // 需要手动创建所有依赖对象
    BookDao bookDao = new BookDao();
    BookService bookService = new BookService(bookDao);
    return bookService.getBookList();
}
}
// Service 也需要手动创建 Dao
public class TraditionalBookService {
private BookDao bookDao;
public TraditionalBookService() {
    this.bookDao = new BookDao();  // 硬编码依赖
}
}

传统方式的问题：

  • 对象创建逻辑分散在各个类中
  • 修改依赖时需要修改多处代码
  • 难以进行单元测试（无法轻松替换依赖）
  • 代码耦合度高，维护困难

使用Spring IoC/DI的优势：

  • 对象创建集中管理
  • 依赖关系通过配置声明，而非硬编码
  • 便于单元测试（可以通过Mock替换依赖）
  • 代码解耦，各层职责清晰
  • 支持灵活的配置和扩展

通过这个完整示例，能更直观地理解IoC和DI在实际项目中的应用价值。Spring容器就像一个“对象工厂”，负责创建和管理所有Bean对象，开发者只需要通过注解声明依赖关系，Spring就会自动完成对象的装配和注入。

三、Bean的存储

之前提到，要把某个对象交给IoC容器管理，需要在类上添加@Component注解。而Spring框架为了更好地服务Web应用程序，提供了更丰富的注解：

类注解：@Controller、@Service、@Repository、@Component、@Configuration

方法注解：@Bean

Bean命名约定

SpringIoC与DI实战指南

开发人员不需要为Bean指定名称。如果没有显式提供名称，Spring容器会为Bean生成唯一名称。命名方式如下：

  • beanName默认为类名的小驼峰写法。例如：类名UserController，Bean名称为userController；类名AccountService，Bean名称为accountService。
  • 如果类名前两位均为大写，beanName则为类名本身。例如：类名UController，Bean名称为UController；类名AManager，Bean名称为AManager。

四、小结

本来准备在这把Bean的几个注解一起写了，但考虑到篇幅就放到下一章。现在九点了，刚点了一份臭粉，晚上虽吃过晚饭，但臭粉太好吃了。柳妹妹螺狮粉（它家辣椒不辣，能吃辣的直接上变态辣就行），一定记得拿到手汤倒进去闷一会再吃，最好从出餐到进嘴隔30分钟，这样更有味道，更好吃哦。

来源：https://www.jb51.net/program/367742acd.htm
SpringDI
上一篇Java定时任务只执行一次并自动关闭的方法 下一篇Python模块与包：从定义到实战指南
本站内容用于信息整理与展示，如有侵权或内容问题请及时联系处理。

相关推荐

补充同频道和同主题内容，方便继续浏览更多相关内容。

同类最新

继续查看同栏目最近更新的文章。

更多
FileZilla断点续传设置与操作指南
编程语言 · 2026-07-25

FileZilla断点续传设置与操作指南

FileZilla支持断点续传，需客户端与服务器均开启REST命令。设置中确保启用断点续传及继续传输选项。中断后自动或手动从断点恢复。注意服务器支持、传输模式匹配及文件完整性校验。

 Debian系统C++编译器位置查找方法
编程语言 · 2026-07-25

Debian系统C++编译器位置查找方法

在Debian系统中，通过apt安装的C++编译器g++默认位于 usr bin g++，可使用which或whereis命令验证路径。g++属于build-essential软件包，若未安装则需执行sudoaptinstallbuild-essential。该包还包含gcc、make等编译工具链，g++是GNUC++编译器，实际是符号链接指向具体版本，验证

 Debian系统安装C++环境的方法
编程语言 · 2026-07-25

Debian系统安装C++环境的方法

在Debian系统安装C++开发环境：先sudoaptupdate更新包列表，再sudoaptinstallbuild-essential安装编译工具链，或单独安装g++。用g++--version验证。可选安装VSCode、GDB、CMake等工具并配置默认编译器版本。

 Debian系统C++开发环境配置指南
编程语言 · 2026-07-25

Debian系统C++开发环境配置指南

在Debian系统中，先执行aptupdate更新软件包列表，再安装build-essential元包即可获得GCC、G++、Make和GDB。通过运行g++--version命令验证编译器安装成功。可选安装VisualStudioCode、CLion等编辑器及CMake构建工具，并编写一个简单的HelloWorld程序，使用g++编译运行以验证环境配置正确

 通过cpustat工具查看CPU状态的具体方法与详细步骤
编程语言 · 2026-07-25

通过cpustat工具查看CPU状态的具体方法与详细步骤

cpustat是sysstat包中的CPU监控工具，可按固定间隔输出带时间戳的CPU使用率统计。安装后运行cpustat即可实时显示各核心信息，常用指标包括%usr、%sys、%iowait、%steal和%idle，用于定位用户态、内核态或I O瓶颈。高级选项-c可显示单核统计，-m可同时查看内存使用，适合脚本采集和性能分析。