加一句：bean 的名字怎么定#

PPT 第 65 页最后还有一条”注意”：

声明 bean 的时候，可以通过注解的 value 属性指定 bean 的名字，如果没有指定，默认为类名首字母小写。

两种写法对比：

1
@Repository               // 名字默认 = 类名首字母小写：userDaoImpl
2
public class UserDaoImpl implements UserDao { /* …… */ }

1
@Repository("userDao")    // 手动指定名字：userDao（value 属性，括号里直接写字符串）
2
@Component("userServiceA")
3
public class UserServiceImpl implements UserService { /* …… */ }

名字有什么用？——同类型有多个 bean 时，靠名字区分（本篇”DI 详解（二）“的 @Qualifier / @Resource 里写的那个字符串，就是 bean 的名字）。所以这条默认规则必须记牢：

（本机实测里 @Qualifier("userServiceImpl")、@Resource(name = "userServiceImpl2") 能生效，靠的就是它——名字拼错的话，容器会告诉你”没有叫这个名字的 bean”。）

实测：本机把两个同类型 bean 摆在一起，启动直接失败#

1
***************************
2
APPLICATION FAILED TO START
3
***************************
4

5
Description:
6

7
Field userService in com.itheima.controller.UserController required a single bean, but 2 were found:
8
  - userServiceImpl: defined in URL [...]
9
  - userServiceImpl2: defined in URL [...]
10

11
Action:
12

13
Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

1
UnsatisfiedDependencyException: Error creating bean with name 'userController':
2
Unsatisfied dependency expressed through field 'userService':
3
No qualifying bean of type 'com.itheima.service.UserService' available:
4
expected single matching bean but found 2: userServiceImpl,userServiceImpl2

三种解决方案（PPT 第 70 页 + 实测结果）#

PPT 给了三个方案，本机把三个都跑了一遍：

三种写法的代码对照（都改在 UserController / UserServiceImpl 上）：

1
// 方案一：@Primary —— 给"首选的那个"实现类贴个标签
2
@Service
3
@Primary     // UserServiceImpl2 也存在，但优先注入我
4
public class UserServiceImpl implements UserService { /* …… */ }

1
// 方案二：@Qualifier —— 在注入处按名字点名
2
@RestController
3
public class UserController {
4

5
    @Autowired
6
    @Qualifier("userServiceImpl")     // 名字 = 类名首字母小写
7
    private UserService userService;
8
}

1
// 方案三：@Resource —— 换一个注解，直接按名字注入
2
@RestController
3
public class UserController {
4

5
    @Resource(name = "userServiceImpl2")   // 注意包是 jakarta.annotation.Resource
6
    private UserService userService;
7
}

1
注入 userServiceImpl  → curl /list → [{"id":1,...},{"id":2,...}, …]      （原始数据）
2
注入 userServiceImpl2 → curl /list → [{"id":201,...},{"id":202,...}, …]  （加了 200 的那份）

另外，构造器注入与 setter 注入也一样能解决冲突（本机的对照实验）：

一、知识回顾（读完直接做下面的实践题）#

1. 四个 bean 注解：@Component（声明 bean 的基础注解，不属于下面三类时用）、@Controller（控制层）、@Service（业务层）、@Repository（数据访问层，由于与 mybatis 整合，用的少）；后三个都是 @Component 的衍生注解
2. 两条注意：SpringBoot 集成 web 开发中声明控制器 bean 只能用 @Controller（或 @RestController）；声明 bean 的注解要被扫描到才生效
3. bean 名字规则：声明 bean 时可通过注解的 value 属性指定名字（@Repository("userDao")）；没有指定时默认为类名首字母小写（UserServiceImpl → userServiceImpl）
4. 组件扫描与它的实测边界：四大注解要被 @ComponentScan 扫到才生效；它虽然没有显式配置，但实际上已经包含在启动类注解 @SpringBootApplication 中，默认扫描的范围是启动类所在包及其子包——实测把控制器放到包外（com.outside.OutsideController，启动类在 com.itheima）：应用启动正常、日志无报错，但访问那个接口是 404（映射根本没注册）
5. 三种注入方式：属性注入（@Autowired 标在成员变量上）、构造器注入（标在构造方法上，字段常用 private final）、setter 注入（标在 setter 方法上）
6. 三种方式的优缺点：属性注入——代码简洁、方便快速开发，但隐藏了类之间的依赖关系、可能破坏封装性；构造器注入——能清晰看到依赖关系、提高安全性，但代码繁琐、构造参数过多会让构造函数臃肿；setter 注入——保持封装性、依赖关系更清晰，但要额外编写 setter 方法、增加代码量
7. 构造器注入的例外：如果只有一个构造函数，@Autowired 注解可以省略（本机实测：构造器不写 @Autowired 配 @Primary → 启动成功）
8. 同类型多个 bean 的报错：@Autowired 默认按类型注入；两个实现类都交给容器时报 Field userService ... required a single bean, but 2 were found（异常链：No qualifying bean of type ... available: expected single matching bean but found 2: userServiceImpl,userServiceImpl2）
9. 三种解决方案：① 实现类上加 @Primary（实测注入 userServiceImpl）；② @Autowired + @Qualifier("userServiceImpl")（实测注入 userServiceImpl）；③ @Resource(name = "userServiceImpl2")（实测注入 userServiceImpl2）
10. @Resource 与 @Autowired 的区别：@Autowired 是 Spring 框架提供的注解、默认按照类型注入；@Resource 是 JavaEE 规范提供的、默认按照名称注入

二、裸写题#

• 2-1 给三层的类挑”最贴切”的 bean 注解 一个三层架构的工程里，有三个类要交给 IOC 容器管理：

  1. com.itheima.controller.EmpController（控制层，处理请求、响应数据）；
  2. com.itheima.service.impl.EmpServiceImpl（业务层）；
  3. com.itheima.dao.impl.EmpDaoImpl（数据访问层）。

  要求：

  1. 给每个类选最贴切的注解（不是全用同一个）并写在类上；
  2. 说明为什么控制层的类必须用它选的那个注解（提示在 PPT 的”注意事项”里）；
  3. 写出这三个类默认的 bean 名字分别是什么；再写出把数据访问层的 bean 名字显式指定为 empDao 的写法。 （练习文件 test_39_声明Bean的注解.java 里给了三个类的骨架和写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：四个注解里，一个”通用”，另外三个分别对应三层——按类所在的层选；默认名字记”类名首字母变小写” 二级 · 方法：控制层 @Controller（本案例其实用 @RestController）、业务层 @Service、数据访问层 @Repository；指定名字写在注解括号里（value 属性） 三级 · 骨架：@____ / @____ / @____("____")；默认名字 = empController? 注意——bean 名字由类名决定

  参考答案（做完再点开）

  1
  // ① 控制层：SpringBoot 集成 web 开发中，声明控制器 bean 只能用 @Controller
  2
  //   （更常用的是它的组合注解 @RestController = @Controller + @ResponseBody）
  3
  @RestController
  4
  public class EmpController { /* …… */ }

  1
  // ② 业务层
  2
  @Service
  3
  public class EmpServiceImpl implements EmpService { /* …… */ }

  1
  // ③ 数据访问层（顺手把 bean 名字显式指定为 empDao）
  2
  @Repository("empDao")
  3
  public class EmpDaoImpl implements EmpDao { /* …… */ }

  2. 控制器必须用 @Controller（或 @RestController）：在 SpringBoot 集成 web 开发中，声明控制器的 bean 只能用 @Controller——SpringMVC 靠它（以及 @RequestMapping 等）识别请求处理类；换成 @Component / @Service 之类的名字虽然也能被扫描成 bean，但不是”控制器”的规范写法。
  3. 默认 bean 名字（类名首字母小写）：

     类名	默认 bean 名字
     EmpController	empController
     EmpServiceImpl	empServiceImpl
     EmpDaoImpl	empDaoImpl（上面显式指定后是 empDao）

• 2-2 三种依赖注入方式各写一遍 一个控制器 DeptController 需要使用业务对象 DeptService（接口）。请用三种不同的写法完成注入：

  1. 第一种：最简洁的写法（直接标在成员变量上）；
  2. 第二种：把依赖做成构造方法的参数（体现”类必须拿到依赖才能创建”）；
  3. 第三种：通过一个 setter 方法注入；
  4. 每种写法旁边用中文注释写出它的优点和缺点（各一条，按 PPT 的说法）；
  5. 回答一个问题：三种写法里，哪一种可以不写注入注解？前提是什么？ （练习文件 test_39_三种依赖注入方式.java 里按三种写法给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：三种写法的区别只在”依赖从哪个入口进来”——成员变量、构造方法、setter 方法 二级 · 方法：注解都是 @Autowired，只是标的位置不同；构造器写法里字段用 private final；“可以不写注解”的那一种，前提和”类里有几个构造方法”有关 三级 · 骨架：@____ private DeptService deptService; / private final DeptService deptService; + public DeptController(DeptService deptService) { this.deptService = ____; } / public void setDeptService(DeptService deptService) { this.deptService = ____; }

  参考答案（做完再点开）

  1
  // ① 属性注入
  2
  @RestController
  3
  public class DeptController {
  4
      @Autowired
  5
      private DeptService deptService;
  6
      // 优点：代码简洁、方便快速开发
  7
      // 缺点：隐藏了类之间的依赖关系、可能会破坏类的封装性
  8
  }

  1
  // ② 构造器注入
  2
  @RestController
  3
  public class DeptController {
  4
  
  5
      private final DeptService deptService;
  6
  
  7
      @Autowired
  8
      public DeptController(DeptService deptService) {
  9
          this.deptService = deptService;
  10
      }
  11
      // 优点：能清晰地看到类的依赖关系、提高了代码的安全性
  12
      // 缺点：代码繁琐、如果构造参数过多，可能会导致构造函数臃肿
  13
  }

  1
  // ③ setter 注入
  2
  @RestController
  3
  public class DeptController {
  4
  
  5
      private DeptService deptService;
  6
  
  7
      @Autowired
  8
      public void setDeptService(DeptService deptService) {
  9
          this.deptService = deptService;
  10
      }
  11
      // 优点：保持了类的封装性，依赖关系更清晰
  12
      // 缺点：需要额外编写 setter 方法，增加了代码量
  13
  }

  5. 构造器注入可以不写注入注解，前提是类里只有一个构造函数（PPT 原话：如果只有一个构造函数，@Autowired 注解可以省略；本机实测构造器不写 @Autowired 也能启动成功）。

• 2-3 两个同类型的 bean 打起来了，给三个解决方案 工程里有一个业务接口 UserService，现在有两个实现类都被交给了容器：

  1
  @Service
  2
  public class UserServiceImpl implements UserService { /* …… */ }
  3
  
  4
  @Service
  5
  public class UserServiceImpl2 implements UserService { /* …… */ }

  控制层里是这么写的：

  1
  @RestController
  2
  public class UserController {
  3
      @Autowired
  4
      private UserService userService;
  5
      // ……
  6
  }

  启动工程时直接失败。要求：

  1. 从报错里抄出最关键的那一句，并解释它为什么会发生（说清”注入规则 + 有几个候选”）；
  2. 给出三种能让工程正常启动的改法，每种写出改哪里、改什么（三种都要说明”最后注入的是哪一个”）；
  3. 回答：如果不改代码，有没有办法让这两行”和平共处”？（想想”接收多个 bean”这种可能，任答一种即可） （练习文件 test_39_同类型多个Bean的冲突.java 里给了报错原文和三种方案的写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：报错的实质是”要一个、给了俩”；三种改法分别是”指定首选""按名字点名""换一个按名字注入的注解” 二级 · 方法：① 实现类上加 @Primary；② 注入处 @Qualifier("userServiceImpl") 配 @Autowired；③ 注入处 @Resource(name = "userServiceImpl2") 三级 · 骨架：@____ public class UserServiceImpl implements UserService {...} / @____ @____("userServiceImpl") private UserService userService; / @____(name = "____") private UserService userService;

  参考答案（做完再点开）

  1. 最关键的一句（本机实测报错原文）：

     1
     Field userService in com.itheima.controller.UserController required a single bean, but 2 were found:
     2
       - userServiceImpl: defined in URL [...]
     3
       - userServiceImpl2: defined in URL [...]

     原因：@Autowired 默认按照类型注入——它拿着 UserService 这个类型去容器里找，找到了两个候选 bean（userServiceImpl 和 userServiceImpl2），规则是”一个萝卜一个坑”、又不能替开发者做选择，于是启动阶段直接失败。
  2. 三种改法（都实测能启动成功）：

     改法	改哪里	改什么	最终注入
     ① @Primary	实现类上	给 UserServiceImpl 加 @Primary（首选）	userServiceImpl（/list 返回 id 1、2、3…）
     ② @Autowired + @Qualifier	注入处（成员变量上）	@Qualifier("userServiceImpl") 指明 bean 名字	userServiceImpl
     ③ @Resource	注入处	@Resource(name = "userServiceImpl2")（按名称注入）	userServiceImpl2（/list 返回 id 201、202…，因为 2 号实现类把 id 加了 200）

  3. 不改代码也有办法：让”消费者接受多个 bean”——注入时把类型写成 List<UserService>（或在构造器里接收 List<UserService> / Map<String, UserService>），容器会把所有同类型的 bean 都给你，自己按需挑选。另外也可以用 ApplicationContext 按名字主动 getBean("userServiceImpl") 取（本机报错的 Action 里就提到了 “updating the consumer to accept multiple beans” 这种思路）。

     1
     @Autowired
     2
     private List<UserService> userServiceList;          // 拿到两个实现
     3
     // 或者
     4
     @Autowired
     5
     private Map<String, UserService> userServiceMap;    // key 就是 bean 名字

• 2-4 接口为什么又 404 了（扫描范围排查） 小张把一个正常运行的工程改了目录结构：启动类还在 com.itheima（SpringbootWebDemoApplication），但他把控制器挪到了 com.itheima.other 之外的新包 com.outside 里（类名 OutsideController，注解 @RestController + @RequestMapping("/outside") 都写了）。重启后：

  1. 应用启动成功，日志里没有报错；
  2. 访问 http://localhost:8080/outside 是 404。

  请回答：

  1. 为什么启动不报错、接口却 404？（说清容器”发现 bean / 注册映射”的规则）
  2. 给出两种解决办法（一种改代码位置、一种改扫描配置）；
  3. 同类问题的表现还有哪些？（至少写一条别的：比如”注入时报找不到 bean”，并说明原因是一样的） （练习文件 test_39_组件扫描范围排查.java 里给了写作区。）
  提示（先自己想，实在想不出再点开）

  一级 · 思路：注解只负责”打标记”，谁来读这些标记才是关键——找到”负责扫描的那个注解”和它的默认范围 二级 · 方法：@SpringBootApplication 里已包含 @ComponentScan，默认只扫启动类所在包及其子包；要么把类挪回 com.itheima 下面，要么显式加 @ComponentScan({"com.itheima", "com.outside"}) 三级 · 骨架：@SpringBootApplication + @____({"com.itheima","com.outside"})（加在启动类上）

  参考答案（做完再点开）

  1. 因为组件扫描扫不到它：@SpringBootApplication 内部已包含 @ComponentScan，默认扫描的范围是启动类所在包及其子包。com.outside 不是 com.itheima 的子包 → 这个 @RestController 类没有被创建成 bean、@RequestMapping 也没有被注册成映射 → 应用当然能启动（没有 bean 也不算错），访问这个地址就是 404。本机实测（Spring Boot 3.2.8）就是这个结果：

     1
     $ curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/outside
     2
     404

  2. 两种办法：

     1
     // 办法一：把类挪回启动类所在包及其子包（课程规范做法）
     2
     // com.outside.OutsideController  →  com.itheima.controller.OutsideController

     1
     // 办法二：显式配置扫描范围（把包外那个包也加进来）
     2
     @SpringBootApplication
     3
     @ComponentScan({"com.itheima", "com.outside"})   // 覆盖默认范围
     4
     public class SpringbootWebDemoApplication {
     5
         public static void main(String[] args) {
     6
             SpringApplication.run(SpringbootWebDemoApplication.class, args);
     7
         }
     8
     }

  3. 同类表现（根因都一样——类没被扫到，所以没有 bean）：把 UserDaoImpl 放到包外时，UserServiceImpl 里 @Autowired private UserDao userDao; 会在启动阶段报”找不到类型为 UserDao 的 bean”（No qualifying bean of type 'com.itheima.dao.UserDao' available 这一类），而不是等到运行时报错——注入发生在启动阶段，所以扫不到 bean 时启动就失败；控制器是”注册映射”，扫不到只是 404，不影响启动。两者的检查顺序都是：先看包的位置，再看注解有没有写、有没有写错位置。

三、综合题#

• 3-1 把”注解 + 注入 + 冲突”三件事在一个工程里全过一遍 在上一篇改造好的”三层 + IOC/DI”工程上继续做，每一步都验证一次 /list：

  1. 把四个 bean 注解归位：控制层用 @RestController、业务层用 @Service、数据访问层用 @Repository，并在注释里写出它们的默认 bean 名字；顺手把数据访问层的 bean 名字显式改成 userDaoImpl（value 属性）；
  2. 把业务层实现类的注释改成 @Service("userServiceA")（显式命名），观察工程能否正常启动、/list 是否照旧；
  3. 把控制层的注入方式依次换成三种（属性注入 → 构造器注入 → setter 注入），每换一种都重启验证一次；构造器注入那次把 @Autowired 去掉，确认仍能启动；
  4. 制造冲突：新建第二个实现类（实现同一个接口，把 id 都加 200，也交给容器），重启 → 把启动失败的报错关键句抄下来；
  5. 用三种方案分别解决冲突（@Primary / @Qualifier / @Resource），每次都用 curl -s http://localhost:8080/list 的 id 是 1 开头还是 201 开头判断究竟注入了哪一个，把三次结果记到练习文件里；
  6. 扫描范围实验：把控制器临时挪到一个启动类包之外的包，重启 → 记录状态码；再挪回来（或者给启动类加 @ComponentScan 显式指定范围），确认恢复 200；
  7. 收尾：把工程恢复到”能跑、注解最规范”的那一版，并写下三条”以后遇到 bean 相关报错先查什么”的清单。 （练习文件 test_39_综合_注解注入与冲突处理.java 里按这 7 步给了写作区。）

  涉及知识点

  知识点	在这里的应用
  四大注解	@RestController（控制层）、@Service（业务层）、@Repository（数据访问层）、@Component（通用）
  bean 名字	默认类名首字母小写；用注解的 value 属性显式指定（@Service("userServiceA")）
  组件扫描	@SpringBootApplication 内含 @ComponentScan，默认只扫启动类包及其子包
  三种注入方式	属性注入 / 构造器注入（单构造方法可省注解）/ setter 注入
  按类型 vs 按名称	@Autowired 按类型；@Resource 按名称；@Qualifier 给按类型加一个”按名字”的限定
  冲突排查	required a single bean, but 2 were found → 用数据（id 是否 +200）判断实际注入了谁

  提示（先自己想，实在想不出再点开）

  一级 · 思路：注解决定”哪些对象进容器、叫什么名字”，注入注解决定”从容器里拿哪一个”；冲突的本质是”类型相同、名字不同，容器不敢替你选” 二级 · 方法：按层换注解（@RestController / @Service / @Repository）；注入方式就是 @Autowired 换三个位置（成员变量 / 构造方法 / setter）；冲突三招 @Primary / @Qualifier("名字") / @Resource(name = "名字")；扫描范围检查”包在不在启动类下面” 三级 · 骨架：@____("userServiceA") / @____(name = "____") / 报错关键词 = required a single bean, but 2 were found

  参考答案（做完再点开）

  3-1 七步结果：

  1. 注解归位 + 默认名字：

     1
     @RestController  public class UserController { }     // 默认 bean 名 userController
     2
     @Service         public class UserServiceImpl implements UserService { }   // userServiceImpl
     3
     @Repository("userDaoImpl") public class UserDaoImpl implements UserDao { } // 显式写成了 userDaoImpl（默认本来是 userDaoImpl，这里等于写全）

  2. 改成 @Service("userServiceA") 后：启动正常、/list 照旧——因为注入处还是按类型找（@Autowired private UserService userService;），容器里只有一个 UserService 类型的 bean，名字叫什么不影响。
  3. 三种注入方式（每次重启验证 /list 都是 200 + application/json）：

     1
     // 属性注入
     2
     @Autowired private UserService userService;
     3
     // 构造器注入（只有一个构造方法 → @Autowired 可以省略）
     4
     private final UserService userService;
     5
     public UserController(UserService userService) { this.userService = userService; }
     6
     // setter 注入
     7
     @Autowired public void setUserService(UserService userService) { this.userService = userService; }

  4. 冲突报错关键句（本机实测原文）：

     1
     Field userService in com.itheima.controller.UserController required a single bean, but 2 were found:
     2
       - userServiceImpl: defined in URL [...]
     3
       - userServiceImpl2: defined in URL [...]

     异常链补充：No qualifying bean of type 'com.itheima.service.UserService' available: expected single matching bean but found 2: userServiceImpl,userServiceImpl2
  5. 三种方案的实测结果：

     方案	写法	/list 返回的 id	说明
     @Primary	UserServiceImpl 类上加 @Primary	1、2、3…	注入了 1 号实现
     @Qualifier	@Qualifier("userServiceImpl") + @Autowired	1、2、3…	按名字点名 1 号实现
     @Resource	@Resource(name = "userServiceImpl2")	201、202…	按名字点名 2 号实现（它把 id 加了 200）

  6. 扫描范围实验：控制器挪到包外 → curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/outside 得到 404（应用能启动）；挪回来或给启动类加 @ComponentScan({"com.itheima","com.outside"}) 后恢复 200。
  7. “遇到 bean 相关报错先查什么”清单（三条）： ① 先看包的位置——类是不是在启动类所在包及其子包里（扫不到 → 404 或”找不到 bean”）； ② 再看注解——实现类上有没有 @Component/@Service/@Repository（别加在接口上），注入处有没有 @Autowired（别写在方法体里的局部变量上）； ③ 最后看有没有冲突——同类型是不是有多个 bean（required a single bean, but 2 were found），是的话用 @Primary / @Qualifier / @Resource 指定，并用”数据特征”（比如 id 有没有 +200）确认实际注入了哪一个。