Dagger2如何@为一种类型提供两种不同的实现

// 定义限定符注解
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface Qualifier1 {}

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface Qualifier2 {}

// 定义接口
public interface MyInterface {
    void doSomething();
}

// 实现接口的两个类
public class Implementation1 implements MyInterface {
    @Override
    public void doSomething() {
        // 实现1的逻辑
    }
}

public class Implementation2 implements MyInterface {
    @Override
    public void doSomething() {
        // 实现2的逻辑
    }
}

// Dagger2的依赖注入组件
@Component
public interface MyComponent {
    @Qualifier1
    MyInterface getImplementation1();

    @Qualifier2
    MyInterface getImplementation2();
}

// 在需要注入的地方使用限定符注解
public class MyClass {
    @Inject
    @Qualifier1
    MyInterface implementation1;

    @Inject
    @Qualifier2
    MyInterface implementation2;

    public void doSomething() {
        implementation1.doSomething();
        implementation2.doSomething();
    }
}

// 在提供方法上使用限定符注解，提供不同的实现
@Module
public class MyModule {
    @Provides
    @Qualifier1
    MyInterface provideImplementation1() {
        return new Implementation1();
    }

    @Provides
    @Qualifier2
    MyInterface provideImplementation2() {
        return new Implementation2();
    }
}

// 在应用中使用Dagger2进行依赖注入
public class MyApp {
    public static void main(String[] args) {
        MyComponent component = DaggerMyComponent.builder()
                .myModule(new MyModule())
                .build();

        MyClass myClass = new MyClass();
        component.inject(myClass);

        myClass.doSomething();
    }
}