我有一个大型 Android 应用程序，需要根据操作系统版本、制造商和许多其他内容运行不同的代码。但是，此应用程序需要是单个 APK。它需要在运行时足够聪明才能确定要使用的代码。到目前为止，我们一直在使用 Guice，但性能问题导致我们考虑迁移到 Dagger。但是，我一直无法确定我们是否可以实现相同的用例。

主要目标是让我们在启动时运行一些代码以提供兼容模块的列表。然后将此列表传递给 Dagger 以连接所有内容。

这是我们要迁移的 Guice 当前实现的一些伪代码

import com.google.inject.AbstractModule;

@Feature("Wifi")
public class WifiDefaultModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(WifiManager.class).to(WifiDefaultManager.class);
    bind(WifiProcessor.class).to(WifiDefaultProcessor.class);
  }
}

@Feature("Wifi")
@CompatibleWithMinOS(OS > 4.4)
class Wifi44Module extends WifiDefaultModule {
  @Override
  protected void configure() {
    bind(WifiManager.class).to(Wifi44Manager.class);
    bindProcessor();
  }

  @Override
  protected void bindProcessor() {
    (WifiProcessor.class).to(Wifi44Processor.class);
  }
}  

@Feature("Wifi")
@CompatibleWithMinOS(OS > 4.4)
@CompatibleWithManufacturer("samsung")
class WifiSamsung44Module extends Wifi44Module {
  @Override
  protected void bindProcessor() {
    bind(WifiProcessor.class).to(SamsungWifiProcessor.class);
}

@Feature("NFC")
public class NfcDefaultModule extends AbstractModule {
  @Override
  protected void configure() {
    bind(NfcManager.class).to(NfcDefaultManager.class);
  }
}

@Feature("NFC")
@CompatibleWithMinOS(OS > 6.0)
class Nfc60Module extends NfcDefaultModule {
  @Override
  protected void configure() {
    bind(NfcManager.class).to(Nfc60Manager.class);
  }
}

public interface WifiManager {
  //bunch of methods to implement
}

public interface WifiProcessor {
  //bunch of methods to implement
}

public interface NfcManager {
  //bunch of methods to implement
}

public class SuperModule extends AbstractModule {
  private final List<Module> chosenModules = new ArrayList<Module>();

  public void addModules(List<Module> features) {
    chosenModules.addAll(features);
  }

  @Override
  protected void configure() {
    for (Module feature: chosenModules) {
      feature.configure(binder())
    }
  }  
}

SuperModule superModule = new SuperModule();
superModule.addModules(crazyBusinessLogic());
Injector injector = Guice.createInjector(Stage.PRODUCTION, superModule);

最佳答案

Dagger 在编译时生成代码，因此您不会像在 Guice 中那样具有模块灵活性；而不是 Guice 能够反射(reflection)地发现 @Provides方法并运行反射 configure()方法，Dagger 需要知道如何创建它在运行时可能需要的每个实现，并且需要在编译时知道这一点。因此，无法传递任意的模块数组并让 Dagger 正确连接您的图形 ;它破坏了编写 Dagger 提供的编译时检查和性能。

也就是说，您似乎可以接受包含所有可能实现的单个 APK，因此唯一的问题是在运行时在它们之间进行选择。这在 Dagger 中是很有可能的，并且可能属于以下四种解决方案之一:David 的基于组件依赖的解决方案、模块子类、有状态模块实例或 @BindsInstance基于重定向。

组件依赖

如 David's blog you linked ，您可以定义一个带有一组需要传入的绑定(bind)的接口(interface)，然后通过传递给构建器的该接口(interface)的实现来提供这些绑定(bind)。虽然界面的结构让这个设计得很好，可以通过 Dagger @Component实现到其他 Dagger @Component实现，接口(interface)可以被任何东西实现。

但是，我不确定这个解决方案是否适合您:这种结构也最适合继承独立实现，而不是您的各种 WifiManager 的情况。实现都具有图形需要满足的依赖项。如果您需要支持“插件”架构，或者如果您的 Dagger 图太大以至于单个图不应包含应用程序中的所有类，您可能会被这种类型的解决方案所吸引，但除非您有这些限制您可能会发现此解决方案冗长且具有限制性。

模块子类

Dagger 允许非 final模块，并允许将实例传递到模块中，因此您可以通过将模块的子类传递到组件的构建器来模拟您的方法。因为替换/覆盖实现的能力经常与测试相关联，这在 Dagger 2 Testing page under the heading "Option 1: Override bindings by subclassing modules (don’t do this!)" 中有描述。 ——它清楚地描述了这种方法的注意事项，特别是虚方法调用将比静态方法慢 @Provides方法，以及任何被覆盖的 @Provides方法必然需要采用任何实现使用的所有参数。

// Your base Module
@Module public class WifiModule {
  @Provides WifiManager provideWifiManager(Dep1 dep1, Dep2 dep2) {
    /* abstract would be better, but abstract methods usually power
     * @Binds, @BindsOptionalOf, and other declarative methods, so
     * Dagger doesn't allow abstract @Provides methods. */
    throw new UnsupportedOperationException();
  }
}

// Your Samsung Wifi module
@Module public class SamsungWifiModule {
  @Override WifiManager provideWifiManager(Dep1 dep1, Dep2 dep2) {
    return new SamsungWifiManager(dep1);  // Dep2 unused
  }
}

// Your Huawei Wifi module
@Module public class HuaweiWifiModule {
  @Override WifiManager provideWifiManager(Dep1 dep1, Dep2 dep2) {
    return new HuaweiWifiManager(dep1, dep2);
  }
}

// To create your Component
YourAppComponent component = YourAppComponent.builder()
    .baseWifiModule(new SamsungWifiModule())   // or name it anything
                                               // via @Component.Builder
    .build();

// Your NFC module
@Module public class NfcModule {
  private final boolean useNfc60;

  public NfcModule(boolean useNfc60) { this.useNfc60 = useNfc60; }

  @Override NfcManager provideNfcManager() {
    if (useNfc60) {
      return new Nfc60Manager();
    }
    return new NfcDefaultManager();
  }
}

// To create your Component
YourAppComponent component = YourAppComponent.builder()
    .nfcModule(new NfcModule(true))  // again, customize with @Component.Builder
    .build();

// Your NFC module
@Module public class NfcModule {
  private final boolean useNfc60;

  public NfcModule(boolean useNfc60) { this.useNfc60 = useNfc60; }

  @Override NfcManager provideNfcManager(
      Provider<Nfc60Manager> nfc60Provider,
      Provider<NfcDefaultManager> nfcDefaultProvider) {
    if (useNfc60) {
      return nfc60Provider.get();
    }
    return nfcDefaultProvider.get();
  }
}

// Your NFC module
@Module public abstract class NfcModule {
  @Provides static NfcManager provideNfcManager(
      YourConfiguration yourConfiguration,
      Provider<Nfc60Manager> nfc60Provider,
      Provider<NfcDefaultManager> nfcDefaultProvider) {
    if (yourConfiguration.useNfc60()) {
      return nfc60Provider.get();
    }
    return nfcDefaultProvider.get();
  }
}

// To create your Component
YourAppComponent component = YourAppComponent.builder()
    // Use @Component.Builder and @BindsInstance to make this easy
    .yourConfiguration(getConfigFromBusinessLogic())
    .build();

关于android - Dagger2 - 如何在运行时有条件地选择模块，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48874448/