依赖注入和没有依赖注入代码对比，直观理解依赖注入功能

为了直观展示 Dagger Hilt 依赖注入后的代码生成和替换，我们将依赖注入前后的代码进行对比。通过这些对比，你可以更清晰地看到 Dagger Hilt 如何简化依赖管理。

依赖注入前后的代码对比

1. 没有依赖注入的代码

在没有使用依赖注入的情况下，我们需要手动创建和管理依赖对象。

Engine.kt

class Engine {
    fun start() {
        println("Engine started")
    }
}

Car.kt

class Car(private val engine: Engine) {
    fun drive() {
        engine.start()
        println("Car is driving")
    }
}

MainActivity.kt

class MainActivity : AppCompatActivity() {

    private lateinit var car: Car

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val engine = Engine()
        car = Car(engine)

        car.drive()
    }
}

2. 使用 Dagger Hilt 进行依赖注入后的代码

使用 Dagger Hilt 进行依赖注入后，我们不需要手动创建和管理依赖对象，Hilt 会自动处理这些工作。

Engine.kt

class Engine @Inject constructor() {
    fun start() {
        println("Engine started")
    }
}

Car.kt

class Car @Inject constructor(private val engine: Engine) {
    fun drive() {
        engine.start()
        println("Car is driving")
    }
}

AppModule.kt

@Module
@InstallIn(SingletonComponent::class)
object AppModule {

    @Provides
    fun provideEngine(): Engine {
        return Engine()
    }

    @Provides
    fun provideCar(engine: Engine): Car {
        return Car(engine)
    }
}

MyApplication.kt

@HiltAndroidApp
class MyApplication : Application() {
}

MainActivity.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var car: Car

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        car.drive()
    }
}

依赖注入前后的对比分析

1. Engine 类：

   • 依赖注入前：Engine 类是一个普通类，在 MainActivity 中手动实例化。
   • 依赖注入后：使用 @Inject 注解标记构造函数，表明该类可以通过依赖注入进行实例化。

2. Car 类：

   • 依赖注入前：Car 类需要手动传入 Engine 实例，通过构造函数注入。
   • 依赖注入后：使用 @Inject 注解标记构造函数，Hilt 自动管理 Car 的依赖关系，并注入 Engine 实例。

3. MainActivity 类：

   • 依赖注入前：MainActivity 中手动创建 Engine 和 Car 实例，并管理它们的依赖关系。
   • 依赖注入后：使用 @AndroidEntryPoint 注解标记类，通过 @Inject 注解直接注入 Car 实例，Hilt 自动处理 Car 和 Engine 的创建和注入。

4. AppModule 类：

   • 依赖注入前：没有对应的模块类，需要手动管理所有依赖对象的创建。
   • 依赖注入后：创建 AppModule 模块，使用 @Provides 注解的方法提供 Engine 和 Car 的实例，Hilt 负责管理这些依赖的创建和生命周期。

Hilt 的代码生成与替换

Dagger Hilt 在编译时生成必要的代码来处理依赖注入。以下是 Hilt 代码生成和替换的关键点：

1. 生成依赖注入容器：@HiltAndroidApp 注解生成应用级依赖注入容器，并初始化依赖关系。
2. 生成组件和模块：Hilt 解析 @Module 和 @InstallIn 注解，生成组件和模块代码，管理依赖的生命周期和作用域。
3. 生成注入代码：Hilt 生成代码，在运行时根据依赖图注入依赖对象。例如，在 MainActivity 中生成代码，在合适的时机注入 Car 实例。
4. 依赖图：Hilt 分析所有注入点和模块，生成依赖图，表示对象及其依赖关系的有向图，确定对象的创建顺序和依赖关系。

联系我

通过上述对比，可以直观地看到使用 Dagger Hilt 进行依赖注入的优势。Hilt 简化了依赖的创建和管理，减少了手动编写的样板代码，提高了代码的可维护性和可测试性。Hilt 的底层原理通过编译时代码生成和运行时依赖注入，提供了一种模块化、可测试且可维护的依赖管理方式。

为了更清晰地展示上述代码的依赖关系，这里提供一个依赖关系有向图。这个图展示了各个类之间的依赖关系以及 Dagger Hilt 如何管理这些依赖。

有向图说明

• Engine 类：通过 @Inject 注解可以被注入。
• Car 类：依赖 Engine 类，通过 @Inject 注解标记其构造函数。
• AppModule 模块：提供 Engine 和 Car 的实例。
• MainActivity 类：通过 @AndroidEntryPoint 注解标记，注入 Car 实例。

依赖关系有向图

     +----------------+
     |  MyApplication |
     | @HiltAndroidApp|
     +--------+-------+
              |
              v
     +-----------------+
     |   MainActivity  |
     | @AndroidEntryPoint|
     +--------+--------+
              |
              v
     +--------+-------+
     |       Car      |
     | @Inject        |
     +--------+-------+
              |
              v
     +--------+-------+
     |      Engine    |
     | @Inject        |
     +----------------+

图例

1. MyApplication：应用程序类，通过 @HiltAndroidApp 注解触发 Hilt 的初始化。
2. MainActivity：活动类，通过 @AndroidEntryPoint 注解标记，允许 Hilt 在该类中进行依赖注入。它依赖于 Car。
3. Car：业务逻辑类，通过 @Inject 注解标记构造函数，依赖于 Engine。
4. Engine：基础类，通过 @Inject 注解标记构造函数。

这个有向图和代码展示了 Dagger Hilt 如何管理依赖关系，自动创建和注入对象，简化了依赖管理。通过使用 Hilt，开发者可以专注于业务逻辑，而无需手动管理复杂的依赖关系，从而提高代码的可维护性和可测试性。