Kodein vs Dagger - 无法让 Dagger 使用多个模块工作

Question

(x-post from /r/androiddev)

我想先声明这不是 "which is better" post；这完全是一个关于我如何使用 Dagger 构建东西的问题（以及我如何在 Kodein 中构建它以帮助说明问题）。

我已经在几个工作项目中使用 Kodein 几年了，我发现它非常容易使用，以至于我再也没有看过 Dagger。我开始了一个新的个人项目，我想我会再试一次 Dagger。

为简单起见，我有 3 个模块（这是一个普通的桌面应用程序，不是 Android 一个）；

1. 应用程序
2. 普通
3. google

app 包含单个 class App:

class App(
  private val api: GoogleApi,
  private val argParser: ArgParser
) {
  fun run() {
    while(true) {
      api.login(argParser.username, argParser.password);
    }
  }

}

common 包含单个 class ArgParser（实现并不重要）

google 包含几个 classes:

class GoogleApi(  
  driveProvider: () -> Drive
) {

  private val drive by lazy {
    driveProvider()
  }

  fun login(username: String, password: String) {
    drive.login() // not real call
  }
}

internal class CredentialRetriever(
  private val transport: NetHttpTransport,
  private val jsonFactory: JacksonFactory
) {

  fun retrieveCredentials() = ...

}

google 的依赖项是：

dependencies {

  implementation "com.google.api-client:google-api-client:$googleApiVersion"

  implementation "com.google.oauth-client:google-oauth-client-jetty:$googleApiVersion"

  implementation "com.google.apis:google-api-services-drive:v3-rev110-$googleApiVersion"

}

我特别使用 implementation 因为我不想让任何人直接使用底层 Google 库。

为了让它在 Kodein 中工作，我在 main 中执行以下操作：

fun main(args: Array<String>) {

  val kodein = Kodein {
    import(commonModule(args = args))
    import(googleModule)
    import(appModule)

    bind<App>() with singleton {
      App(
        api = instance(),
        argParser = instance()
      )
    }
  }

  kodein.direct.instance<App>().run()
}

然后在 google:

val googleModule = Kodein.Module("Google") {

  bind<CredentialRetriever>() with provider {
    CredentialRetriever(jsonFactory = instance(), transport = instance())
  }

  bind<Drive>() with provider {
    Drive.Builder(
      instance(),
      instance(),
      instance<CredentialRetriever>().retrieveCredentials()
    ).setApplicationName("Worker").build()
  }

  bind<GoogleApi>() with singleton {
    GoogleApi(drive = provider())
  }

  bind<JacksonFactory>() with provider {
    JacksonFactory.getDefaultInstance()
  }

  bind<NetHttpTransport>() with provider{
    GoogleNetHttpTransport.newTrustedTransport()
  }
}

最后在 common:

fun commonModule(args: Array<String>) = Kodein.Module("Common") {
  bind<ArgParser>() with singleton { ArgParser(args = args) }
}

我尝试在 Dagger 中实现它，但无法正常工作。我的第一次尝试是在 app 中创建一个 Component，它依赖于 common 和 google 中的模块。这没有用，因为生成的代码引用了 google 中未公开的 classes（如 Drive）。我可以通过使它们 api 依赖关系来解决这个问题，但我不想公开它们：

// CredentialRetriever and GoogleApi were updated to have @Inject constructors

// GoogleApi also got an @Singleton

@Module
object GoogleModule {

  @Provides
  internal fun drive(
    transport: NetHttpTransport,
    jsonFactory: JacksonFactory,
    credentialRetriever: CredentialRetreiver
  ): Drive =
    Drive.Builder(
      transport,
      jsonFactory,
      credentialRetriever.retrieveCredentials()
    ).setApplicationName("Worker").build()

  @Provides
  internal fun jsonFactory(): JacksonFactory =
    JacksonFactory.getDefaultInstance()

  @Provides
  internal fun netHttpTransport(): NetHttpTransport = 
    GoogleNetHttpTransport.newTrustedTransport()
}

接下来我尝试为每个模块制作一个组件（gradle 模块）：

// in google module

@Singleton
@Component(modules = [GoogleModule::class])
interface GoogleComponent {
  fun googleApi(): GoogleApi
}

// in common module

@Singleton
@Component(modules = [CommonModule::class])
interface CommonComponent {
  fun argParser(): ArgParser
}

然后在 app 有趣的事情开始了：

// results in "AppComponent (unscoped) cannot depend on scoped components:"

@Component(dependencies = [CommonComponent::class, GoogleComponent::class])
interface AppComponent {
  fun app(): App
}

好的，让我们将其限定范围：

// results in "This @Singleton component cannot depend on scoped components:"

@Singleton
@Component(dependencies = [CommonComponent::class ,GoogleComponent::class])
interface AppComponent {
  fun app(): App
}

编辑：尝试让AppComponent使用自定义作用域：

// results in "AppComponent depends on more than one scoped component:"

@AppScope
@Component(dependencies = [CommonComponent::class ,GoogleComponent::class])
interface AppComponent {
  fun app(): App
}

如何在 Dagger 中实现这一点？我已经阅读了文档，我想我有点理解它们，但我不知道下一步该怎么做。

Answer 1

我冒昧地更改了您的示例，以便 a) 删除不必要的细节和 b) 简化设置。

给定 3 个具有以下 classes 的模块：

// ----->> app <<-----
class App @Inject constructor(
        private val api: AbstractApi,
        private val argParser: ArgParser
)

// ----->> google <<-----
// expose a public interface
interface AbstractApi

// have our internal implementation
internal class GoogleApi @Inject constructor(
        private val argParser: ArgParser
) : AbstractApi

// ----->> common <<-----

// expose some common class
interface ArgParser

所以我们需要在 google 和 app 中绑定 ArgParser 的实现。我在这里使用 ArgParser 作为示例，我们如何将参数传递给我们的 API。 GoogleApi 完全是 internal 以确保没有泄漏。我们只暴露接口 AbstractApi.

我将 GoogleApi 设为内部以消除 Gradle 实现的复杂性 / api。行为是一样的，甚至可能更严格一点：我们的模块中有一些 class 我们不能公开。这样我们也有编译器验证。

我们可以将所有实现细节隐藏在我们添加到 google 的组件后面，以创建我们的 GoogleApi 接口实现。

// ----->> google
@Component(modules = [ApiModules::class])
interface ApiComponent {
    // has a provision method for our API
    fun api(): AbstractApi

    @Component.Factory
    interface Factory {
        // factory method to bind additional args that we need to supply
        fun create(@BindsInstance parser: ArgParser): ApiComponent
    }
}

@Module
internal interface ApiModules {
    @Binds
    fun bindApi(googleApi: GoogleApi): AbstractApi

}

我们在这里不使用作用域，因为在使用该组件的任何地方都应该处理作用域。 ArgParser 是我们创建对象时可能需要提供的参数示例。我们也可以使用 @Component.Builder 而不是工厂。

Dagger 将在同一模块 (google) 内生成组件，因此不会有任何引用代码的问题。我们所要做的就是在我们的 app 模块中检索 API：

// ----->> app
@Component(modules = [AppModule::class])
interface AppComponent {
    fun app(): App
}

@Module
class AppModule {

    @Provides
    fun provideParser(): ArgParser = object : ArgParser {} // just bind a dummy implementation

    @Provides
    fun provideApi(argParser: ArgParser): AbstractApi {
        return DaggerApiComponent.factory().create(argParser).api()
    }
}

我们现在可以使用组件工厂从我们的模块创建一个实例。如果我们需要一个范围，我们可以像往常一样在 @Provides 方法中添加它。

此设置应完全隐藏 public 界面后面的 app 模块的任何细节。生成的代码驻留在同一模块中。

---

为什么不暴露一个@Module？一个@Subcomponent?

据报道，向组件添加模块也会在该组件内生成工厂代码，这将尝试使用 non-referenced classes。这同样适用于子组件。

为什么不使用组件依赖项？

由于组件上没有范围，我们不妨将其添加为组件依赖项，但那样我们将无法添加范围。我们也很难传递参数，因为我们必须在创建组件时提供它们。