Kodein vs Dagger-无法使用多个模块运行Dagger

Question

（来自/ r / androiddev的x-
post
）

我想以说这不是“更好”的帖子作为开头。严格来说，这是一个关于如何使用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中实现此功能，但无法正常工作。我的第一个尝试是让Componentin
app依赖于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()
}

接下来，我尝试为每个模块制作组件（渐变模块）：

// 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

因此，我们需要绑定一个实现了ArgParser两个google和app。我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是我们可能需要提供以创建对象的参数的示例。我们也可以使用a
@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？

据报道，将模块添加到组件中也会在该组件内生成工厂代码，这将尝试使用未引用的类。子组件也是如此。

为什么不使用组件依赖关系？

由于组件上没有作用域，因此我们最好将其添加为组件依赖项，但那时我们将无法添加作用域。另外，传递参数会很麻烦，因为在创建组件时必须提供参数。