java - Kodein 与 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"

}

我专门使用实现，因为我不希望任何人直接使用底层 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 中创建一个依赖于 common 和 google 模块的 Component。这不起作用，因为生成的代码引用了未从 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 中绑定(bind) ArgParser 的实现。我使用 ArgParser 作为示例，说明如何将参数传递给 API。 GoogleApi 完全是内部，以确保没有泄漏。我们只公开接口(interface)AbstractApi。

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

我们可以将所有实现细节隐藏在添加到 google 的组件后面，以创建接口(interface)的 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？

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

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

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