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

VsCode远程Copilot无法使用Claude Agent问题

最近我突然发现vscode Copilot中Claude模型突然没了，我刚充的钱啊！没有Claude我还用啥Copilot 很多小伙伴知道要开代理，开完代理后确实Claude会出来，本地使用是没有任何问题的，但是如果使用远程ssh的话，会出现访问异常，连接不上的情况。这时候很多小伙伴就在网上寻找方法，在vscode setting中添加这么一段代码。可以看看这篇博客 "http.proxy": "http://127.0.0.1:1082", "remote.extensionKind": { "GitHub.copilot": [ "ui" ], "GitHub.copilot-chat": [ "ui" ], "pub.name": [ "ui&

By Ne0inhk

一文掌握 Git 分支：本地管理 + 远程协作 + 最佳实践

前言：为什么分支如此重要？ 在现代软件开发中，分支（Branch） 是 Git 最强大的特性之一。想象一下： * 🚀 你可以在不影响主代码的情况下开发新功能 * 🐛 你可以独立修复紧急 Bug * 🧪 你可以安全地尝试实验性想法 * 👥 团队成员可以并行工作而不互相干扰 这一切都归功于 git branch 命令。本文将带你从零开始，全面掌握 Git 分支管理的核心技能。 一、分支的本质：理解 Git 分支模型 在深入命令之前，先理解分支的本质： ┌─────────────────────────────────────────────────┐ │ Git 分支 = 指向提交的轻量级指针 │ │ │ │ main ──→ ● ──→ ● ──→ ● (最新提交) │ │ ↘ │ │ feature ──→ ● ──→ ● (独立开发线) │ └─────────────────────────────────────────────────┘ 关键概念： * 分支只是一个指向特定提交的指针 * 创建分支几乎零成本（只创建指针，不复制文件）

By Ne0inhk
PandaWiki：更轻量的开源知识库，问答效果到底如何？（本地部署教程+效果实测）

PandaWiki：更轻量的开源知识库，问答效果到底如何？（本地部署教程+效果实测）

开源 RAG 项目我之前主要围绕 RAGFlow 写了不少落地案例。RAGFlow 定位是大而全的企业级 RAG 引擎，所以社区里也一直有人吐槽：资源吃得多、处理慢。但这事儿某种程度上就是端到端全包（解析、切分、向量化、检索、权限、工作流、评测）的代价，工程体量上去了，默认就不可能太轻。 如果你想找一款更轻量的开源方案，主要用来处理产品文档、技术文档、FAQ、博客等内容，那可以看看今天要介绍的 PandaWiki。一句话总结：PandaWiki 更像开源版的知识库产品，而不是一个给工程师从零拼装的 RAG 引擎。 这个项目实际我也是近期才注意到，GitHub 目前 8.6K Star，看趋势图下半年热度是一路走高。我花了几天集中测了下，确实有一些可圈可点的地方，这篇就抓大放小，来和各位说道说道。 这篇试图说清楚： PandaWiki 的手把手本地部署过程、

By Ne0inhk