[翻译]Swift中的依赖注入

2020-12-04 本文已影响0人 Grabin

IMG_7762.PNG

原创作者：Juan Cazalla
原文链接：Dependency injection in Swift
翻译：Grabin

在使用面向对象编程(OOP)开发应用程序时，您将意识到，如果希望能够测试软件，则需要使用控制反转(IoC)原则。通常，为了实现这一点，我们使用依赖注入模式(Dependency Injection)，该模式包括为每个类提供所需的依赖。

在本文中，我将展示一种在Swift中实践此模式的方法，以便轻松模拟图形的某些依赖关系。

即使您不关心测试应用程序，我也建议您在代码中应用此原则，随着项目规模的扩大，就能够感受这种方式带来的好处。

在构造函数中使用默认值

在Swift中，我们可以通过在构造函数中使用默认值来实现注入。

class ContactsRepository {
    let contactsDataSource: ContactsDataSource

    init(contactsDataSource: ContactsDataSource = NetworkContactsDataSource()) {
        self.contactsDataSource = contactsDataSource
    }
}

很容易吧？起初，这似乎是个好主意，因为它提高了可测试性，并且易于实现参数注入，但这也带来一些问题。这个解决方案的主要问题是与依赖项的默认构造函数紧密耦合。想象一下，您想编写一个UI测试，在其中使用test double(测试替身)模拟HTTP响应。在这种情况下，您将需要提供此 UIViewController 的所有依赖关系，因为您不能再使用默认构造函数。这是浪费时间，对吧？

DIP & Swinject

根据上面讨论的问题，我决定尝试一些替代方法，例如 Dip 或 Swinject。这两个框架实际上非常相似。它们是依赖性容器，您可以在它里面使用闭包注册以解决依赖性。从较高的层面看，他们的工作是将这些闭包存储在字典中，并在需要实例化服务时使用它。因此，要解决该问题，您只需要用测试替身(mock类/实体)override需要替换的所有内容即可。

但是，这些框架有一些缺点，例如：

依赖关系是在runtime时构建的，因此，如果您忘记注册如何解析依赖项，则应用程序将在运行时崩溃。
由于需要在使用依赖项之前先注册它们，因此如果在启动时进行加载，则加载应用程序将花费更长的时间。
解决依赖项时，需要使用强制解包（Swinject）或 try（Dip）。
在我看来，最糟糕的问题是，如果您需要在运行时传递参数，这些参数是不会传入的，并且不会自动完成。这会很容易导致出错，只需更改依赖关系的顺序，应用程序就会在运行时崩溃。

因此，我决定不使用它们，而是找到一个适合我的用例的解决方案，而又不影响性能，又不会失去由于Swift编译器而获得的安全性。

解决方案

我提出的解决方案中以下几点您应该会喜欢的：

注入了解决依赖关系所需的参数，因此您不会出错。
如果忘记定义如何实例化对象，则该应用将无法编译。
应用程序的性能不受影响。您无需在运行时注册解析依赖关系。
处理可选值并不难，因为它可以在Swinject或Dip中进行。
您不需要使用任何外部库。依赖项注入器会影响整个代码库，并且与第三方库的依赖项存在风险。

为了实现它，该解决方案使用了一些Swift功能，例如类型推断和协议扩展。让我们看一个简单的例子。

创建一个用于demo的代表 superheroes 的结构体：

struct SuperHero {
    let name: String
}

我们可以定义一个为您提供超级英雄实例并使用 extension 默认实现的协议。我们将其命名为SuperHeroAssembler：


protocol SuperHeroAssembler {
     func resolve() -> SuperHero
}

extension SuperHeroAssembler {
     func resolve() -> SuperHero {
         return SuperHero(name: "Iron Man")
     }
}

现在，我们可以使用它来 resolve SuperHero实例：


class AppAssembler: SuperHeroAssembler { }

let assembler: SuperHeroAssembler = AppAssembler()

let superHero: SuperHero = assembler.resolve()

print(superHero.name) // Iron Man

那我们如何在测试中模拟它？好吧，这确实很容易，我们只需要创建一个符合 SuperHeroAssembler 的新类，但具有不同的resolve函数即可。让我们看看如何实现它：

class TestAssembler: SuperHeroAssembler { }

extension SuperHeroAssembler where Self: TestAssembler {
    func resolve() -> SuperHero {
        return SuperHero(name: "Test SuperHero!")
    }
}

let testAssembler: SuperHeroAssembler = TestAssembler()

let testSuperHero: SuperHero = testAssembler.resolve()

print(testSuperHero.name) // Test SuperHero!

也许通过这样一个简单的示例，您看不到任何优势，但是如果使用得当，此想法将非常有用。让我们看一个更详细的用例的例子，看看它是如何工作的。

在实际开发工作中怎么去使用？

想象一下，现在需要在一个页面中显示给定用户的所有联系人。联系人来自网络，我们希望能够在验收测试中使用双重测试。

为此，我们使用以下类：

class ContactsListViewController: UIViewController {
    private let presenter: ContactsListPresenter

    init(presenter: ContactsListPresenter) {
        self.presenter = presenter
        super.init(nibName: nil, bundle: nil)
        self.presenter.ui = self
    }

    // View controller logic
}

extension ContactsListViewController: ContactsListUI {
    func show(contacts: [Contact]) {
        // Logic to show contacts list
    }
}

protocol ContactsListUI {
    func show(contacts: [Contact])
}

class ContactsListPresenter {
    weak var ui: ContactsListUI?
    private let getAllContacts: GetAllContacts

    init(getAllContacts: GetAllContacts) {
        self.getAllContacts = getAllContacts
    }

    // Presenter logic
}

class GetAllContacts {
    private let contactsDataSource: ContactsDataSource

    init(contactsDataSource: ContactsDataSource) {
        self.contactsDataSource = contactsDataSource
    }

    // Use case functions
}

class GetAllContacts {
    private let contactsDataSource: ContactsDataSource

    init(contactsDataSource: ContactsDataSource) {
        self.contactsDataSource = contactsDataSource
    }

    // Use case functions
}

protocol ContactsDataSource {
    func getAll() -> [Contact]
}

class NetworkContactsDataSource: ContactsDataSource {
    func getAll() -> [Contact] {
        return [Contact(name: "Network Contact")]
    }
}

为了定义如何解决依赖关系，我们将针对该用例使用一个汇编器，我将其称为ContactsSceneAssembler。在此汇编器中，我们将具有一个能够解析所需的每种类型的函数。


class Assembler: ContactsSceneAssembler { }

protocol ContactsSceneAssembler {
    func resolve(user: User) -> ContactsListViewController
    func resolve(user: User) -> ContactsListPresenter
    func resolve() -> GetAllContacts
    func resolve() -> ContactsDataSource
}

extension ContactsSceneAssembler {
    func resolve(user: User) -> ContactsListViewController {
        // Nice! We can and must use the assembler itself to resolve the dependencies
        return ContactsListViewController(presenter: resolve(user: user))
    }

    func resolve(user: User) -> ContactsListPresenter {
        return ContactsListPresenter(user: user, getAllContacts: resolve())
    }

    func resolve() -> GetAllContacts {
        return GetAllContacts(contactsDataSource: resolve())
    }

    func resolve() -> ContactsDataSource {
        return NetworkContactsDataSource()
    }
}

如您所见，我们可以（并且必须）重用汇编器本身来解决依赖关系。另一个很棒的事情是，我们在运行时知道函数的输入参数及其类型。因此，当您编写自动完成功能时，便可以完成大部分工作。

现在，如果要创建 ContactsListViewController，我们只需要提供 user 给 assembler 来 resolve 它。


let contactsListViewController: ContactsListViewController = assembler.resolve(user: user)

正如我们在第一个示例中看到的那样，可以很容易地使用mock实体来代替 NetworkContactsDataSource。您只需要创建一个assembler，即可在其中将 resolve() 返回的 ContactsDataSource 对象替换掉：

class TestAssembler: ContactsSceneAssembler {
    func resolve() -> ContactsDataSource {
        return StubContactsDataSource()
    }
}

这样做会使我们的代码更加灵活！

[翻译]Swift中的依赖注入

在构造函数中使用默认值

DIP & Swinject

解决方案

在实际开发工作中怎么去使用？

猜你喜欢

热点阅读