Java Dagger2-应用程序可以'；t依赖于多个作用域组件_Java_Android_Kotlin_Dependency Injection_Dagger 2

Java Dagger2-应用程序可以'；t依赖于多个作用域组件

java android kotlin dependency-injection

Java Dagger2-应用程序可以'；t依赖于多个作用域组件,java,android,kotlin,dependency-injection,dagger-2,Java,Android,Kotlin,Dependency Injection,Dagger 2,注意：该问题可能与其他问题类似，但它提供了更好的解释，附带代码，旨在找到问题的解决方案，其他问题中提供的解决方案不适用就在几天前，我开始开发Android模块化应用程序。我使用匕首2来处理依赖注入，目前我面临一种奇怪的行为。我有我的主要应用程序模块和其他三个模块： Core\u模块：它公开第三方库和存储层本地化\u模块：它公开存储库以获取本地化信息 Configuration\u模块：它公开存储库以获取配置参数 Configuration\u Module和localization\u

注意：该问题可能与其他问题类似，但它提供了更好的解释，附带代码，旨在找到问题的解决方案，其他问题中提供的解决方案不适用

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

```
Core\u模块
```
：它公开第三方库和存储层
```
本地化\u模块
```
：它公开存储库以获取本地化信息
```
Configuration\u模块
```
：它公开存储库以获取配置参数

Configuration\u Module

和

localization\u Module

都依赖于

Core\u Module

核心组件：

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

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

    fun storageRepository(): StorageRepository
}

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

本地化组件：

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

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

    fun storageRepository(): StorageRepository
}

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

配置组件

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

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

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

应用组件

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

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

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

主要应用

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()
    }
}

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

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

    private fun registerDependencies() {
        val coreModule = CoreModule(applicationContext)
        val applicationModule = ApplicationModule(LocalisationModule(coreModule).localisationComponent,
                                ConfigurationModule(coreModule).configurationComponent)

        applicationComponent = DaggerApplicationComponent.builder()
                .applicationModule(applicationModule)
                .build()
    }
}

我决定设计这个架构，因为我想将功能划分为独立的、可互换的模块，以便每个模块都包含执行特定功能和将单个模块导出到其他应用程序所需的一切

不幸的是，我得到一个错误，说匕首组件不允许依赖于多个作用域组件。

有人知道如何面对这种问题吗？

在一整天的麻烦之后，我找到了一个适合我的情况的解决方案。所有描述的模块（

Configuration\u Module

，

localization\u Module

）都需要在我的应用程序模块中使用

因此，对于名为

ApplicationModule

的

@ApplicationScope

模块

，我删除了所有组件依赖项

应用程序组件

@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
    }
}

最后是我的主要申请

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()
    }
}

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

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

    private fun registerDependencies() {
        val coreModule = CoreModule(applicationContext)
        val applicationModule = ApplicationModule(LocalisationModule(coreModule).localisationComponent,
                                ConfigurationModule(coreModule).configurationComponent)

        applicationComponent = DaggerApplicationComponent.builder()
                .applicationModule(applicationModule)
                .build()
    }
}

我指出，一切都很顺利。

在一整天的麻烦之后，我找到了适合我的情况的解决方案。所有描述的模块（

Configuration\u Module

，

localization\u Module