Android中基于Koin实现CoroutineWorker的动态Lambda依赖注入问询

问题背景 #

我正在调研Android应用中的Koin依赖注入库，现有一个CoroutineWorker负责处理后台任务。目前我已经实现了固定注入Lambda的代码，但希望能在运行时动态指定要注入的Lambda表达式——比如我有10个分别以BackgroundLambdaName_0到BackgroundLambdaName_9命名的Lambda，希望在启动后台任务时决定使用哪一个。

当前非动态的Koin模块代码：

const val BackgroundLambdaName: String = "back-ground-lambda"
val lambdaModule = module {
    single(qualifier = named(BackgroundLambdaName)) { background }
}
private val background: suspend CoroutineScope.(Service) -> Unit = { service: Service ->
    val limit: Int = 200
    var offset: Int = 0
    loop@ while (true) {
        val networkResponse = service.move(options = mutableMapOf("limit" to limit, "offset" to offset))
        if (networkResponse.next == null) {
            break@loop
        }
        offset += limit
    }
}

当前的CoroutineWorker实现：

class BackgroundWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params), KoinComponent {
    private val service: Service by inject()
    private val x_background: suspend CoroutineScope.(Service) -> Unit by inject(qualifier = named(BackgroundLambdaName))

    override suspend fun doWork(): Result = coroutineScope {
        withContext(Dispatchers.IO) {
            downloadSynchronously(this)
            Result.success()
        }
    }

    private suspend fun downloadSynchronously(coroutineScope: CoroutineScope) {
        x_background(coroutineScope, service)
    }
}

启动任务的代码，希望能在这里动态指定限定符：

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresBatteryNotLow(true)
    .setRequiresCharging(true)
    .build()
val backgroundWorkRequest = OneTimeWorkRequestBuilder<BackgroundWorker>()
    .setConstraints(constraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    ).build()
// 希望在这里动态设置要使用的Lambda限定符（比如BackgroundLambdaName_0）
WorkManager.getInstance(application).enqueueUniqueWork(UNIQUE_WORK_NAME, ExistingWorkPolicy.KEEP, backgroundWorkRequest)

解决方案 #

核心思路是：通过WorkRequest的输入数据传递目标限定符名称，然后在Worker内部动态从Koin获取对应的Lambda实例，而不是用初始化时绑定的by inject()（因为它是在Worker创建时就确定了依赖，无法动态修改）。

步骤1：定义所有带不同限定符的Lambda模块

先把所有需要的Lambda都注册到Koin模块里，每个用唯一的命名限定符：

// 定义所有Lambda的命名常量
const val BackgroundLambdaName_0 = "back-ground-lambda-0"
const val BackgroundLambdaName_1 = "back-ground-lambda-1"
// ... 直到BackgroundLambdaName_9

val lambdaModule = module {
    // 注册第一个Lambda
    single(named(BackgroundLambdaName_0)) {
        suspend CoroutineScope.(Service) -> Unit { service: Service ->
            // 这里是BackgroundLambdaName_0对应的业务逻辑
            val limit = 200
            var offset = 0
            loop@ while (true) {
                val response = service.move(mutableMapOf("limit" to limit, "offset" to offset))
                if (response.next == null) break@loop
                offset += limit
            }
        }
    }

    // 注册第二个Lambda
    single(named(BackgroundLambdaName_1)) {
        suspend CoroutineScope.(Service) -> Unit { service: Service ->
            // 这里是BackgroundLambdaName_1对应的业务逻辑，比如不同的参数或流程
            val limit = 100
            var offset = 0
            repeat(5) {
                service.move(mutableMapOf("limit" to limit, "offset" to offset))
                offset += limit
            }
        }
    }

    // ... 继续注册剩下的Lambda（BackgroundLambdaName_2到BackgroundLambdaName_9）
}

步骤2：启动WorkRequest时传递限定符参数

在构建OneTimeWorkRequest时，通过setInputData把目标限定符名称传递给Worker：

// 比如这里选择使用BackgroundLambdaName_0作为本次任务的Lambda限定符
val targetQualifier = BackgroundLambdaName_0

val inputData = workDataOf(
    "LAMBDA_QUALIFIER" to targetQualifier
)

val backgroundWorkRequest = OneTimeWorkRequestBuilder<BackgroundWorker>()
    .setConstraints(constraints)
    .setBackoffCriteria(
        BackoffPolicy.EXPONENTIAL,
        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    )
    .setInputData(inputData) // 传递限定符参数
    .build()

WorkManager.getInstance(application).enqueueUniqueWork(UNIQUE_WORK_NAME, ExistingWorkPolicy.KEEP, backgroundWorkRequest)

步骤3：修改CoroutineWorker实现，动态获取Lambda

把原来的by inject()改为在doWork()方法内部，根据输入数据的限定符动态从Koin获取实例：

class BackgroundWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params), KoinComponent {
    private val service: Service by inject()
    // 不要在这里初始化x_background，改为动态获取

    override suspend fun doWork(): Result = coroutineScope {
        // 从输入数据中获取限定符名称
        val qualifierName = inputData.getString("LAMBDA_QUALIFIER")
            ?: return@coroutineScope Result.failure() // 如果没有传递参数，直接返回失败

        // 动态从Koin获取对应的Lambda
        val x_background: suspend CoroutineScope.(Service) -> Unit = get(named(qualifierName))

        withContext(Dispatchers.IO) {
            downloadSynchronously(this, x_background)
            Result.success()
        }
    }

    private suspend fun downloadSynchronously(coroutineScope: CoroutineScope, lambda: suspend CoroutineScope.(Service) -> Unit) {
        lambda(coroutineScope, service)
    }
}

关键说明 #

• 为什么不能用by inject()？因为by inject()是在Worker被实例化时就完成依赖注入的，而Worker的实例化时机由WorkManager控制，无法在启动任务时修改注入的依赖。
• 输入数据传递的是字符串形式的限定符名称，Koin的get(named(...))方法可以通过这个名称找到对应的注册实例。
• 如果需要做参数校验，可以在Worker里先判断qualifierName是否在允许的列表中，避免非法参数导致的注入失败。

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