Java中@Autowired注解用法及说明

目录

• 1. 核心概念：它是什么？
• 2. 为什么要用它？（依赖注入的优势）
• 3. 如何使用它？
• a. 用在字段上（最常见）
• b. 用在构造器上（推荐方式）
• c. 用在 Setter 方法上
• 4. 装配机制（Spring 如何找到要注入的 Bean？）
• 5. 可能遇到的问题及解决方案
• a. 找不到 Bean（NoSuchBeanDefinitionException）
• b. 找到多个 Bean（NoUniqueBeanDefinitionException）
• c. 非必须的依赖（required=false）
• 总结

1. 核心概念：它是什么？

@Autowired 是 Spring 框架 提供的一个核心注解，用于实现 依赖注入。

它的核心思想是：你不负责创建（new）你所需要的对象，而是由 Spring 容器（IoC 容器）自动“装配”给你。

简单来说，就是“我要什么，你（Spring）就给我什么”。

2. 为什么要用它？（依赖注入的优势）

在没有依赖注入的时代，对象pythonA如果需要使用对象B，它需要自己 new B()。这带来了紧耦合的问题：

public class OrderService {
    // OrderService 自己创建了 PaymentProcessor，紧耦合
    private PaymentProcessor processor = new PaymentProcessor();

    public void processOrder() {
        processor.charge();
    }
}

使用 @Autowired 后，代码变为：

public class OrderService {
    // OrderService 声明它需要一个 Payhttp://www.devze.commentProcessor，由 Spring 提供
    @Autowired
    private PaymentProcessor processor;

    public void processOrder() {
        processor.charge();
    }
}

这样做的好处：

• 解耦：OrderService 不再关心 PaymentProcessor 是如何创建的。
• 易于测试：在测试时，你可以轻松地注入一个模拟的 PaymentProcessor，而不是真实的那个。
• 可维护性：如果你想更换 PaymentProcessor 的实现，只需要修改 Spring 的配置（如 @Component 注解），而不需要修改 OrderService 的代码。
• 单一职责：每个类专注于自己的业务逻辑，而不是对象的创建和www.devze.com查找。

3. 如何使用它？

@Autowired 可以用在以下几个地方：

a. 用在字段上（最常见）

这是最简洁的方式，直接注入到字段，不需要 setter 方法。

@Service
public class OrderService {

    @Autowired
    private PaymentProcessor paymentProcessor;
    @Autowired
    private EmailService emailService;

    // ... 业务方法
}

b. 用在构造器上（推荐方式）

Spring 官方推荐的方式。它明确地声明了创建对象所必需的依赖，并且可以保证这些依赖在对象初始化时就被设置好，避免了 NullPointerException。

@Service
public class OrderService {

    private final PaymentProcessor paymentProcessor;
    private final EmailService emailService;

    // 构造器注入
    @Autowired
    public OrderService(PaymentProcessor paymentProcessor, EmailService emailService) {
        this.paymentProcessor = paymentProcessor;
        this.emailService = emailService;
    }

    // ... 业务方法
}

注意：在 Spring 4.3 及以后，如果类中只有一个构造器，那么 @Autowired 注解可以省略。

c. 用在 Setter 方法上

类似于字段注入，但提供了在注入后执行一些额外逻辑的机会。

@Service
public class OrderService {

    private PaymentProcessor paymentProcessor;

    // Setter 注入
    @Autowired
    public void setPaymentProcessor(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
        // 可以在这里加入一些初始化逻辑
    }
}

4. 装配机制（Spring 如何找到要注入的 Bean？）

Spring 会按照以下优先级在它的 IoC 容器 中查找匹配的 Bean：

1. 按类型（ByType）：这是首选方式。Spring 会寻找与字段/方法参数类型完全匹配的 Bean。

   • 例如：@Autowired private PaymentProcessor processor; Spring 会寻找类型为 PaymentProcessor 的 Bean。

2. 按名称（ByName）（如果按类型有歧义）：

   • 如果容器中有多个相同类型的 Bean（例如，PaymentProcessor 有两个实现类：CreditCardProcessor 和 PayPalProcessor），按类型注入就会失败。
   • 此时，Spring 会退而求其次，尝试使用字段名或参数名作为 Bean 的 ID 来查找。
   • 例如：@Autowired private PaymentProcessor creditCardProcessor; Spring 会寻找 ID 为 creditCardProcessor 的 Bean。

3. 使用 @Qualifier 注解（解决歧义的终极武器）：

   • 当按名称也无法满足，或者你想明确指定时，可以配合 @Qualifier 使用。
   • 你在实现类上使用 @Qualifier 给它起一个“限定符”名字。

   @Component
   @Qualifier("creditCard")
   public class CreditCardProcessor implements PaymentProcessor { ... }
   
   @Component
   @Qualifier("paypal")
   public class PayPalProcessor implements PaymentProcessor { ... }
   

   • 在注入点时，使用 @Qualifier 指定要注入哪一个。

   @Autowired
   @Qualifier("creditCard") // 明确指定要注入标有 "creditCard" 的 Bean
   private PaymentProcessor processor;
   

5. 可能遇到的问题及解决方案

a. 找不到 Bean（NoSuchBeanDefinitionException）

原因：Spring 容器中没有与你 @Autowired 字段/参数类型匹配的 Bean。

解决：

• 确保目标类（如 PaymentProcessor 的实现类）已经被 Spring 管理（即标注了 @Component, @Service, @Repository 等注解）。
• 确保组件扫描（@ComponentScan）的路径正确，能够扫描到这些类。

b. 找到多个 Bean（NoUniqueBeanDefinitionException）

原因：有多个相同类型的 Bean 存在于容器中。

解决：

使用 @Qualifier 注解明确指定一个（如上文所示）。

将其中一个候选 Bean 标记为 @Primary，这样当有多个同类型 Bean 时，会优先选择它。

@Component
@Primary // 优先选择这个
public class CreditCardProcessor implements PaymentProcessor { ... }

c. 非必须的依赖（required=false）

默认情况下，@Autowired 要求依赖是必须的。如果找不到，应用会启动失败。

你可以将其设置为 false，这样即使找不到，Spring 也会继续启动，但该字段可能为 null。

@Autowired(required = false)
private OptionalDependency optionalDependency; // 可能为 null，使用时要小心

注意：

更现代和安全的做法编程客栈是使用 Jhttp://www.devze.comava 8 的 Optional 或 构造器注入 来明确处理可为空的依赖。

总结

@Autowired 是 Spring 生态的基石之一，理解它对于掌握 Spring 开发至关重要。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程客栈(www.devze.com)。