什么是依赖注入。

首先理解什么是依赖倒置

依赖倒置原则（Dependence Inversion Principle，简称DIP）

• 核心思想：高层模块不应该依赖底层模块，二者都该依赖其抽象：抽象不应该依赖细节；细节应该依赖抽象；
• 说明：高层模块就是调用端，低层模块就是具体实现类。抽象就是指接口或抽象类。细节就是实现类。
• 通俗来讲：依赖倒置原则的本质就是通过抽象（接口或抽象类）使个各类或模块的实现彼此独立，互不影响，实现模块间的松耦合。
• 问题描述：类A直接依赖类B，假如要将类A改为依赖类C，则必须通过修改类A的代码来达成。这种场景下，类A一般是高层模块，负责复杂的业务逻辑；类B和类C是低层模块，负责基本的原子操作；假如修改类A，会给程序带来不必要的风险。
• 解决方案：将类A修改依赖接口interface，类B和类C各自实现接口interface，类A通过接口interface间接与类B或者类C发生联系，则会大大降低修改类A的几率。
• 好处：依赖倒置的好处在小型项目中很难体现出来。但在大中型项目中可以减少需求变化引起的工作量。使并行开发更友好。

下面我们用一个简单的例子来说明依赖注入：

假设我们有一个 Car 类和一个 Engine 类，Car 类依赖于 Engine 类来驱动

// 引擎类
class Engine {
? ? fun start() {
? ? ? ? println("Engine is starting.")
? ? }
}

// 汽车类
class Car {
? ? private val engine: Engine

? ? // 构造函数，Car 依赖于 Engine
? ? constructor(engine: Engine) {
? ? ? ? this.engine = engine
? ? }

? ? fun start() {
? ? ? ? engine.start()
? ? ? ? println("Car is starting.")
? ? }
}

// 主函数
fun main() {
? ? // 创建引擎
? ? val engine = Engine()

? ? // 创建汽车并传入引擎
? ? val car = Car(engine)

? ? // 启动汽车
? ? car.start()
}

在上述代码中，Car 类在构造函数中接受一个 Engine 对象，并使用这个对象来启动引擎。这种方式称为构造函数注入，是一种依赖注入的形式。

然而，如果我们使用依赖注入框架（比如 Dagger、Koin 等），我们可以通过配置让框架自动创建和注入依赖，而不需要手动传递。以下是使用 Koin 框架的例子：

// 使用 Koin 框架
import org.koin.core.KoinComponent
import org.koin.core.inject

// 引擎类
class Engine : KoinComponent {
    fun start() {
        println("Engine is starting.")
    }
}

// 汽车类，通过 Koin 的 inject 函数注入引擎
class Car : KoinComponent {
    private val engine: Engine by inject()

    fun start() {
        engine.start()
        println("Car is starting.")
    }
}

// 主函数
fun main() {
    // 使用 Koin 框架配置引擎的实例
    val engineModule = module {
        single { Engine() }
    }
    startKoin {
        modules(engineModule)
    }

    // 创建汽车并启动
    val car = Car()
    car.start()
}

在这个例子中，我们使用了 Koin 框架，并通过 inject 函数注入了 Engine 对象，而不需要手动传递。这样，框架会负责创建和管理依赖的实例。这是一种更灵活、易于测试和扩展的依赖注入方式。