在本文中，我将介绍依赖注入的基础知识，以及如何使用Swinject框架将依赖注入应用到iOS项目中。

什么是依赖

依赖是我们代码中两个模块之间的耦合（在面向对象语言中，指的是两个类），通常是其中一个模块使用另外一个提供的功能。

依赖有什么不好？

从上层到底层依赖都是危险的，因为我们在某种程度上把两个模块进行耦合，这样当需要修改其中一个模块时，我们必须修改与其耦合的模块的代码。这对于创建一个可测试的app来说是很不利的，因为单元测试要求测试一个模块时，要保证它和app中其他模块是隔离的。

举个例子

class Module1{
   var module2:Module2 

   init (){
      module2 = Module2()
   }

   func doSomething(){
      ...
      module2.doSomethingElse();
      ...
   } 
}

如何在不测试doSomethingElse函数的前提下测试doSomething函数呢？如果测试失败，是哪个函数导致的呢？我们不得而知。如果doSomethingElse函数在数据库中保存数据或者向服务器端发起API请求，那么事情将变得更加糟糕。

每当敲下new关键字我们都应该意识到这可能是需要避免的强依赖。编写更少的模块也不是解决方案，不要忘记单一职责原则。

依赖反转

如果不能在一个模块内部初始化另外的模块，那么需要以其他的形式初始化这些模块。你能想象如何实现吗？没错，通过构造函数。这基本上就是依赖反转原则的涵义了。你不应该依赖具体的模块对象，应该依赖抽象。

前面的代码应该修改为：

 class Module1{
   var module2:Module2 

   init(module2: Module2){
      self.module2 = module2
   }

   func doSomething(){
      ...
      module2.doSomethingElse();
      ...
   } 
}

什么是依赖注入呢?

依赖注入(Dependency Injection, DI)是一种技术，在这种技术中，可以从实体自身的范围之外设置实体的依赖项，将整个系统转换为松散耦合的模块。想象一下，我们可以提供一个模块，这个模块包含了对应用程序其他组件的引用，这样你就可以避免UIViewController之间的通信模式。

从上面的例子我们知道，通过构造函数传递依赖（注入），从而把创建模块的任务从另一个模块内部抽离出来。对象在其他地方创建，并以构造函数参数的形式传递给另一个对象。

但新问题出现了。如果我们不能在模块内部创建其他的模块，那么必须有个地方对这些模块进行初始化。另外，如果我们需要创建的模块的构造函数包含大量的依赖参数，代码将变得丑陋和难以阅读，app中将存在大量传递的对象。依赖注入正是为解决这类问题而诞生的。

我们需要在app中提供另一个模块，专门负责提供其他模块的实例并注入他们的依赖，这个模块就是依赖注入器，模块的创建集中于app中的一个统一的入口。

还是举个例子来说明问题吧。

首先，如果没有进行依赖注入的情况

第一步，创建Cat类：

class Cat {
    let name: String

    init(name: String) {
        self.name = name
    }

    func sound() -> String {
        return "Miao !"
    }
}

第二步，创建Person类：

class Person {
    let pet = Cat(name: "nimo")

    func play() -> String {
        return "I'm playing with \(pet.name). \(pet.sound())"
    }
}

Person类中关联了Cat类属性。

实际使用：

let per = Person()
print(per.play())

输出：

// 输出 "I'm playing with nimo. Miao!"

问题来了，如果我不想养猫，我想养狗了，那我是不是就得新建一个Person2，关联一个Dog类呢？
所以必须要对两个类的依赖进行解耦, 并且改变为依赖抽象，这样之后再进行依赖替换的时候就很容易了。

其次，我们来尝试解耦

第一步，我们先将宠物抽象成一个接口协议，使用者不用具体实现，只是依赖这个协议即可：

protocol AnimalType {
    var name: String { get }
    func sound() -> String
}

第二步，让 Cat 类实现这个协议:

class Cat: AnimalType {
    let name: String

    init(name: String) {
        self.name = name
    }

    func sound() -> String {
        return "Miao!"
    }
}

第三步，Person中关联一个依赖于AnimalType的pet，而非Cat的具体实现，并构造一个初始化方法，将pet传入：

class Person {
    let pet: AnimalType

    init(pet: AnimalType) {
        self.pet = pet
    }

    func play() -> String {
        return "I'm playing with \(pet.name). \(pet.sound())"
    }
}

具体使用：

let catPerson = Person(pet: Cat(name: "nimo"))
print(catPerson.play()) // 输出 "I'm playing with nimo. Miao!"

如果换成养狗，则创建个Dog：

class Dog: AnimalType {
    let name: String

    init(name: String) {
        self.name = name
    }

    func sound() -> String {
        return "wwww!"
    }
}

具体使用：

let dogPerson = Person(pet: Dog(name: "hah"))
print(dogPerson.play()) // 输出 "I'm playing with hah. wwww!"

以上是通过抽象出一个接口协议，代替了具体实现，如果项目中依赖关系多且复杂，使用Swinject进行依赖注入就比较方便了。

最后，我们使用Swinject来进行依赖注入

Swinject是一个很棒的用于Swift项目的DI框架，而且它是开源的。它使用泛型以一种非常简单的方式解耦你的代码。

第一步，通过CocoaPods将其添加到您的项目中：

pod ‘Swinject’

导入：

import Swinject

第二步，包装container，放到一个统一的类中：

import Swinject
class DIContainer {
    static let container:Container = {
        let con = Container()
        con.register(AnimalType.self) { _ in  Cat(name: "Nimo") }
        con.register(Person.self) { r in
           Person(pet: r.resolve(AnimalType.self)!)
        }
        return con
    }()
}

第三步，具体使用：

    let container = DIContainer.container
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let per = container.resolve(Person.self)!
        print(per.play())
    }