什么是依赖注入。

2023-12-15 16:05:27

首先理解什么是依赖倒置

依赖倒置原则(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 对象,而不需要手动传递。这样,框架会负责创建和管理依赖的实例。这是一种更灵活、易于测试和扩展的依赖注入方式。

文章来源:https://blog.csdn.net/qq_28909387/article/details/135016357
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。