Kodein vs Dagger - 无法让 Dagger 与多个模块一起工作

Question

(x-post from /r/androiddev)

我只想先说这不是一篇“哪个更好”的帖子；这严格来说是一个关于如何使用 Dagger 构建东西（以及我如何在 Kodein 中构建它以帮助说明问题）的问题。

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

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

1. 应用程序
2. 常见
3. 谷歌

app 包含单个类App：

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

}

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

google 包含几个类：

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 公开的类（如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 个具有以下类的模块：

// ----->> 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，以通过实现/api 消除 Gradle 的复杂性。行为是相同的，甚至可能更严格一些：我们的模块中有一些无法公开的类。这样我们也有编译器验证。

我们可以将所有实现细节隐藏在我们添加到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 方法中添加它。

此设置应完全隐藏公共接口后面的app 模块的任何细节。生成的代码位于同一个模块中。

---

为什么不公开@Module？ @Subcomponent?

据报道，向组件添加模块也会在该组件中生成工厂代码，该代码将尝试使用未引用的类。这同样适用于子组件。

为什么不使用组件依赖？

由于组件上没有作用域，我们不妨将其添加为组件依赖项，但那时我们将无法添加作用域。此外，我们将更难传递参数，因为我们必须在创建组件时提供它们。