Dagger2如何在运行时条件选择模块？Android多场景适配问询

别担心，Dagger2不仅能完美适配你的需求，还能解决你之前用Guice遇到的性能问题——毕竟它是编译时生成注入代码，完全没有运行时反射的开销。下面我会一步步告诉你怎么实现你要的运行时逻辑判断：

1. 先在应用启动时收集设备信息，传递给Dagger组件 #

首先，你需要把操作系统版本、设备厂商这些运行时参数封装成一个类，然后在Application的onCreate()里初始化它，再通过Dagger的组件构建器传递进去。

举个例子，先定义一个封装设备信息的数据类：

data class DeviceContext(
    val osSdkVersion: Int,
    val manufacturer: String
)

然后创建你的Dagger组件，用@Component.Builder和@BindsInstance来接收这个运行时参数：

@Component
interface AppComponent {
    // 注入你的Application或者其他需要依赖的类
    fun inject(app: MyApplication)

    @Component.Builder
    interface Builder {
        // 绑定运行时的DeviceContext实例
        @BindsInstance
        fun deviceContext(context: DeviceContext): Builder
        fun build(): AppComponent
    }
}

接下来在Application的启动流程中初始化组件：

class MyApplication : Application() {
    lateinit var appComponent: AppComponent

    override fun onCreate() {
        super.onCreate()
        // 收集设备信息
        val deviceContext = DeviceContext(
            osSdkVersion = Build.VERSION.SDK_INT,
            manufacturer = Build.MANUFACTURER
        )
        // 构建Dagger组件并传入参数
        appComponent = DaggerAppComponent.builder()
            .deviceContext(deviceContext)
            .build()
        // 注入Application本身（如果需要）
        appComponent.inject(this)
    }
}

2. 根据运行时参数提供不同的依赖实例 #

有了DeviceContext之后，你就可以在Dagger的Module里写@Provides方法，根据参数判断返回不同的实现类。

比如你需要不同的网络处理类：

@Module
class NetworkModule {
    @Provides
    fun provideNetworkHandler(deviceContext: DeviceContext): NetworkHandler {
        return when {
            // 针对Android 13+返回特定实现
            deviceContext.osSdkVersion >= Build.VERSION_CODES.TIRAMISU -> Android13NetworkHandler()
            // 针对三星设备返回定制实现
            deviceContext.manufacturer.equals("Samsung", ignoreCase = true) -> SamsungNetworkHandler()
            // 默认实现
            else -> DefaultNetworkHandler()
        }
    }
}

别忘了把这个Module加到你的AppComponent里：

@Component(modules = [NetworkModule::class])
interface AppComponent {
    // ... 之前的代码
}

3. 复杂判断场景：用工厂模式配合Dagger #

如果你的判断逻辑特别复杂（比如多个条件组合），单独写在Module里会显得混乱，这时候可以用工厂类来封装逻辑，让Dagger注入工厂需要的所有依赖，再由工厂来创建实例。

比如一个功能模块的工厂：

class FeatureFactory @Inject constructor(
    private val deviceContext: DeviceContext,
    // 注入所有可能用到的实现类
    private val defaultFeature: DefaultFeature,
    private val huaweiFeature: HuaweiFeature,
    private val android14Feature: Android14Feature
) {
    fun createFeature(): Feature {
        return when {
            deviceContext.osSdkVersion >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE -> android14Feature
            deviceContext.manufacturer.equals("Huawei", ignoreCase = true) -> huaweiFeature
            else -> defaultFeature
        }
    }
}

之后在需要使用Feature的地方，直接注入FeatureFactory，调用createFeature()就能拿到符合当前设备的实例了。

为什么Dagger2比Guice更适合你？ #

• 性能更优：编译时生成代码，没有Guice的运行时反射开销，正好解决你之前的性能痛点
• 编译时校验：依赖注入的错误会在编译阶段就暴露出来，不用等到运行时才发现问题
• 灵活性足够：不管是简单的条件判断还是复杂的多场景适配，都能通过Module、工厂模式轻松实现

总的来说，Dagger2完全能支撑你的单一APK多场景适配需求，启动时的配置逻辑也能完美实现。

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