@Autowired和@Resource的区别

一、先明确：为什么考察这两个注解的区别？

你是否能区分两者的核心注入逻辑（按类型 vs 按名称），理解底层查找 Bean 的规则？

能否知道两者的来源、特性差异，避免在跨环境（如非 Spring 容器）使用时踩坑？

能否处理 "多个同类型 Bean" 的注入场景，体现实战能力？

能否说出注入的最佳实践（如构造器注入优先），体现对 Spring 规范的理解？

二、先铺垫：通俗认知

用 "找员工" 的场景类比，快速理解核心差异：

@Autowired = 「按岗位类型找人」：比如公司要找 "Java 开发" 岗位的人，不管名字是张三、李四，只要是这个岗位的就选（如果有多个 Java 开发，会报错）；
@Resource = 「先按名字找人，找不到再按岗位类型」：比如先找名字叫 "zhangSan" 的员工，找不到再找 "Java 开发" 岗位的员工（如果名字和类型都匹配不上才报错）。

简单说：

@Autowired核心是按类型（Type）注入，默认要求注入的 Bean 必须存在；
@Resource核心是按名称（Name）注入，名称匹配失败后降级为按类型注入，更灵活。

三、核心前提：Bean 的 "名称" 与 "类型"

在拆解区别前，先明确 Spring 中 Bean 的两个核心标识（理解这一点是关键）：

「Bean 类型」：Bean 的实际类类型（如UserService、OrderService），接口的实现类也属于接口类型；
「Bean 名称」：默认是类名首字母小写（如UserServiceImpl → userServiceImpl），也可通过@Component("customName")自定义名称。

四、核心区别：@Autowired vs @Resource

以下是最全面的区别拆解：

对比维度	@Autowired	@Resource
注解来源	Spring 框架自带注解（`org.springframework.beans.factory.annotation`）	JDK 原生注解（`javax.annotation.Resource`，JDK9 + 需手动引入依赖）
核心注入规则	优先按类型（Type）查找 Bean	优先按名称（Name）查找 Bean，名称匹配失败则按类型查找
指定注入目标的方式	需配合`@Qualifier("beanName")`指定 Bean 名称；或`@Primary`指定优先 Bean	直接通过`name`属性指定 Bean 名称（`@Resource(name="beanName")`），或`type`属性指定类型
是否支持 required 属性	支持（`@Autowired(required=false)`），设置为 false 时，Bean 不存在也不报错	不支持 required，但可通过`lookup`属性间接实现（极少用）
支持的注入位置	字段、构造器、方法（setter / 普通方法）、参数	字段、方法（setter / 普通方法），不支持构造器和参数注入
多实现类场景处理	直接注入会报`NoUniqueBeanDefinitionException`，必须配合`@Qualifier`/`@Primary`	可通过`name`属性指定具体 Bean 名称，无需额外注解
依赖查找范围	默认查找所有 Spring 容器中的 Bean	可通过`lookup`属性指定查找范围（如应用上下文、父容器）
兼容性	仅适用于 Spring/Spring Boot 环境	通用注解，可用于其他支持 JSR-250 规范的容器（如 J2EE）

代码示例 1：基础注入（单 Bean 场景）

复制代码

// 1. 定义Bean：UserService接口+实现类
public interface UserService {
    void sayHello();
}

@Service // 默认Bean名称：userServiceImpl
public class UserServiceImpl implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello UserService");
    }
}

// 2. 注入Bean的类
@Service
public class OrderService {
    // -------------------- @Autowired注入（按类型） --------------------
    @Autowired // 按UserService类型查找，找到UserServiceImpl，注入成功
    private UserService userService1;

    // -------------------- @Resource注入（先按名，再按类型） --------------------
    @Resource // 先按字段名"userService2"找Bean，找不到→按UserService类型找，注入成功
    private UserService userService2;

    @Resource(name = "userServiceImpl") // 直接按名称找，精准注入
    private UserService userService3;

    public void test() {
        userService1.sayHello();
        userService2.sayHello();
        userService3.sayHello();
    }
}

代码示例 2：多 Bean 场景（核心考点）

当一个接口有多个实现类时，两者的处理方式差异最明显：

复制代码

// 1. 定义多个实现类
@Service("userServiceV1") // 自定义Bean名称
public class UserServiceV1 implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello UserServiceV1");
    }
}

@Service("userServiceV2")
public class UserServiceV2 implements UserService {
    @Override
    public void sayHello() {
        System.out.println("Hello UserServiceV2");
    }
}

// 2. 注入测试
@Service
public class OrderService {
    // -------------------- @Autowired注入（多Bean场景） --------------------
    // 错误写法：直接注入会报NoUniqueBeanDefinitionException
    // @Autowired
    // private UserService userService;

    // 正确写法1：配合@Qualifier指定Bean名称
    @Autowired
    @Qualifier("userServiceV1") // 指定名称，精准注入
    private UserService userService1;

    // 正确写法2：配合@Primary（在其中一个实现类上标注@Primary）
    @Autowired
    private UserService userService2; // 注入标注@Primary的实现类

    // -------------------- @Resource注入（多Bean场景） --------------------
    // 正确写法：直接通过name指定，无需额外注解
    @Resource(name = "userServiceV2")
    private UserService userService3;

    public void test() {
        userService1.sayHello(); // 输出：Hello UserServiceV1
        userService3.sayHello(); // 输出：Hello UserServiceV2
    }
}

// 给UserServiceV1添加@Primary，让@Autowired默认注入它
@Service("userServiceV1")
@Primary
public class UserServiceV1 implements UserService { ... }

代码示例 3：required 属性（@Autowired 专属）

复制代码

@Service
public class OrderService {
    // required=false：即使Bean不存在，也不会报错，注入null
    @Autowired(required = false)
    private UserService userService;

    public void test() {
        if (userService != null) {
            userService.sayHello();
        } else {
            System.out.println("UserService Bean不存在");
        }
    }
}

代码示例 4：注入位置差异

复制代码

@Service
public class OrderService {
    // 1. @Autowired支持构造器注入（推荐的最佳实践）
    private final UserService userService;

    @Autowired // 构造器注入，Spring 4.3+可省略@Autowired（只有一个构造器时）
    public OrderService(UserService userService) {
        this.userService = userService;
    }

    // 2. @Resource不支持构造器注入（编译报错）
    // @Resource
    // public OrderService(UserService userService) {
    //     this.userService = userService;
    // }

    // 3. 两者都支持setter方法注入
    private UserService userService2;

    @Autowired
    public void setUserService2(UserService userService2) {
        this.userService2 = userService2;
    }

    private UserService userService3;

    @Resource(name = "userServiceV1")
    public void setUserService3(UserService userService3) {
        this.userService3 = userService3;
    }
}

五、核心异常场景与解决方案

异常 1：NoUniqueBeanDefinitionException（多 Bean 注入失败）

触发场景：@Autowired注入时，接口有多个实现类，未指定具体 Bean；
解决方案：
1. 用@Qualifier("beanName")指定 Bean 名称；
2. 用@Primary标注优先注入的实现类；
3. 改用@Resource(name="beanName")精准注入。

异常 2：NoSuchBeanDefinitionException（Bean 不存在）

触发场景：@Autowired(required=true)（默认）注入不存在的 Bean；
解决方案：
1. 检查 Bean 是否被 Spring 扫描（是否加@Service/@Component，扫描路径是否正确）；
2. 设置@Autowired(required=false)，避免报错；
3. 确认 Bean 名称 / 类型是否匹配。

异常 3：JDK9 + 中 @Resource 找不到

触发场景：JDK9 及以上版本使用@Resource，提示 "找不到注解"；
解决方案：手动引入依赖（Maven）：
<dependency> <groupId>jakarta.annotation</groupId> <artifactId>jakarta.annotation-api</artifactId> <version>2.1.1</version> </dependency>

六、最佳实践

1. 注入方式优先级（Spring 官方推荐）

构造器注入 > Setter注入 > 字段注入

构造器注入：强制依赖（Bean 创建时必须注入），避免空指针，支持不可变对象（final 字段）；
字段注入：简洁但耦合度高，无法实现不可变对象，单元测试需用反射注入；
Setter 注入：适合可选依赖（可通过 setter 动态修改）。

2. 注解选择原则

简单场景（单 Bean）：两者均可，优先@Autowired（Spring 生态更适配）；
多 Bean 场景：优先@Resource(name="beanName")（无需额外注解，更简洁）；
跨容器场景（非纯 Spring）：用@Resource（通用性更好）；
可选依赖场景：用@Autowired(required=false)（@Resource无此特性）；
构造器注入场景：只能用@Autowired（@Resource不支持）。

3. 避免的不良习惯

不要滥用字段注入：尤其是核心依赖，优先用构造器注入；
不要在多 Bean 场景下直接用@Autowired：必须配合@Qualifier/@Primary；
不要依赖@Resource的 "按类型降级"：多 Bean 场景下明确指定name，避免隐式错误。

加分项

结合最佳实践："我知道 Spring 官方推荐构造器注入，因为它能保证依赖不可变，避免空指针；我在项目中核心依赖用构造器注入，可选依赖用 Setter+@Autowired (required=false)"；
理解底层逻辑："@Autowired 是按类型查找 Bean，底层用 BeanFactory 的 getBean (Class<T>) 方法；@Resource 先按名称查找，用 getBean (String name)，找不到再用 getBean (Class<T>)"；
处理异常场景："遇到过多 Bean 注入报错的问题，我会用 @Resource (name) 精准指定，比 @Autowired+@Qualifier 更简洁"；
关注版本兼容："知道 JDK9 + 中 @Resource 需要手动引入依赖，避免编译报错"。

踩坑点

死记区别，不懂场景：只能说出 "按类型 vs 按名称"，但不知道多 Bean 场景该选哪个；
滥用字段注入：所有依赖都用字段注入，不知道构造器注入的优势；
忽略 required 属性：默认用 @Autowired 注入可选依赖，导致 Bean 不存在时报错；
混淆注入位置：试图用 @Resource 注入构造器参数，导致编译报错；
依赖 @Resource 的降级逻辑：多 Bean 场景下不指定 name，依赖 "按类型降级"，导致注入错误的 Bean。

举一反三

"Spring 4.3 + 为什么可以省略构造器上的 @Autowired？"（答案：Spring 会自动注入只有一个构造器的 Bean，无需显式标注 @Autowired；多个构造器时仍需标注）；
"@Primary 和 @Qualifier 的区别是什么？分别适用于什么场景？"（答案：① @Primary：标注在 Bean 上，指定 "默认优先注入" 的 Bean，适用于 "大多数场景用这个 Bean，少数场景指定其他"；② @Qualifier：标注在注入点，精准指定 Bean 名称，适用于 "明确指定某个 Bean"；③ 优先级：@Qualifier > @Primary）；
"字段注入和构造器注入的优缺点分别是什么？为什么官方推荐构造器注入？"（答案：① 字段注入：优点是简洁，缺点是耦合高、无法实现 final 字段、单元测试困难；② 构造器注入：优点是强制依赖、支持 final、耦合低、单元测试易模拟，缺点是代码稍多；③ 官方推荐原因：构造器注入能保证 Bean 创建时依赖已初始化，避免空指针，符合 "不可变" 设计原则）；
"如果一个 Bean 既没有标注 @Autowired 也没有 @Resource，Spring 会注入吗？"（答案：不会，Spring 的依赖注入是 "显式" 的，必须通过注解 / XML 配置指定，除非是构造器注入且只有一个构造器（Spring 4.3+））；
"@Autowired 的注入时机是什么？和 @Resource 有区别吗？"（答案：① 两者默认都是 "初始化阶段" 注入（Bean 创建后填充属性）；② 区别：@Autowired 支持 @Lazy 懒加载，@Resource 不支持；懒加载时，Bean 会在第一次使用时才注入）。

总结

@Autowired是 Spring 注解，核心按类型注入，支持构造器 / 参数注入、required属性，多 Bean 场景需配合@Qualifier/@Primary；
@Resource是 JDK 注解，核心按名称注入（降级按类型），不支持构造器注入，多 Bean 场景指定name更简洁，跨容器兼容性更好；
实际开发中优先按 "构造器注入> Setter 注入 > 字段注入" 选择，多 Bean 场景用@Resource(name)，可选依赖用@Autowired(required=false)。