文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

swift依赖注入和依赖注入容器详解

2023-01-28 12:03

关注

什么是控制反转(Inversion of Control)?

控制反转就是把传统的控制逻辑委托给另一个类或框架来处理,客户方只需实现具体的任务而不需要关心控制逻辑。

举个例子,比如存在客户方和服务方两个类,客户方需要调用服务方的函数来执行某个逻辑。在传统的编程方式中,客户方根据自己的需求直接去调用服务方的函数从而达到目的。而控制反转,则是把控制逻辑交给服务方,服务方提供了一个控制流的框架,具体的内容需要由客户方来填充,也就是说对流程的控制反转了,现在是服务方调用客户方。据说好莱坞有句名言 Don't call us, we'll call you,差不多就是这个意思。以上的服务方也可以是库代码或者框架。

在 iOS 开发中,有一个非常常见的控制反转的实现,可能很多人都没有意识到这个就是控制反转,那就是 completionHandler,或者说 callback。

API.request(completion: { data in
    handleData(data)
})

在这个例子中,业务方只需要关系拿到数据以后干什么,而不关心 completion 的调用时机,把 completion 的调用委托给了网络库,这就是控制反转。

控制反转可以让主要任务和控制逻辑分离,可以提升代码的模块性和扩展性,让代码松耦合,并可以让写测试代码变得简单。

常见的控制反转的实现有:

本文仅讨论依赖注入这种实现,暂不讨论其他的实现。

什么是依赖注入?

依赖注入是控制反转的一种具体实现。它在类的外部创建这个类的依赖对象,然后通过某个方式把这个依赖对象提供给类。通过依赖注入,把依赖对象的创建和绑定都移动到了类的外部。

先看下面的例子:

class Car {
    var tyres: [Tyre]
    init() {
        let tyre1 = Tyre()
        let tyre2 = Tyre()
        let tyre3 = Tyre()
        let tyre4 = Tyre()
        tyres = [tyre1, tyre2, tyre3, tyre4]
    }
}

这个例子中构建了一个汽车对象,汽车对象的构建需要拼装 4 个轮胎。这个代码的缺点显而易见,就是轮胎的创建逻辑和汽车本身耦合了。当我们想换成另一种轮胎时,或者 Tyre 类调整了实现在构造时添加了一个参数,都必须改动 Car 类中的代码。

用依赖注入的方式,把依赖对象的创建和绑定挪到类外部,就能解决这类问题。

class Car {
    var tyres: [Tyre]
    init(types: [Tyre]) {
        self.types = types
    }
}

再举个例子,App 开发中常见的网络请求 -> 数据处理 -> 数据渲染流程,传统方式开发如下:

// DataViewModel.swift
func loadData() {
    API.requestData(id: 2222, completion: { data in 
        self.handleData(data)
    })
}

这样的代码是无法测试的,因为 ViewModel 和具体的网络请求实现耦合了。为了让 loadData 这个方法可以被测试,应该抽象一个网络请求的接口,然后从外部注入这个接口的实现。如下代码:

protocol Networking {
    func requestData(id: Int, completion: (Data) -> Void)
}

让 DataViewModel 拥有一个需要注入的属性对象:

class DataViewModel {
    let networking: Networking
    init(networking: Networking) {
        self.networking = networking
    }
}

loadData 方法修改如下:

func loadData(completion: (() -> Void)?) {
    networking.requestData(id: 2222, completion: { data in
        self.handleData(data)
    })
}

这样把具体的网络请求实现转移到外部注入,在测试的时候就可以简单的实现一个模拟的网络请求,这样就可以写出测试代码:

func testLoadData() {
    let networking = MockNetworking()
    let viewModel = DataViewModel(networking: networking)
    let expectation = XCTestExpectation()
    viewModel.loadData {
        expectation.fulfill()
    }
    wait(for: [expectation], timeout: .infinity)
    XCTAssertTrue(viewModel.data.xxxx)
}

依赖注入最大的优点就是实现了类之间的解耦。什么叫解耦,解耦就是两个类之间虽然存在一些依赖关系,但是当其中任何一个类的实现发生改变时,另一个类的实现完全不受影响,解耦本身是通过抽象接口来实现的,因此依赖注入也需要抽象接口,并且依赖注入将依赖的创建转移到了客户类的外部,把依赖的创建逻辑也和客户类本身解耦。这样无论是替换依赖对象的实现类,还是替换依赖对象类实现中的某个部分,客户方类都不需要做任何修改。

依赖注入的种类

依赖注入主要通过初始化器注入、属性注入、方法注入、接口注入等方式来进行注入。

初始化器注入

初始化器注入就是通过初始化方法的参数来给对象提供依赖。初始化器注入是最常用的注入方式,它简单直观,当一个对象依赖的对象的生命周期和对象自身相同时,使用初始化器注入是最好的方式。

class ClientObject {
    private var dependencyObject: DependencyObject
    init(dependencyObject: DependencyObject) {
        self.dependencyObject = dependencyObject
    }
}

属性注入

属性注入是通过对象的公开属性来给对象提供依赖,也可以叫 setter 注入。一般在无法使用初始化器注入时(例如使用了 Storyboard),或者依赖对象的生命周期小于对象时使用。

public class ClientObject {
    public var dependencyObject: DependencyObject
}
let client = ClientObject()
client.dependencyObject = DefaultDependencyObject()

方法注入

方法注入的方式是对象需要实现一个接口,这个接口中声明了能给对象提供依赖的方法。注入器通过调用这个方法来给对象提供依赖。方法注入也可以叫接口注入。

protocol DependencyObjectProvider {
    func dependencyObject() -> DependencyObject
}

有时客户方只在某些特定的条件下才需要使用依赖,这时可以用方法注入,客户方仅仅在需要使用依赖的时候才会去调用方法来创建依赖对象,这样避免了客户方在不使用依赖的时候依赖对象也被创建出来占用内存空间的问题。这一点也可以通过注入一个代码块来实现:

init(dependencyBuilder: () -> DependencyObject) {
    self.dependencyBuilder = dependencyBuilder
}

依赖注入容器

依赖注入要求对象的依赖在对象外部创建并通过某种方式注入到对象中。如果每次创建对象时都去创建一遍对象的依赖,会让代码变得重复和复杂,当对象的依赖调整时,每个地方都需要做改动。因此通常使用依赖注入时,也需要一个依赖注入容器(Dependency Injection Container)。

依赖注入容器用来统一地管理依赖对象的创建和生命周期,也可以根据需要给对象注入依赖。

依赖注入容器要提供以下的功能:

实现一个简单的依赖注入容器

有很多第三方依赖注入框架实现了依赖注入的功能,例如 Swift 语言的 Swinject。我们也可以自己实现一个依赖注入容器。

按照依赖注入容器的定义,并借助 Swift 的泛型和协议,可以定义以下协议:

protocol DIContainer {
    func register<Component>(type: Component.Type, component: Any)
    func resolve<Component>(type: Component.Type) -> Component?
}

具体实现如下:

final class DefaultDIContainer: DIContainer {
    static let shared = DefaultDIContainer()
    private init() {}
    var components: [String: Any] = [:]
    func register<Component>(type: Component.Type, component: Any) {
        components["\(type)"] = component
    } 
    func resolve<Component>(type: Component.Type) -> Component? {
        return components["\(type)"] as? Component
    }
}

有了这个 DIContainer,在使用时可以选择两种方式,一种是在外部 resolve 对象并注入。

let object = DIContaienr.shared.resolve(Data.self)
let viewModel = ViewModel(dependencyObject: object)

一种是在初始化方法的参数默认值中 resolve:

class ViewModel {
    init(dependencyObject: DependencyObject = DIContainer.shared.resolve(Data.self))
    self.dependencyObject = dependencyObject
}

这两种方式各有一些使用场景,可以根据具体情况选用。

以上的 DIContainer 只是一个简单的实现,结合具体需求,可以添加上线程安全、Storyboard 注入,自动解析等功能,可参考 Swinject。

总结

依赖注入在很多领域都是常见的设计模式,例如 Java Spring 等,无论做哪个方向的开发,依赖注入都是一定要掌握的。在合适的时候使用依赖注入,可以让代码解耦,提高代码的可测试性、可扩展性。

参考资料

以上就是swift依赖注入和依赖注入容器详解的详细内容,更多关于swift依赖注入依赖注入容器的资料请关注编程网其它相关文章!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯