原创作者：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()
}
}
这样做会使我们的代码更加灵活！
