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

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（造汽车）

先看传统代码：

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容器做的工作：

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

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

1.3 什么是DI

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

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

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

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 运行与测试

启动应用程序后，访问http://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命名约定

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

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

四、小结

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