Spring IoC 与 DI 核心知识点综合测试题

Ne0inhk

— 14 min read
Spring IoC 与 DI 核心知识点综合测试题

3.3.1 方法注解要配合类注解使用

在 Spring 框架的设计中，方法注解 @Bean 要配合类注解才能将对象正常的存储到 Spring 容器中，如下代码所示：

@Component public class BeanConfig { @Bean public User user(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; } }

再次执行以上代码，运行结果如下：

3.3.2 定义多个对象

对于同一个类，如何定义多个对象呢？比如多数据源的场景，类是同一个，但是配置不同，指向不同的数据源。

我们看下@Bean的使用：

@Component public class BeanConfig { @Bean public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; } @Bean public User user2(){ User user = new User(); user.setName("lisi"); user.setAge(19); return user; } }

定义了多个对象的话，我们根据类型获取对象，获取的是哪个对象呢？

@SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { //获取Spring上下文对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); //从Spring上下文中获取对象 User user = context.getBean(User.class); //使用对象 System.out.println(user); } }

运行结果:

报错信息与解决方案

报错信息显示：期望只有一个匹配，结果发现了两个，user1, user2从报错信息中，可以看出来，@Bean 注解的 bean, bean 的名称就是它的方法名

接下来我们根据名称来获取 bean 对象

@SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { //获取Spring上下文对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); //根据bean名称, 从Spring上下文中获取对象 User user1 = (User) context.getBean("user1"); User user2 = (User) context.getBean("user2"); System.out.println(user1); System.out.println(user2); } }

运行结果:

User(name=zhangsan, age=18) User(name=lisi, age=19)

可以看到，@Bean 可以针对同一个类，定义多个对象.

3.3.3 重命名 Bean

1. 五大注解（@Component/@Service/@Controller/@Repository/@Configuration）

Spring 会根据类名自动生成 bean name，规则分两种：

  • 情况 1：类名前两个字母都是大写 → bean name 直接等于类名本身
    • 例：class HTTPClient {} → bean name = HTTPClient
    • 例：class SQLParser {} → bean name = SQLParser
  • 情况 2：其他情况 → bean name 是类名的小驼峰写法（首字母小写）
    • 例：class UserService {} → bean name = userService
    • 例：class OrderController {} → bean name = orderController

2. @Bean 注解

当你在配置类里用 @Bean 标注一个方法时：

  • bean name 直接等于方法名

例：

@Bean public UserService userService() { return new UserService(); }

→ bean name = userService

举个完整例子对比

代码写法生成的 bean name规则
class UserService {}userService小驼峰
class HTTPClient {}HTTPClient前两位大写，保持原样
@Bean public OrderDao orderDao() {}orderDao方法名

💡 小提示：

  • 如果你想自定义 bean name，可以直接在注解里写，比如 @Service("myUserService") 或 @Bean(name = "myOrderDao")。
  • 这个规则是 Spring 的 BeanNameGenerator 实现的，目的是保证 bean 名称的可读性和唯一性

可以通过设置 name 属性给 Bean 对象进行重命名操作，如下代码所示:

@Bean(name = {"u1","user1"}) public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; }

此时我们使用 u1 就可以获取到 User 对象了，如下代码所示:

此时可通过 context.getBean("u1") 或 context.getBean("user1") 获取对象：

@SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); User u1 = (User) context.getBean("u1"); System.out.println(u1); } }
3.3.3.2语法简写规则

单个名称时，大括号也可省略：

@Bean("u1") public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; }

name= 可省略：

@Bean({"u1","user1"}) public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; }
3.3.3.3 扫描路径知识点

Q：使用 @Component/@Service 等四个注解声明的 bean，一定会生效吗？A：不一定。原因：bean 想要生效，还需要被 Spring 扫描到，未被扫描的注解不会被注册为 bean。

A：不一定。原因：bean 想要生效，还需要被 Spring 扫描到，未被扫描的注解不会被注册为 bean。

下⾯我们通过修改项⽬⼯程的⽬录结构，来测试bean对象是否⽣效:

@SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { //获取Spring上下文对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); //从Spring上下文中获取对象 User u1 = (User) context.getBean("u1"); //使用对象 System.out.println(u1); } }

运行结果：

结果解读

这个异常表示：Spring 容器中不存在名为 u1 的 Bean。

  • 可能原因：
    1. @Bean(name = "u1") 的配置类没有被 Spring 扫描到。
    2. @Bean 注解没有被正确添加到类注解（如 @Component/@Configuration）的类中。
    3. Bean 名称拼写错误（如 u1 写成 ui 或其他）。

注意：运行的这个类在扫描五大注解的时候只扫描在同一个路径下的文件，如果把他放到的service里面，其他路径的就不会扫描了

@ComponentScan({"com.example.demo"}) @SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { //获取Spring上下文对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); //从Spring上下文中获取对象 User u1 = (User) context.getBean("u1"); //使用对象 System.out.println(u1); } }

Spring Boot 的 @SpringBootApplication 已经包含了 @ComponentScan，默认扫描范围是 “启动类所在的包 + 所有子包”，所以大部分场景不用手动加。

但遇到以下情况，就需要手动配置 @ComponentScan：

  1. Bean 所在的包不在启动类的包 / 子包下（比如启动类在 com.example.demo，但 Bean 写在 com.example.service，不在子包）；
  2. 想精确控制扫描范围（比如只扫描 service 和 controller 包，排除 entity 包）；
  3. 想排除某些不想被扫描的类（比如某个类加了 @Service，但暂时不想让它变成 Bean）。
@ComponentScan 的核心用法
1. 基础用法：指定扫描的包路径
// 启动类 // 手动指定扫描 com.example.service 和 com.example.controller 两个包 @ComponentScan({"com.example.service", "com.example.controller"}) @SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); } }
  • 语法：@ComponentScan({"包路径1", "包路径2"})，大括号里可以写多个包；
  • 注意：包路径要写完整的包名（比如 com.example.service，不是 service）。
2. 进阶用法：包含 / 排除指定类
// 扫描 com.example 包，但排除 UserService 类（即使它加了 @Service 也不会变成 Bean） @ComponentScan( basePackages = "com.example", excludeFilters = @ComponentScan.Filter( type = FilterType.ASSIGNABLE_TYPE, classes = UserService.class ) ) @SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); } }

这种用法适合临时排除某个类，或者只扫描特定类型的注解（比如只扫描 @Controller，不扫描 @Service）。

3.和 @Configuration 的关联

@Configuration 标记的配置类，也需要被 @ComponentScan 扫描到，否则里面的 @Bean 方法不会被执行：

// 配置类放在 com.example.config 包下 @Configuration public class BeanConfig { @Bean public User user() { return new User("zhangsan", 18); } } // 启动类如果不扫描 com.example.config，BeanConfig 不会被识别，user() 也不会执行 @ComponentScan({"com.example.controller", "com.example.config"}) // 必须包含 config 包 @SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); User user = context.getBean(User.class); // 能拿到对象，因为扫描到了 BeanConfig } }
4.关键注意点（避坑）
  1. 不要重复扫描：手动加 @ComponentScan 时，不要和 @SpringBootApplication 的默认扫描范围重复，否则可能导致 Bean 重复创建；
  2. 包路径要写对：如果包路径写错（比如少写一层），Spring 找不到注解类，会报 NoSuchBeanDefinitionException；
  3. Spring Boot 不推荐手动加：除非特殊场景，否则尽量把所有 Bean 放在启动类的包 / 子包下，利用默认扫描，减少配置。

{} 里可以配置多个包路径这种做法仅做了解，不做推荐使用

那为什么前面没有配置 @ComponentScan 注解也可以呢？

@ComponentScan 注解虽然没有显式配置，但是实际上已经包含在了启动类声明注解 @SpringBootApplication 中了

默认扫描的范围是 SpringBoot 启动类所在包及其子包

在配置类上添加 @ComponentScan 注解，该注解默认会扫描该类所在的包下所有的配置类

推荐做法:

把启动类放在我们希望扫描的包的路径下,这样我们定义的bean就都可以被扫描到

DI 详解

依赖注入（DI）是 IoC 容器在创建 Bean 时，为其提供运行所依赖资源（对象）的过程，也被称为 “对象注入” 或 “属性装配”。

Spring 提供了三种依赖注入方式：

  1. 属性注入（Field Injection）
  2. 构造方法注入（Constructor Injection）
  3. Setter 注入（Setter Injection）
4.1 属性注入

属性注入通过 @Autowired 注解实现，将 Service 类注入到 Controller 类中。

Service 类实现：

import org.springframework.stereotype.Service; @Service public class UserService { public void sayHi() { System.out.println("Hi,UserService"); } }

Controller 类实现：

@Controller public class UserController { // 注入方法1：属性注入 @Autowired private UserService userService; public void sayHi(){ System.out.println("hi,UserController..."); userService.sayHi(); } }

获取并调用 Controller 方法：

@SpringBootApplication public class SpringIocDemoApplication { public static void main(String[] args) { // 获取Spring上下文对象 ApplicationContext context = SpringApplication.run(SpringIocDemoApplication.class, args); // 从Spring上下文中获取对象 UserController userController = (UserController) context.getBean("userController"); // 使用对象 userController.sayHi(); } }

运行结果：

4.2 构造方法注入

构造方法注入是在类的构造方法中实现注入，代码如下：

@Controller public class UserController2 { //注入方法2：构造方法 private UserService userService; @Autowired public UserController2(UserService userService) { this.userService = userService; } public void sayHi(){ System.out.println("hi,UserController2..."); userService.sayHi(); } }

注意事项：

  • 如果类只有一个构造方法，@Autowired 注解可以省略；
  • 如果类中有多个构造方法，需要添加 @Autowired 来明确指定使用哪个构造方法。

4.3 Setter 注入

Setter 注入通过类的 Setter 方法实现，需在 set 方法上添加 @Autowired 注解，代码如下：

@Controller public class UserController3 { //注入方法3：Setter方法注入 private UserService userService; @Autowired public void setUserService(UserService userService) { this.userService = userService; } public void sayHi(){ System.out.println("hi,UserController3..."); userService.sayHi(); } }

练习思考：尝试一下 set 方法如果不加 @Autowired 注解能注入成功吗？

4.4 三种注入优缺点分析

属性注入
  • 优点：简洁，使用方便；
  • 缺点:
    • 只能用于 IoC 容器，如果是非 IoC 容器不可用，并且只有在使用的时候才会出现 NPE（空指针异常）
    • 不能注入一个 Final 修饰的属性
构造函数注入 (Spring 4.X 推荐)
  • 优点:
    • 可以注入 final 修饰的属性
    • 注入的对象不会被修改
    • 依赖对象在使用前一定会被完全初始化，因为依赖是在类的构造方法中执行的，而构造方法是在类加载阶段就会执行的方法.
    • 通用性好，构造方法是 JDK 支持的，所以更换任何框架，他都是适用的
  • 缺点:
    • 注入多个对象时，代码会比较繁琐
Setter 注入 (Spring 3.X 推荐)
  • 优点：方便在类实例化之后，重新对该对象进行配置或者注入
  • 缺点:
    • 不能注入一个 Final 修饰的属性
    • 注入对象可能会被改变，因为 setter 方法可能会被多次调用，就有被修改的风险.

4.5 @Autowired 存在问题

当同一类型存在多个 bean 时，使用 @Autowired 会存在问题

@Component public class BeanConfig { @Bean("u1") public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; } @Bean public User user2() { User user = new User(); user.setName("lisi"); user.setAge(19); return user; } } 
@Controller public class UserController { @Autowired private UserService userService; //注入user @Autowired private User user; public void sayHi(){ System.out.println("hi,UserController..."); userService.sayHi(); System.out.println(user); } }

运行结果:

报错的原因是，非唯一的 Bean 对象。

解决方案

Spring 提供了以下几种解决方案：

  • @Primary
  • @Qualifier
  • @Resource
1. 使用 @Primary 注解

当存在多个相同类型的 Bean 注入时，加上 @Primary 注解，来确定默认的实现。

@Component public class BeanConfig { @Primary //指定该bean为默认bean的实现 @Bean("u1") public User user1(){ User user = new User(); user.setName("zhangsan"); user.setAge(18); return user; } @Bean public User user2() { User user = new User(); user.setName("lisi"); user.setAge(19); return user; } }
2. 使用 @Qualifier 注解

指定当前要注入的 bean 对象。在 @Qualifier 的 value 属性中，指定注入的 bean 的名称。

  • @Qualifier 注解不能单独使用，必须配合 @Autowired 使用
@Controller public class UserController { @Qualifier("user2") //指定bean名称 @Autowired private User user; public void sayHi(){ System.out.println("hi,UserController..."); System.out.println(user); } }
3. 使用 @Resource 注解

是按照 bean 的名称进行注入。通过 name 属性指定要注入的 bean 的名称。

@Controller public class UserController { @Resource(name = "user2") private User user; public void sayHi(){ System.out.println("hi,UserController..."); System.out.println(user); } }

常见面试题：@Autowired 与 @Resource 的区别

  • @Autowired 是 Spring 框架提供的注解，而 @Resource 是 JDK 提供的注解
  • @Autowired 默认是按照类型注入，而 @Resource 是按照名称注入。相比于 @Autowired 来说，@Resource 支持更多的参数设置，例如 name 设置，根据名称获取 Bean。

@Autowired 与 @Resource 核心区别

这张图总结了 Spring 中两个依赖注入注解的核心差异，我帮你补充完整并做进一步解读：

1. 来源不同
  • @Autowired：由 Spring 框架 提供（org.springframework.beans.factory.annotation.Autowired），是 Spring 专属的注入注解。
  • @Resource：由 JDK 提供（javax.annotation.Resource，Java EE 标准），不依赖 Spring 框架，可在其他 IoC 容器中使用。
2. 注入规则不同
  • @Autowired：默认 ** 按类型（byType）** 注入。
    • 先根据属性类型在容器中找匹配的 Bean；
    • 若存在多个同类型 Bean，会再按属性名匹配；
    • 需指定名称时，要配合 @Qualifier("beanName") 使用。
  • @Resource：默认 ** 按名称（byName）** 注入。
    • 优先根据 name 属性或属性名匹配 Bean；
    • 若名称匹配不到，才会降级为按类型匹配；
    • 原生支持 name 参数，可直接指定要注入的 Bean 名称，无需额外注解。
3. 功能与参数对比
特性@Autowired@Resource
来源Spring 框架JDK (Java EE)
默认注入方式按类型 (byType)按名称 (byName)
指定名称需配合 @Qualifier直接用 name 属性
支持参数仅 requiredname, type, lookup 等
兼容性仅 Spring 容器通用，兼容所有支持 Java EE 的容器
4. 典型使用场景

@Resource：适合多实例场景，可直接指定名称获取目标 Bean，避免类型匹配歧义。

// 直接指定注入名为 userService1 的 Bean @Resource(name = "userService1") private UserService userService;

@Autowired：适合单类型 Bean 场景，代码更简洁，Spring 生态中最常用。

@Autowired private UserService userService;

💡 补充说明

  • 在 Spring 4.3+ 后，构造方法注入成为官方推荐，@Autowired 可省略，此时 @Resource 的优势主要体现在精确按名匹配上。
  • @Resource 属于 Java EE 规范，在高版本 JDK 中需要手动引入 jakarta.annotation-api 依赖才能使用。
  • 若项目仅使用 Spring 生态，推荐优先用 @Autowired + @Qualifier；若需跨容器兼容，可考虑 @Resource。

Read more

MySQL 数据类型核心指南：选型、实战与避坑

MySQL 数据类型核心指南：选型、实战与避坑

🔥草莓熊Lotso：个人主页 ❄️个人专栏: 《C++知识分享》《Linux 入门到实践：零基础也能懂》 ✨生活是默默的坚持，毅力是永久的享受！ 🎬 博主简介： 文章目录 * 前言： * 一. MySQL 数据类型分类总览 * 二. 数值类型：精准匹配数字范围与精度 * 2.1 整数类型（BIT/TINYINT/INT/BIGINT） * 2.1.1 TINYINT 类型测试 * 2.1.2 BIT 类型测试 * 2.1.3 INT/BIGINT 对比测试 * 2.2 小数类型（FLOAT/DOUBLE/DECIMAL） * 2.2.

By Ne0inhk
Flutter 组件 analyzer_testing 适配鸿蒙 HarmonyOS 实战：分析器插件测试，构建 AST 仿真与编译器级别静态诊断验证架构

Flutter 组件 analyzer_testing 适配鸿蒙 HarmonyOS 实战：分析器插件测试，构建 AST 仿真与编译器级别静态诊断验证架构

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net Flutter 组件 analyzer_testing 适配鸿蒙 HarmonyOS 实战：分析器插件测试，构建 AST 仿真与编译器级别静态诊断验证架构 前言 在鸿蒙（OpenHarmony）生态迈向深度定制化研发、涉及高性能自定义 Lint 规则集开发、代码自动化重构工具链及严苛的编译器插件质量底线的背景下，如何实现一套能够精确模拟抽象语法树（AST）、支持在无文件系统环境下执行实时代码分析且具备“像素级”错误定位能力的“分析器测试基座”，已成为决定研发工具链稳定性与代码诊断准确性的命脉。在鸿蒙项目涉及海量 eTS 与 Flutter 代码混合静态检查的复杂场景下，如果开发的分析器插件未经严格的语法全集覆盖测试，由于由于分析引擎的内部状态复杂性，极易由于由于“误报”或“漏报”导致鸿蒙应用在编译期发生难以排查的元数据错误。 我们需要一种能够解耦物理磁盘、支持声明式代码片段输入且具备 AST 结构断言能力的验证方案。 analyzer_testing 为

By Ne0inhk

Node.js完全指南：从入门到精通

一、Node.js基础概念 1.1 什么是Node.js？ Node.js是一个基于Chrome V8引擎的JavaScript运行环境，让JavaScript可以在服务器端运行。它使用事件驱动、非阻塞I/O模型，使其轻量且高效。 1.2 Node.js的历史 * 2009年：Ryan Dahl创建了Node.js * 2010年：NPM（Node Package Manager）诞生 * 2011年：npm 1.0发布 * 2015年：Node.js基金会成立 * 2016年：引入长期支持（LTS）版本 * 至今：持续快速发展，广泛应用于后端开发 1.3 Node.js的特点 * 单线程：使用单线程事件循环，避免线程切换开销

By Ne0inhk
MySQL 内置函数指南：日期、字符串、数学函数实战

MySQL 内置函数指南：日期、字符串、数学函数实战

🔥草莓熊Lotso：个人主页 ❄️个人专栏: 《C++知识分享》《Linux 入门到实践：零基础也能懂》 ✨生活是默默的坚持，毅力是永久的享受！ 🎬 博主简介： 文章目录 * 前言： * 一. 日期函数：处理时间相关需求 * 1.1 核心日期函数表 * 1.2 实战案例 * 1.2.1 基础时间获取 * 1.2.2 日期加减运算 * 1.2.3 日期差计算与时间提取 * 1.2.4 业务场景：查询近期数据 * 二. 字符串函数：处理文本数据 * 2.1 核心字符串函数表 * 2.2 实战案例 * 2.2.

By Ne0inhk