如果一个接口有多个实现类，@Autowired 时会发生什么？如何解决？

当一个接口有多个实现类，并且都注册为 Spring Bean 时，直接使用 @Autowired 注入该接口类型，Spring 会“感到困惑”。

会发生什么？

Spring 在进行依赖注入时，首先会按类型查找。它会发现有多个 Bean（EmailNotificationService 和 SmsNotificationService）都匹配 NotificationService 这个类型。

此时，Spring 不知道该注入哪一个，于是会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException

这个异常信息非常直白：“找到了多个符合条件的 Bean，但我不知道你要哪一个”。

让我们用一个具体的例子来说明：

// 1. 接口
public interface NotificationService {
    void send(String message);
}

// 2. 实现类 A
@Service
public class EmailNotificationService implements NotificationService {
    @Override
    public void send(String message) {
        System.out.println("通过邮件发送通知: " + message);
    }
}

// 3. 实现类 B
@Service
public class SmsNotificationService implements NotificationService {
    @Override
    public void send(String message) {
        System.out.println("通过短信发送通知: " + message);
    }
}

// 4. 使用者 (会出错!)
@Service
public class OrderService {
    @Autowired
    private NotificationService notificationService; // Spring: ??? 该注入 Email 还是 SMS?

    public void placeOrder() {
        // ...下单逻辑...
        notificationService.send("您的订单已创建！");
    }
}

在启动时，Spring 容器会因为无法为 OrderService 找到一个唯一的 NotificationService Bean 而失败。

如何解决？

有多种优雅的方式可以解决这个问题，具体取决于你的业务意图。

解决方案 1：使用 @Primary - 指定一个首选的实现

如果你希望在大多数情况下都使用某一个特定的实现（比如，邮件是默认的通知方式），你可以将它标记为 首选（Primary）。

@Service
@Primary // <-- 加上这个注解
public class EmailNotificationService implements NotificationService {
    // ...
}

工作原理：当 Spring 发现有多个候选 Bean 时，它会优先选择被 @Primary 注解的那个。这样，OrderService 中的 @Autowired 就会成功注入 EmailNotificationService 的实例。

优点：简单明了，消费者（OrderService）的代码无需任何改动。
适用场景：当多个实现中有一个是“默认”或“主要”选项时。

解决方案 2：使用 @Qualifier - 精准指定要注入的 Bean

如果你想在注入点明确指定使用哪一个实现，可以使用 @Qualifier 注解。这就像是按“名字”来查找。

首先，你需要知道 Bean 的名字。默认情况下，Spring Bean 的名字是其类名的小驼峰形式（e.g., EmailNotificationService 的 Bean 名是 emailNotificationService）。

// 使用者
@Service
public class OrderService {
    
    private final NotificationService notificationService;

    // 在构造函数或字段上使用 @Qualifier
    @Autowired
    public OrderService(@Qualifier("smsNotificationService") NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void placeOrder() {
        // ...下单逻辑...
        notificationService.send("您的订单已创建！"); // 这里会使用短信服务
    }
}

你也可以在实现类上用 @Qualifier 自定义一个名字，然后在注入点使用它：

@Service
@Qualifier("emailNotifier") // 自定义一个名字
public class EmailNotificationService implements NotificationService { ... }

// 注入时使用自定义的名字
@Autowired
@Qualifier("emailNotifier")
private NotificationService notificationService;

优点：非常精确，控制权在消费者手中，可以灵活选择任意一个实现。
适用场景：当消费者需要一个特定的、非默认的实现时，或者没有明确的默认实现时。

解决方案 3：注入所有实现类的集合

有时候，你的业务需求可能是“向所有渠道发送通知”。在这种情况下，你可以直接注入一个包含所有 NotificationService 实现的 List 或 Map。

A. 注入 List

@Service
public class NotificationManager {
    
    private final List<NotificationService> notificationServices;

    @Autowired
    public NotificationManager(List<NotificationService> notificationServices) {
        this.notificationServices = notificationServices;
    }

    public void notifyAllChannels(String message) {
        // Spring会自动将所有NotificationService的Bean注入这个List
        for (NotificationService service : notificationServices) {
            service.send(message);
        }
    }
}

// 调用时会输出：
// 通过邮件发送通知: 您的订单已创建！
// 通过短信发送通知: 您的订单已创建！

B. 注入 Map
如果你还想通过 Bean 的名字来获取特定的实现，可以注入一个 Map<String, NotificationService>。

@Service
public class NotificationManager {

    private final Map<String, NotificationService> serviceMap;

    @Autowired
    public NotificationManager(Map<String, NotificationService> serviceMap) {
        this.serviceMap = serviceMap; // key是Bean的名字, value是Bean实例
    }

    public void sendByChannel(String channelName, String message) {
        NotificationService service = serviceMap.get(channelName);
        if (service != null) {
            service.send(message);
        } else {
            System.out.println("未找到渠道: " + channelName);
        }
    }
}

// 调用
// notificationManager.sendByChannel("smsNotificationService", "请注意查收");

优点：非常强大和灵活，是**策略模式（Strategy Pattern）**的完美实现。
适用场景：当你需要执行所有实现，或者需要根据某些条件动态选择一个实现时。

总结与最佳实践

最佳实践建议：

• 优先使用构造函数注入：它能保证依赖在对象创建时就是可用的，并且方便进行单元测试。
• 如果有一个明确的通用实现，使用 @Primary 是最干净的方案。
• 如果不同的消费者需要不同的实现，@Qualifier 是你的不二之选。
• 当你需要构建一个可扩展的系统（比如，未来可能增加 App 推送、微信通知等），注入集合的方式是最高级、最灵活的设计。