Android中使用Kotlin实现模块B调用模块A函数的方法

因为Module A已经依赖Module B，直接让B依赖A会造成循环依赖，所以必须通过接口或解耦方案实现反向调用，以下是几种常用方案：

一、接口回调（最直接的解耦方式） #

核心思路是在B中定义接口，A实现该接口并注册到B，B通过接口调用A的逻辑。

1. 在Module B中定义回调接口

// Module B/src/main/java/com/example/b/AFunctionCallback.kt
interface AFunctionCallback {
    // 声明需要调用的A模块函数签名
    fun fetchDataFromA(): String
}

2. 在Module B中提供注册回调的入口
   可以通过单例类或业务类暴露注册方法：

// Module B/src/main/java/com/example/b/BusinessHandler.kt
object BusinessHandler {
    private var aCallback: AFunctionCallback? = null

    // 供A模块注册回调
    fun registerACallback(callback: AFunctionCallback) {
        aCallback = callback
    }

    // B模块需要调用A逻辑的地方
    fun processWithAData() {
        aCallback?.fetchDataFromA()?.let { data ->
            // 处理从A获取的数据
            println("Module B 收到A的数据：$data")
        }
    }
}

3. 在Module A中实现接口并注册

// Module A/src/main/java/com/example/a/ACallbackImpl.kt
class ACallbackImpl : AFunctionCallback {
    override fun fetchDataFromA(): String {
        // 这里是A模块的具体业务逻辑
        return "Module A 生成的业务数据"
    }
}

// 在A模块的初始化时机（比如Application启动、页面初始化）注册
// 示例：在A模块的Application类中
class AApp : Application() {
    override fun onCreate() {
        super.onCreate()
        BusinessHandler.registerACallback(ACallbackImpl())
    }
}

二、依赖注入（适合大型项目） #

利用DI框架（如Dagger/Hilt）将A的实现注入到B中，避免硬编码依赖。

1. 在Module B中定义抽象接口

// Module B/src/main/java/com/example/b/AService.kt
interface AService {
    fun executeBusinessLogic(): Boolean
}

2. 在Module B中声明依赖该接口的类

// Module B/src/main/java/com/example/b/BService.kt
class BService @Inject constructor(private val aService: AService) {
    fun doBusiness() {
        val success = aService.executeBusinessLogic()
        if (success) {
            // 执行后续逻辑
        }
    }
}

3. 在Module A中实现接口并配置DI

// Module A/src/main/java/com/example/a/AServiceImpl.kt
class AServiceImpl : AService {
    override fun executeBusinessLogic(): Boolean {
        // A模块的业务逻辑
        return true
    }
}

// 配置Hilt模块，提供AService的实现
@Module
@InstallIn(SingletonComponent::class)
object AModule {
    @Provides
    fun provideAService(): AService {
        return AServiceImpl()
    }
}

三、事件总线（适合跨模块通信场景） #

通过事件发送-接收的方式，让B触发请求，A执行逻辑后返回结果。以LiveData为例：

1. 定义事件类（可放在Module B或公共模块）

// 可放在Module B或公共基础模块
data class CallAEvent(val resultCallback: (String) -> Unit)

2. 实现事件总线（单例模式）

object EventBus {
    private val callAEventLiveData = MutableLiveData<CallAEvent>()

    // 发送调用A的请求
    fun sendCallAEvent(callback: (String) -> Unit) {
        callAEventLiveData.value = CallAEvent(callback)
    }

    // 暴露观察入口
    fun observeCallAEvent(owner: LifecycleOwner, observer: Observer<CallAEvent>) {
        callAEventLiveData.observe(owner, observer)
    }
}

3. 在Module A中监听事件并处理

// 在A模块的生命周期组件中（如Activity、Application）监听
class AMainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        EventBus.observeCallAEvent(this) { event ->
            // 执行A模块的函数
            val data = getAData()
            // 通过回调返回结果给B
            event.resultCallback(data)
        }
    }

    private fun getAData(): String {
        return "Module A 返回的数据"
    }
}

4. 在Module B中发送事件触发调用

// Module B中需要调用A的地方
fun requestAData() {
    EventBus.sendCallAEvent { data ->
        println("Module B 收到A的数据：$data")
    }
}

关键注意事项 #

• 绝对不能在Module B的Gradle中添加对Module A的依赖，否则会触发循环依赖错误。
• 所有方案的核心都是面向接口编程，让依赖方（B）依赖抽象，提供方（A）实现抽象，从而解耦模块间的直接依赖。

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