Spring IoC与DI：解耦实战指南- 惊觉

一、IoC & DI入门

1.1 再次认识Spring

我们知道Spring是一个开源框架，使用Spring让我们的开发更加简单。用一句更具体的话来说，Spring是包含了众多工具方法的IoC容器（容器中装的对象）

1.2 什么是IoC

IoC 是Spring的核心思想，我们在上一节已经使用过@RestController，当时我们提到加上这个注解就是把这个对象交给Spring管理，Spring框架启动时会加载该类，把对象交给Spring管理，这就是IoC思想。

IoC（Inversion of Control [控制反转]），也就是说Spring是一个“控制反转”的容器

所谓控制反转就是控制权发生了反转。获得依赖对象的过程被反转了，当需要某个对象时，传统的开发模式需要自己new一个对象，而现在只需要把创建对象的任务交给容器，在程序中注入依赖（Dependency Injection，DI）就可以了。这个容器称为：IoC容器，Spring是一个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）是从不同的角度描述同一件事情，依赖注入是从应用程序的角度来描述，就是通过引入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 java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
@Repository
public class BookDao {
/**
 * 模拟数据获取图书信息
 * @return 图书列表
 */
public List&lt;BookInfo&gt; mockData() {
    List&lt;BookInfo&gt; books = new ArrayList&lt;&gt;();
    for (int i = 0; i &lt; 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 java.util.List;
@Service
public class BookService {
@Autowired
private BookDao bookDao;
/**
获取图书列表并处理状态显示
@return 处理后的图书列表
*/
public List&lt;BookInfo&gt; getBookList() {
List&lt;BookInfo&gt; 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 java.util.List;
@RestController
@RequestMapping("/book")
public class BookController {
@Autowired
private BookService bookService;
@RequestMapping("/getList")
public List&lt;BookInfo&gt; getList() {
// 通过注入的bookService获取数据
List&lt;BookInfo&gt; 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 在实际项目中的应用：

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

2.3 与传统方式的对比

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

// 传统方式：手动创建对象
public class TraditionalBookController {
public List&lt;BookInfo&gt; 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的几个注解一起写了。但是考虑到这样的话文章太长了，所以就放去下一章了。现在已经九点了，我才点了臭粉，其实晚上我也吃晚饭了。但是这个臭粉太好吃了，柳妹妹螺狮粉（它家辣椒不辣，能吃辣的直接上变态辣就行），一定记得拿到手汤到进去闷一会再吃，最好从出餐到进嘴隔30min这样更有味道，更好吃哦。

转载自 CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2401_83281222/article/details/162946083

Spring IoC与DI：解耦实战指南

一、IoC & DI入门

1.1 再次认识Spring

1.2 什么是IoC

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

1.2.2 IoC优势

1.3 什么是DI

二、IoC & DI使用

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

2.1.1 实体类定义

2.1.2 Dao层实现

2.1.3 Service层实现

2.1.4 Controller层实现

2.1.5 启动类配置

2.1.6 运行与测试

2.2 示例解析

2.3 与传统方式的对比

三、Bean的存储

Bean命名约定

四、小结

评论

评论列表

微信小程序

QQ小程序

关于作者

Spring IoC与DI：解耦实战指南

一、IoC & DI入门

1.1 再次认识Spring

1.2 什么是IoC

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

1.2.2 IoC优势

1.3 什么是DI

二、IoC & DI使用

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

2.1.1 实体类定义

2.1.2 Dao层实现

2.1.3 Service层实现

2.1.4 Controller层实现

2.1.5 启动类配置

2.1.6 运行与测试

2.2 示例解析

2.3 与传统方式的对比

三、Bean的存储

Bean命名约定

四、小结

相关文章

评论

评论列表

微信小程序

QQ小程序

关于作者