如何为Worker类实现Dagger依赖注入？解决框架创建类的注入难题

这是Android开发里很常见的场景——因为Worker由WorkerManager框架负责实例化，没法直接让Dagger接管它的构造流程，不过我们可以通过自定义WorkerFactory结合Dagger的Multibindings特性来实现依赖注入，具体步骤如下：

1. 改造Worker类，使用构造方法注入 #

首先，给你的Worker类添加@Inject注解的构造方法，既要保留WorkerManager要求的Context和WorkerParameters参数，也要加入你需要注入的依赖：

// 示例：使用CoroutineWorker，如果是普通Worker就继承Worker
class MyWorker @Inject constructor(
    appContext: Context,
    workerParams: WorkerParameters,
    private val myBusinessService: MyBusinessService // 你需要注入的自定义依赖
) : CoroutineWorker(appContext, workerParams) {

    override suspend fun doWork(): Result {
        // 在这里使用注入的myBusinessService完成任务
        myBusinessService.doSomething()
        return Result.success()
    }
}

注意：不要用字段注入（@Inject lateinit var xxx），因为WorkerManager创建实例时Dagger没有机会执行注入操作，构造方法注入是唯一可行的方式。

2. 定义Worker绑定的注解和Dagger Module #

我们需要用Dagger的Multibindings来把所有Worker类绑定到一个Map中，这样自定义Factory就能通过类名找到对应的Worker实例。

首先定义一个MapKey注解：

@MapKey
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class WorkerKey(val value: Class<out ListenableWorker>)

然后创建一个Dagger Module，用来绑定你的Worker类：

@Module
abstract class WorkerBindingModule {

    @Binds
    @IntoMap
    @WorkerKey(MyWorker::class)
    abstract fun bindMyWorker(worker: MyWorker): ListenableWorker

    // 如果有其他Worker，按照同样的格式添加绑定即可
    // @Binds
    // @IntoMap
    // @WorkerKey(AnotherWorker::class)
    // abstract fun bindAnotherWorker(worker: AnotherWorker): ListenableWorker
}

3. 实现自定义DaggerWorkerFactory #

这个Factory会被WorkerManager用来创建Worker实例，它通过Dagger注入的Worker Provider Map来获取已经注入好依赖的Worker对象：

class DaggerWorkerFactory @Inject constructor(
    private val workerProviders: Map<Class<out ListenableWorker>, @JvmSuppressWildcards Provider<ListenableWorker>>
) : WorkerFactory() {

    override fun createWorker(
        appContext: Context,
        workerClassName: String,
        workerParameters: WorkerParameters
    ): ListenableWorker? {
        // 根据类名找到对应的Worker Class
        val workerClass = try {
            Class.forName(workerClassName).asSubclass(ListenableWorker::class.java)
        } catch (e: ClassNotFoundException) {
            return null
        }

        // 从Dagger提供的Map中获取Worker的Provider
        val workerProvider = workerProviders[workerClass] ?: return null

        return try {
            // 获取已经注入好依赖的Worker实例
            workerProvider.get()
        } catch (e: Exception) {
            throw RuntimeException("Failed to create worker instance for $workerClassName", e)
        }
    }
}

4. 配置WorkerManager使用自定义Factory #

最后，我们需要让WorkerManager知道要用我们的DaggerWorkerFactory来创建Worker，有两种方式：

方式一：实现HasDefaultWorkerFactory接口 #

让你的Application类实现HasDefaultWorkerFactory，并返回注入的DaggerWorkerFactory：

class MyApplication : Application(), HasDefaultWorkerFactory {

    @Inject
    lateinit var daggerWorkerFactory: DaggerWorkerFactory

    override fun onCreate() {
        super.onCreate()
        // 初始化Dagger组件并注入Application
        DaggerAppComponent.create().inject(this)
    }

    override fun getDefaultWorkerFactory(): WorkerFactory {
        return daggerWorkerFactory
    }
}

方式二：手动初始化WorkerManager #

如果你需要更灵活的配置，可以在Application的onCreate中手动初始化WorkerManager：

class MyApplication : Application() {

    @Inject
    lateinit var daggerWorkerFactory: DaggerWorkerFactory

    override fun onCreate() {
        super.onCreate()
        DaggerAppComponent.create().inject(this)

        // 配置WorkerManager使用自定义Factory
        val config = Configuration.Builder()
            .setWorkerFactory(daggerWorkerFactory)
            .build()
        WorkerManager.initialize(this, config)
    }
}

5. 更新Dagger Component #

确保你的AppComponent包含了之前创建的WorkerBindingModule，并且能注入Application和DaggerWorkerFactory：

@Component(modules = [WorkerBindingModule::class, /* 其他你的模块 */])
interface AppComponent {
    fun inject(app: MyApplication)
    // 如果需要直接获取Factory，也可以添加这个方法
    fun daggerWorkerFactory(): DaggerWorkerFactory
}

这样一来，当WorkerManager需要创建MyWorker时，就会通过我们的DaggerWorkerFactory获取到已经注入好依赖的实例，完美解决了框架创建类的注入问题。

内容的提问来源于stack exchange，提问作者Mehdi Jahed Manesh