Android项目Dagger子组件循环依赖编译栈溢出问题求解

能构建无编译错误的Dagger依赖图，但必须调整组件的依赖方式，打破当前的直接循环引用链——当前代码中SubComponentA和SubComponentB互相通过plus方法直接依赖，Dagger生成代码时会触发无限递归，最终导致栈溢出。

具体解决方案 #

方案1：通过父组件作为依赖中转层

让两个子组件都依赖同一个父组件，子组件之间不再直接互相创建，而是通过父组件提供的工厂类来创建对方组件，彻底切断循环依赖链：

// 定义父组件，作为两个子组件的依赖枢纽
@Component(modules = [ParentModule::class])
interface ParentComponent {
    fun subComponentAFactory(): SubComponentA.Factory
    fun subComponentBFactory(): SubComponentB.Factory
}

@Subcomponent(modules = [SubComponentA.Module::class])
interface SubComponentA {
    class Factory @Inject constructor(private val parentComponent: ParentComponent) {
        fun create(module: SubComponentA.Module): SubComponentA {
            return parentComponent.subComponentAFactory().create(module)
        }

        // 通过父组件获取SubComponentB的创建能力
        fun createSubComponentB(module: SubComponentB.Module): SubComponentB {
            return parentComponent.subComponentBFactory().create(module)
        }
    }

    @dagger.Module
    class Module {
        // 提供Feature A所需的依赖
    }
}

@Subcomponent(modules = [SubComponentB.Module::class])
interface SubComponentB {
    class Factory @Inject constructor(private val parentComponent: ParentComponent) {
        fun create(module: SubComponentB.Module): SubComponentB {
            return parentComponent.subComponentBFactory().create(module)
        }

        // 通过父组件获取SubComponentA的创建能力
        fun createSubComponentA(module: SubComponentA.Module): SubComponentA {
            return parentComponent.subComponentAFactory().create(module)
        }
    }

    @dagger.Module
    class Module {
        // 提供Feature B所需的依赖
    }
}

方案2：使用延迟加载机制（Provider/Lazy）

如果不想引入父组件，可通过Dagger的Provider<T>或Lazy<T>延迟创建对方组件，避免初始化时触发无限递归：

@Subcomponent(modules = [SubComponentA.Module::class])
interface SubComponentA {
    // 暴露SubComponentB的Provider，延迟创建
    fun subComponentBProvider(): Provider<SubComponentB>

    @dagger.Module
    class Module {
        @Provides
        fun provideSubComponentBProvider(
            parentComponent: ParentComponent,
            @Named("BModule") module: SubComponentB.Module
        ): Provider<SubComponentB> {
            return Provider { parentComponent.subComponentBFactory().create(module) }
        }
    }
}

@Subcomponent(modules = [SubComponentB.Module::class])
interface SubComponentB {
    fun subComponentAProvider(): Provider<SubComponentA>

    @dagger.Module
    class Module {
        @Provides
        fun provideSubComponentAProvider(
            parentComponent: ParentComponent,
            @Named("AModule") module: SubComponentA.Module
        ): Provider<SubComponentA> {
            return Provider { parentComponent.subComponentAFactory().create(module) }
        }
    }
}

核心逻辑 #

无论哪种方案，核心都是打破子组件之间的直接循环依赖，让Dagger的代码生成逻辑不会陷入无限递归，从而避免编译时的StackOverflow错误。

内容的提问来源于stack exchange，提问作者Guimareshh