Question

NB该问题可能与其他问题相似，但它提供了带有附件代码的更好解释，旨在找到解决问题的方法，其他问题中提供的解决方案均不适用。

就在几天前，我开始开发一个Android模块化应用程序。我使用Dagger 2来处理依赖项注入，而我目前正面临一种奇怪的行为。我有我的主要应用程序模块和其他三个模块：

Core_Module：它公开了第三方库和存储层。
Localisation_Module：它公开了一个存储库以获取本地化信息。
Configuration_Module：公开一个存储库以获取配置参数。

Configuration_Module和Localisation_Module都取决于Core_Module。

CoreComponent：

@Singleton
@Component(modules = [ApplicationModule::class, NetworkingModule::class, RepositoryModule::class])
interface CoreComponent {
    @Named("retrofit")
    fun retrofit(): Retrofit

    @Named("retrofitWithCache")
    fun retrofitWithCache(): Retrofit

    fun storageRepository(): StorageRepository
}

LocalisationComponent：

@Component(modules = [ServiceModule::class, RepositoryModule::class], dependencies = [CoreComponent::class])
@LocalisationScope
interface LocalisationComponent {
    fun localisationService(): LocalisationService
    fun localisationRepository(): LocalisationRepository
}

ConfigurationComponent

@Component(modules = [ServiceModule::class, RepositoryModule::class], dependencies = [CoreComponent::class])
@ConfigurationScope
interface ConfigurationComponent {
    fun configurationService(): ConfigurationService
    fun configurationRepository(): ConfigurationRepository
}

ApplicationComponent

@Component(dependencies = [LocalisationComponent::class, ConfigurationComponent::class])
@ApplicationScope
abstract class ApplicationComponent {
    abstract fun inject(mainActivity: MainActivity)
}

MainApplication

class MainApplication : Application() {
    lateinit var applicationComponent: ApplicationComponent

    override fun onCreate() {
        super.onCreate()
        this.registerDependencies()
    }

    private fun registerDependencies() {
        val coreModule = CoreModule(applicationContext)
        applicationComponent = DaggerApplicationComponent.builder()
                .localisationComponent(LocalisationModule(coreModule).localisationComponent)
                .configurationComponent(ConfigurationModule(coreModule).configurationComponent)
                .build()
    }
}

我之所以决定设计此体系结构，是因为我想将功能分成独立的，可互换的模块，以便每个模块都包含执行特定功能并将单个模块导出到其他应用程序所需的一切。

不幸的是，我收到一条错误消息，说不允许Dagger组件依赖于多个作用域组件。有人知道如何面对这种问题吗？

Answer 1

经过一整天的麻烦，我找到了适合我的情况的解决方案。所有描述的模块（Configuration_Module，Localisation_Module）都需要在我的应用程序模块中使用。

因此对于名为@ApplicationScope的{{1}} @Module，我删除了所有组件依赖项。

应用程序组件

ApplicationModule

应用模块

@Component(modules = [ApplicationModule::class])
@ApplicationScope
abstract class ApplicationComponent {
    abstract fun inject(mainActivity: MainActivity)
}

最后我的主要应用

@Module
class ApplicationModule(private val localisationComponent: LocalisationComponent,
                        private val configurationComponent: ConfigurationComponent) {
    @Provides
    @ApplicationScope
    fun providesLocalisationRepository(): LocalisationRepository {
        return localisationComponent.localisationRepository() // Provided by Localisation module with Dagger
    }

    @Provides
    @ApplicationScope
    fun providesConfigurationRepository(): ConfigurationRepository {
        return configurationComponent.configurationRepository() // Provided by Configuration module with Dagger
    }
}

我指出一切都像魅力一样。

Dagger2-应用程序不能依赖于多个作用域组件

1 个答案: