如何在Dagger2的AppComponent中动态添加测试模块？

我完全理解你的困扰——既要保留AppComponent继承AndroidInjector带来的自动注入便利，又想在测试时灵活替换或添加模块，不用每次都硬编码修改TestAppComponent的注解列表。这里有几个实用的解决方案，不需要改动你原有的AppComponent结构：

方案1：给TestAppComponent的Builder添加可配置模块方法 #

Dagger的@Component.Builder允许你覆盖组件注解中声明的模块实例，只要你在Builder中定义对应模块类型的方法。这样即使TestAppComponent继承了ApplicationComponent的模块，你也能在测试时动态传入测试模块。

步骤1：修改TestAppComponent的Builder #

@Singleton
@Component(modules = [
    MainModule::class,
    AnalyticsModule::class,
    MainAndroidBinding::class,
    AccountAndroidBinding::class,
    AndroidSupportInjectionModule::class,
    HomeAndroidBinding::class,
    NetworkModule::class
])
interface TestAppComponent : ApplicationComponent {
    fun inject(launchActivityTest: LaunchActivityTest)

    @Component.Builder
    interface Builder {
        @BindsInstance
        fun application(applicaton: Application): Builder
        
        // 添加可替换的模块方法，参数为原模块类型
        fun mainModule(module: MainModule): Builder
        fun analyticsModule(module: AnalyticsModule): Builder
        fun networkModule(module: NetworkModule): Builder
        // 其他需要替换的模块同理
        
        fun build(): TestAppComponent
    }
}

步骤2：测试时动态传入测试模块 #

在LaunchActivityTest的setUp方法中，你可以自由选择要替换的模块：

@Before
fun setUp() {
    val app = InstrumentationRegistry.getTargetContext().applicationContext as MyApplication
    val testAppComponent = DaggerTestAppComponent.builder()
        .application(app)
        .mainModule(MainModuleTest()) // 替换原MainModule
        .analyticsModule(AnalyticsModuleTest()) // 替换原AnalyticsModule
        .networkModule(NetworkModuleTest()) // 替换原NetworkModule
        .build()
    app.applicationComponent = testAppComponent
    testAppComponent.inject(this)
}

优点：无需改动原MyApplication和AppComponent，仅需修改测试组件的Builder，实现成本低。

方案2：通过子类化MyApplication动态配置组件 #

如果需要更灵活的组件构建逻辑，可以通过子类化MyApplication，让测试代码能自定义组件的创建过程。

步骤1：修改MyApplication，开放组件创建逻辑 #

open class MyApplication : DaggerApplication() {
    companion object {
        private lateinit var application: MyApplication
        fun get(): MyApplication = application
    }

    @Inject lateinit var dispatchingActivityInjector: DispatchingAndroidInjector<Activity>
    lateinit var applicationComponent: ApplicationComponent

    override fun onCreate() {
        super.onCreate()
        application = this
    }

    // 开放组件创建逻辑，允许子类重写
    open fun createApplicationComponent(): AndroidInjector<out DaggerApplication> {
        return DaggerApplicationComponent.builder()
            .application(this)
            .build()
    }

    override fun applicationInjector(): AndroidInjector<out DaggerApplication> {
        applicationComponent = createApplicationComponent() as ApplicationComponent
        applicationComponent.inject(this)
        return applicationComponent
    }

    override fun attachBaseContext(base: Context?) {
        super.attachBaseContext(base)
        MultiDex.install(this)
    }
}

步骤2：创建测试用Application子类 #

class TestMyApplication : MyApplication() {
    private var componentFactory: ((Application) -> ApplicationComponent)? = null

    // 允许测试代码设置自定义组件工厂
    fun setComponentFactory(factory: (Application) -> ApplicationComponent) {
        componentFactory = factory
    }

    override fun createApplicationComponent(): AndroidInjector<out DaggerApplication> {
        // 优先使用测试提供的工厂，否则用默认逻辑
        return componentFactory?.invoke(this) ?: super.createApplicationComponent()
    }
}

步骤3：测试时配置自定义组件 #

@Before
fun setUp() {
    val app = InstrumentationRegistry.getTargetContext().applicationContext as TestMyApplication
    // 自定义组件构建逻辑，按需添加测试模块
    app.setComponentFactory { appInstance ->
        DaggerTestAppComponent.builder()
            .application(appInstance)
            .mainModule(MainModuleTest())
            .analyticsModule(AnalyticsModuleTest())
            .build()
    }
    // 重新初始化组件
    app.applicationInjector()
    val testAppComponent = app.applicationComponent as TestAppComponent
    testAppComponent.inject(this)
}

优点：完全解耦测试组件的构建逻辑，适合复杂测试场景（比如不同测试用例使用不同模块组合）。

关键原理说明 #

当你的TestAppComponent继承ApplicationComponent时，Dagger会自动继承父组件的模块声明，但Builder中提供的模块实例会优先于注解中声明的模块。这意味着你不需要移除父组件的模块，只需要在Builder中定义对应方法，就能用测试模块替换原模块。

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