Android纯Java环境下Dagger2结合WorkManager依赖注入问题

我之前也遇到过类似的问题，纯Java环境下用Dagger2.8（没有android-dagger扩展）给WorkManager注入Room实例确实踩了不少坑，下面是亲测可行的完整方案：

核心思路 #

WorkManager默认的WorkerFactory只会调用Worker的(Context, WorkerParameters)构造函数，不会自动处理Dagger注入。所以我们需要：

• 自定义WorkerFactory，通过它拿到AppComponent的实例来手动注入依赖
• 让Worker的构造函数接收需要的依赖（比如你的DBModel）
• 在Application中初始化WorkManager时指定我们的自定义Factory

步骤1：确保AppComponent能提供DBModel #

首先要保证你的AppComponent和对应的Module能正确提供DBModel实例：

AppComponent定义 #

@Component(modules = {AppModule.class, RoomModule.class})
@Singleton
public interface AppComponent {
    // 暴露DBModel供外部注入使用
    DBModel dbModel();

    // 可选：注入到Application（如果需要）
    void inject(MyApplication application);
}

RoomModule（提供DBModel） #

@Module
public class RoomModule {
    private final Context appContext;

    public RoomModule(Context context) {
        this.appContext = context;
    }

    @Provides
    @Singleton
    DBModel provideDBModel() {
        // 这里替换成你的Room数据库初始化逻辑
        return Room.databaseBuilder(appContext, DBModel.class, "your-db-name")
                .fallbackToDestructiveMigration()
                .build();
    }
}

步骤2：自定义DaggerWorkerFactory #

这个Factory负责创建Worker实例并注入依赖：

public class DaggerWorkerFactory extends WorkerFactory {
    private final AppComponent appComponent;

    public DaggerWorkerFactory(AppComponent appComponent) {
        this.appComponent = appComponent;
    }

    @Override
    public ListenableWorker createWorker(@NonNull Context appContext, @NonNull String workerClassName, @NonNull WorkerParameters workerParameters) {
        try {
            // 反射获取Worker的构造函数（带Context、WorkerParameters、DBModel三个参数）
            Class<?> workerClass = Class.forName(workerClassName);
            Constructor<?> constructor = workerClass.getDeclaredConstructor(Context.class, WorkerParameters.class, DBModel.class);
            // 传入依赖创建Worker实例
            return (ListenableWorker) constructor.newInstance(appContext, workerParameters, appComponent.dbModel());
        } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            throw new RuntimeException("Failed to initialize worker: " + workerClassName, e);
        }
    }
}

步骤3：改造你的UIUpdaterWorker #

让Worker的构造函数接收DBModel，确保构造函数是public的：

public class UIUpdaterWorker extends Worker {
    private final DBModel dbModel;

    // 必须是public构造函数，否则反射无法调用
    public UIUpdaterWorker(@NonNull Context context, @NonNull WorkerParameters params, DBModel dbModel) {
        super(context, params);
        this.dbModel = dbModel;
        // 现在dbModel应该已经被正确注入，不会为空了
    }

    @NonNull
    @Override
    public Result doWork() {
        // 在这里安全使用dbModel操作数据库
        // 示例：List<User> users = dbModel.userDao().getAllUsers();
        return Result.success();
    }
}

步骤4：在Application中初始化WorkManager #

在自定义Application中初始化Dagger和WorkManager，指定我们的自定义Factory：

public class MyApplication extends Application {
    private AppComponent appComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        // 初始化Dagger AppComponent
        appComponent = DaggerAppComponent.builder()
                .roomModule(new RoomModule(this))
                .build();

        // 配置WorkManager使用自定义Factory
        Configuration workManagerConfig = new Configuration.Builder()
                .setWorkerFactory(new DaggerWorkerFactory(appComponent))
                .build();
        // 初始化WorkManager
        WorkManager.initialize(this, workManagerConfig);
    }

    public AppComponent getAppComponent() {
        return appComponent;
    }
}

步骤5：修改AndroidManifest.xml #

禁用WorkManager的默认初始化，指定我们的Application：

<application
    android:name=".MyApplication"
    ...>

    <!-- 禁用WorkManager默认初始化，使用我们自定义的配置 -->
    <meta-data
        android:name="android.workmanager.integration"
        android:value="2" />

    ...
</application>

关键注意点 #

• 确保AppComponent和DBModel都是单例的，避免重复创建数据库实例
• Worker的构造函数必须是public，否则反射会抛出异常
• 如果有多个不同依赖的Worker，可以扩展DaggerWorkerFactory的反射逻辑，比如缓存构造函数或者处理不同的依赖类型

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