@Inject @Qualifier @Named

在依赖注入（DI）中，@Inject、@Qualifier 和 @Named 是用于管理对象创建和绑定的关键注解。以下是它们的用途、依赖配置和代码示例的详细说明：

---

1. 注解的作用

• @Inject：标记需要注入的构造函数、字段或方法（JSR-330 标准）。
• @Qualifier：定义自定义注解，用于解决同一类型多个实现的依赖冲突。
• @Named：基于字符串名称的限定符（@Qualifier 的简化版），直接用于区分实现。

---

2. 依赖配置

Maven (pom.xml) - 使用 javax.inject（传统 Java EE）

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

Maven (pom.xml) - 使用 Jakarta EE

<dependency>
    <groupId>jakarta.inject</groupId>
    <artifactId>jakarta.inject-api</artifactId>
    <version>2.0.1</version>
</dependency>

Gradle (build.gradle.kts) - Kotlin DSL

dependencies {
    // Java EE
    implementation("javax.inject:javax.inject:1")
    // 或 Jakarta EE
    implementation("jakarta.inject:jakarta.inject-api:2.0.1")
}

---

3. 代码示例

场景：多个 Service 实现，需通过名称或限定符区分

步骤 1：定义接口和实现类

public interface Service {
    void execute();
}

// 实现类 1
public class EmailService implements Service {
    @Override
    public void execute() {
        System.out.println("Sending email...");
    }
}

// 实现类 2
public class SmsService implements Service {
    @Override
    public void execute() {
        System.out.println("Sending SMS...");
    }
}

步骤 2：使用 @Named 注解区分实现

import javax.inject.Inject;
import javax.inject.Named;

public class Client {
    private final Service service;

    // 通过名称注入特定实现
    @Inject
    public Client(@Named("email") Service service) {
        this.service = service;
    }

    public void run() {
        service.execute();
    }
}

步骤 3：配置依赖注入框架（以 Dagger 2 为例）

1. 添加 Dagger 依赖：

   <!-- Maven -->
   <dependency>
       <groupId>com.google.dagger</groupId>
       <artifactId>dagger</artifactId>
       <version>2.50</version>
   </dependency>
   <dependency>
       <groupId>com.google.dagger</groupId>
       <artifactId>dagger-compiler</artifactId>
       <version>2.50</version>
       <scope>provided</scope>
   </dependency>
   

   // Gradle
   dependencies {
       implementation("com.google.dagger:dagger:2.50")
       kapt("com.google.dagger:dagger-compiler:2.50")
   }
   

2. 定义模块和绑定：

   import dagger.Module;
   import dagger.Provides;
   import javax.inject.Named;
   
   @Module
   public class AppModule {
       @Provides
       @Named("email")
       Service provideEmailService() {
           return new EmailService();
       }
   
       @Provides
       @Named("sms")
       Service provideSmsService() {
           return new SmsService();
       }
   }
   

3. 创建组件并注入：

   import dagger.Component;
   
   @Component(modules = AppModule.class)
   public interface AppComponent {
       Client getClient();
   }
   
   // 使用
   public class Main {
       public static void main(String[] args) {
           AppComponent component = DaggerAppComponent.create();
           Client client = component.getClient();
           client.run(); // 输出: Sending email...
       }
   }
   

步骤 4：自定义 @Qualifier（替代 @Named）

1. 定义自定义限定符注解：

   import javax.inject.Qualifier;
   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   
   @Qualifier
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Email {}
   
   @Qualifier
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Sms {}
   

2. 在模块中使用自定义限定符：

   @Module
   public class AppModule {
       @Provides
       @Email
       Service provideEmailService() {
           return new EmailService();
       }
   
       @Provides
       @Sms
       Service provideSmsService() {
           return new SmsService();
       }
   }
   

3. 在客户端注入：

   public class Client {
       private final Service service;
   
       @Inject
       public Client(@Email Service service) {
           this.service = service;
       }
   }
   

---

4. 常见问题解决

错误：No qualifying bean of type 'Service'

• 原因：未明确指定使用哪个实现。
• 修复：添加 @Named 或自定义 @Qualifier 注解。

依赖未生效

• 检查：确保依赖注入框架（如 Dagger、Guice、Spring）已正确配置，并生成必要的代码（如 Dagger 需运行 kapt 或 annotationProcessor）。

迁移到 Jakarta EE

• 操作：将 javax.inject 替换为 jakarta.inject，并更新所有导入语句。

---

5. 总结

• @Inject：标记注入点。
• @Named：通过字符串名称区分实现。
• @Qualifier：定义更类型安全的限定符。
• 框架适配：根据使用的 DI 工具（Dagger、Spring、Guice）调整配置。

通过合理使用这些注解，可以优雅地管理复杂的依赖关系。

在依赖注入（DI）框架中，如 Spring 或 Google Guice，@Inject、@Qualifier 和 @Named 是用于控制依赖注入行为的注解。

1. @Inject：

   • @Inject 注解用于标记一个字段、方法或构造函数，表明应该通过依赖注入框架来注入其依赖项。
   • 在 Spring 中，@Inject 是 JSR-330 标准的一部分，它是 @Autowired 的一个替代方案，但两者在功能上是等效的。
   • 使用 @Inject 可以让代码更加标准化，因为它不依赖于 Spring 特定的注解。

2. @Qualifier：

   • @Qualifier 注解用于在存在多个相同类型的 bean 时，帮助 DI 框架区分应该注入哪个具体的 bean。
   • 它通常与自定义注解一起使用，这些自定义注解被标记为 @Qualifier 的元注解。
   • 在 Spring 中，如果你有两个相同类型的 bean，并且你想通过名称或其他标准来区分它们，你可以使用 @Qualifier 注解。

3. @Named：

   • @Named 注解是 JSR-330 标准的一部分，它提供了一种简单的方法来指定应该注入哪个 bean，当存在多个相同类型的 bean 时。
   • 在 Spring 中，@Named 可以作为 @Qualifier 的一个替代方案，用于通过名称来区分 bean。
   • 与 @Qualifier 不同，@Named 本身就是一个注解，而不需要与自定义注解一起使用。

示例

假设你有一个接口 MyService 和两个实现 MyServiceImpl1 和 MyServiceImpl2。

public interface MyService {
    void doSomething();
}

@Service("service1")
public class MyServiceImpl1 implements MyService {
    @Override
    public void doSomething() {
        System.out.println("Doing something in MyServiceImpl1");
    }
}

@Service("service2")
public class MyServiceImpl2 implements MyService {
    @Override
    public void doSomething() {
        System.out.println("Doing something in MyServiceImpl2");
    }
}

在另一个类中，如果你想注入 MyServiceImpl1，你可以这样做：

public class MyClient {

    // 使用 @Inject 和 @Named 来指定要注入的 bean
    @Inject
    @Named("service1")
    private MyService myService;

    public void performAction() {
        myService.doSomething();
    }
}

或者，如果你更喜欢使用 @Qualifier，你可以定义一个自定义注解，并使用它来指定要注入的 bean：

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
public @interface Service1Qualifier {
}

// 在 MyServiceImpl1 上添加 @Service1Qualifier（这通常不是必需的，除非你有特定的逻辑需要这样做）
// 但在注入点使用它：

public class MyClient {

    // 使用 @Inject 和 @Service1Qualifier 来指定要注入的 bean
    @Inject
    @Service1Qualifier
    private MyService myService;

    public void performAction() {
        myService.doSomething();
    }
}

// 你还需要在配置中指定哪个 bean 应该与 @Service1Qualifier 关联，这通常是通过 Java 配置或 XML 配置来完成的。

请注意，在上面的 @Service1Qualifier 示例中，我通常不会在 MyServiceImpl1 上使用 @Service1Qualifier 注解，而是直接在注入点使用它，并通过配置来指定哪个 bean 应该被注入。然而，如果你有一个特定的用例需要在实现类上使用它，那也是可以的。

在 Spring Boot 中，你通常不需要显式地定义 @Qualifier 的自定义实现，因为 @Named 已经提供了足够的功能来通过名称区分 bean。但是，如果你想要更复杂的逻辑或更清晰的代码结构，定义自定义的 @Qualifier 注解可能是有意义的。

在使用依赖注入（Dependency Injection, DI）时，@Inject、@Qualifier 和 @Named 注解用于指定和限定依赖项。它们是 Java 依赖注入规范(JSR-330)和相关框架的一部分。下面是对这些注解的简要介绍以及如何在项目中引入相应的依赖。

@Inject

@Inject 是 JSR-330 标准的一部分，用来标记一个构造器、方法或字段应该通过依赖注入来提供依赖。

@Qualifier

@Qualifier 是一个元注解（即它被用来创建其他注解），用于限定依赖类型，当有多个相同类型的依赖需要注入时，可以使用自定义的限定符注解来区分不同的实现。

@Named

@Named 是 @Qualifier 的一个具体实现，允许你通过名称来限定依赖。它是 Jakarta 或 javax 注入包中的一个标准注解。

Maven/Gradle 引入依赖

对于 Gradle Kotlin DSL (build.gradle.kts) 或 Groovy 版本 (build.gradle) 的构建脚本，根据你需要的版本选择合适的依赖：

• Jakarta EE (2.0.1 或更新版本)

// build.gradle.kts
dependencies {
    implementation("jakarta.inject:jakarta.inject-api:2.0.1") // 确保选择适合你的最新版本
}

或者 Groovy 版本:

// build.gradle
dependencies {
    implementation 'jakarta.inject:jakarta.inject-api:2.0.1' // 确保选择适合你的最新版本
}

• javax (适用于旧版本)

如果你必须使用旧版本的 javax 注解，可以这样添加依赖：

// build.gradle.kts
dependencies {
    implementation("javax.inject:javax.inject:1")
}

或者 Groovy 版本:

// build.gradle
dependencies {
    implementation 'javax.inject:javax.inject:1'
}

注意：由于包名从 javax.* 更改为 jakarta.*，如果你是在2025年进行开发，并且没有特别的需求去支持旧版本，推荐使用 jakarta.inject 相关的依赖。

此外，若你在使用特定框架如 Spring，它也提供了自己的 @Qualifier 和 @Named 实现，可以直接使用而不需要额外添加上述依赖。确保查阅所使用框架的官方文档以获取更详细的指导。