如何在Hilt中解决ClassA与ClassB的循环依赖并传入自身作为监听器

我有一个ClassA依赖于ClassB，而ClassB的构造函数需要由ClassA实现的IClassBListener监听器接口。使用Hilt创建实例时，如何在不触发循环依赖错误的前提下，将Hilt正在创建的ClassA作为监听器传入ClassB？

类结构如下：

class ClassA(val classB: ClassB): IClassBListener

class ClassB(val classBListener: IClassBListener)

interface IClassBListener{}

我尝试了以下代码，但出现了预期的循环依赖错误：

@Singleton
@Provides
fun provideClassA(classBListener: IClassBListener): ClassA = ClassA(ClassB(classBListener))

@Binds
abstract fun bindClassBListener(classA: ClassA): IClassBListener

我希望在provideClassA方法中返回类似ClassA(ClassB(this))的实例，其中this是Hilt创建的ClassA，请问该如何实现？

要打破这种循环依赖，核心是避免Hilt同时触发ClassA和ClassB的即时初始化，以下是三种可行的实现方式：

方式一：使用Provider延迟获取监听器实例 #

利用Hilt的Provider接口延迟获取IClassBListener实例，避免创建ClassB时立即初始化ClassA：

1. 修改ClassB构造函数，接收Provider<IClassBListener>：

class ClassB(private val classBListenerProvider: Provider<IClassBListener>) {
    // 实际使用监听器时再获取实例
    val classBListener: IClassBListener
        get() = classBListenerProvider.get()
}

2. 调整Hilt的绑定与提供逻辑：

@Singleton
@Provides
fun provideClassB(classBListenerProvider: Provider<IClassBListener>): ClassB {
    return ClassB(classBListenerProvider)
}

@Singleton
@Provides
fun provideClassA(classB: ClassB): ClassA {
    return ClassA(classB)
}

@Binds
abstract fun bindClassBListener(classA: ClassA): IClassBListener

这样Hilt创建ClassB时不会立即实例化ClassA，只有当ClassB调用classBListener时，才会获取已经初始化完成的ClassA实例，彻底打破循环依赖链。

方式二：Setter注入分步实例化 #

如果不想修改ClassB的构造，可通过分步创建实例再关联的方式实现：

1. 修改ClassA，添加空构造和Setter方法：

class ClassA: IClassBListener {
    lateinit var classB: ClassB

    // 空构造供Hilt初始化
    constructor()

    // 保留原构造（可选，兼容原有调用）
    constructor(classB: ClassB) {
        this.classB = classB
    }
}

2. 编写Hilt提供方法：

@Singleton
@Provides
fun provideClassA(): ClassA {
    return ClassA()
}

@Singleton
@Provides
fun provideClassB(classA: IClassBListener): ClassB {
    return ClassB(classA)
}

@Singleton
@Provides
fun initClassA(classA: ClassA, classB: ClassB): ClassA {
    classA.classB = classB
    return classA
}

@Binds
abstract fun bindClassBListener(classA: ClassA): IClassBListener

Hilt会自动处理依赖顺序，确保initClassA在ClassA和ClassB都创建完成后执行，保证ClassA的classB属性被正确赋值。

方式三：Kotlin专属——使用Lazy懒加载 #

如果是Kotlin项目，用Lazy实现懒加载更符合语言习惯：

1. 修改ClassB构造函数：

class ClassB(private val classBListener: Lazy<IClassBListener>) {
    fun doSomething() {
        // 使用监听器时才触发实例化
        val listener = classBListener.value
        // 执行业务逻辑
    }
}

2. Hilt配置：

@Singleton
@Provides
fun provideClassB(classBListener: Lazy<IClassBListener>): ClassB {
    return ClassB(classBListener)
}

@Singleton
@Provides
fun provideClassA(classB: ClassB): ClassA {
    return ClassA(classB)
}

@Binds
abstract fun bindClassBListener(classA: ClassA): IClassBListener

Lazy会延迟到第一次调用value时才获取ClassA实例，同样能避免循环依赖问题。

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