当前位置:

首页 > 编程开发 > SpringIoC与DI实战指南

SpringIoC与DI实战指南

Spring框架的依赖注入(DI)和反转控制(IoC)这两个概念,几乎是每个Java开发者都绕不开的核心话题。它们到底怎么解耦、怎么提升代码的可维护性?今天咱们就从实战角度,把这些问题掰开揉碎了讲清楚。 一、IoC & DI入门 1.1 再次认识Spring 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 java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.List;
    import java.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 java.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 java.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命名约定

    SpringIoC与DI实战指南

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

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

    四、小结

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

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    LiteLLM 1.109.0迁移要改什么,1.108.5 LTS、1.106.8与1.110.0-rc.1该如何看
    LiteLLM 1.109.0迁移要改什么,1.108.5 LTS、1.106.8与1.110.0-rc.1该如何看

    给出LiteLLM1.109.0五项迁移配置,说明fallback列表、local缓存、router_settings硬限流、Gemini参数和Lens独立部署,并区分LTS/旧补丁/RC。

    agent-desktop 1.3.1升级后如何理解沙箱存活与桌面快照?
    agent-desktop 1.3.1升级后如何理解沙箱存活与桌面快照?

    agent-desktop 1.3.1让已经启动的沙箱在启动器退出后继续运行,并更新rustix至1.1.6。对通过JSON快照操作桌面的用户而言,沙箱存活、平台权限与ref有效性需要分别判断,不能用其中一项正常代替整项任务的验收。

    langchain-core 1.8.1如何理解langsmith_gateway的作用范围和优先级
    langchain-core 1.8.1如何理解langsmith_gateway的作用范围和优先级

    langchain-core 1.8.1新增的langsmith_gateway用于上下文级LangSmith Gateway覆盖。它并非一次模型调用的临时请求参数:路由在模型构造时解析,因而生效位置、集成支持和配置优先级都需要一起理解。

    Claude Trading Skills如何理解覆盖状态和密钥审查限制?
    Claude Trading Skills如何理解覆盖状态和密钥审查限制?

    Claude Trading Skills分别记录覆盖完整性、数据来源和规则确认;维护者自动扫描标记的not_verified不能等同完整安全验证或已发生密钥泄露,相关Skill代码未在该审查提交中修改。

    llama.cpp预发布b12420、b12424、b12426、b12428怎么按模型任务选择构建
    llama.cpp预发布b12420、b12424、b12426、b12428怎么按模型任务选择构建

    llama.cpp预发布b12420、b12424、b12426、b12428分别带来模型与模板层面的变化。文本模型、文本转语音、语音识别和Jinja渲染不是一项能力;按任务对应构建,可以避免把某个新增支持误认为适用于所有模型的通用升级。

    Google Ads Skills 1.1.1/1.0.3如何检查安装和账号诊断边界?
    Google Ads Skills 1.1.1/1.0.3如何检查安装和账号诊断边界?

    Google Ads设置与Quickstart Skills 1.1.1、账号诊断1.0.3明确MCP有限写入、只读配置和结构化search参数,安装前提为Python3.10+与pipx。

    LangChain四个集成包加入Gateway后,Python环境要注意什么
    LangChain四个集成包加入Gateway后,Python环境要注意什么

    LangChain四个模型集成包共同移除Python3.10支持并加入Gateway路由,需区分独立包版本与各自修复。

    WorkBuddy免费版能用吗?免费功能有哪些限制
    WorkBuddy免费版能用吗?免费功能有哪些限制

    WorkBuddy 免费版能用:体验版限时免费,每月 500 积分,限免期间享全模型调度、无限代码补全、99 个自动任务额度、每项目 5 人协作,另有 3 个自动任务、5 个项目、5GB 资料库、10 个云服务应用的数量限制。本文含官网定价页截图、积分消耗规律和免费补积分方法。

    Qwen Code 0.27.4如何理解临时授权、风险确认与消息分段
    Qwen Code 0.27.4如何理解临时授权、风险确认与消息分段

    解释Qwen Code 0.27.4临时目录授权、Managed Web Terminal、风险确认及飞书企业微信有序分段回复的边界。

    Claude Code 2.1.325哪些权限默认值变了,自动任务如何适配?
    Claude Code 2.1.325哪些权限默认值变了,自动任务如何适配?

    Claude Code 2.1.325改变了两类自动执行的默认行为:沙箱内Bash默认走常规权限流程,定时任务及/loop执行带allowed-tools或hooks声明的Skill会先请求确认。官方提供了对应配置,但受管环境必须遵守最高优先级的管理来源。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。