打开Article.swift并在文件底部添加一个扩展名:

extension Array: URLSessionDecodable where Element == Article {
  init(from output: Data) throws {
    let decoder = JSONDecoder()
    let articlesCollection = try decoder.decode(Articles.self, from: output)
    let articles = articlesCollection.data.map { $0.article }
    self.init(articles)
  }
}

这是你能得到的与Swift扩展的最接近的黑魔法。你应该这样读第一行:“当数组的元素是Article时，扩展数组以符合urlsessiondecodeable。” 在前面，当Element符合协议时，您看到了一个类似的扩展。当讨论的不是一致性而是具体类型时，需要使用 == 操作符来表示该元素 is 该类型，而不是该类型的任何子类型。

在扩展内部，通过将数据解码为Articles来实现协议，然后通过调用不同的array初始化器将其转换为Article的数组。

现在，您可以通过缩短ArticlesViewModel.swift中的大方法链来利用解码。将fetchArticles的代码体改为:

let request = ArticleRequest()
networker.fetch(request)
  .tryMap([Article].init)
  .replaceError(with: [])
  .receive(on: DispatchQueue.main)
  .assign(to: \.articles, on: self)
  .store(in: &cancellables)

当其他人阅读您的代码时，这个新方法应该不会让人感到惊讶。构建并运行项目，以确保一切仍然正常。

Using dependency inversion to test your code

现在您已经有了一个可以工作的网络库，但这并不意味着您已经完成了工作! 为了验证您的库能够工作，并且在重构之后能够继续工作，最好测试您的代码。这个启动项目已经包含了一个测试套件和一个名为ArticleViewModelTests.swift的测试文件。 顾名思义，您将添加一个方法来测试您的视图模型。

但是，在这样做之前，您首先需要使视图模型可测试。可测试类意味着该类与任何可能影响测试结果的外部依赖项解耦。就像实验室里真正的科学家一样，你需要去除所有可能影响结果的外部变量。在你的例子中，外部变量是互联网。

在测试中，您不希望连接到真实服务器。您的测试验证代码是否工作正常。如果服务器宕机或您的机器没有稳定的互联网连接，测试仍然会成功，因为问题不在您的代码。

要将视图模型与Internet分离，需要添加一种方法来注入不同的网络工作者，该网络工作者返回硬编码的数据。这通常称为模拟对象。

首先返回network .swift并添加一个新协议:

protocol Networking {
  func fetch(_ request: Request) -> AnyPublisher<Data, URLError>
}

接下来，您将修改ArticlesViewModel.swift。首先，将networker的声明改为:

private var networker: Networking

然后，向类添加一个初始化式:

init(networker: Networking) {
  self.networker = networker
}

您的视图模型现在不再创建一个networkworker本身，而是在它的初始化式中接收一个Networking实例。这被称为依赖注入:它允许类的消费者将依赖注入到类中。任何使用视图模型的人现在都可以创建自己特定的Networking实现，并将其提供给视图模型，包括您的测试套件。

依赖项注入和依赖项反转是使类与依赖项解耦并使其可测试的关键原则。

您还需要修改ArticlesView.swift，以便将一个网络传递给它的视图模型。将viewModel的声明改为:

@ObservedObject private var viewModel = ArticlesViewModel(
  networker: Networker())

现在，您已经将视图模型与任何外部依赖项完全解耦。此时，项目应该不会出现任何错误。

Testing your view model

既然视图模型是可测试的，就可以开始测试它了! 打开ArticlesViewModelTests.swift。 您还记得前面提到的模拟对象吗? 您现在就可以创建一个。将下面的类添加到文件的顶部，在import语句下面:

class MockNetworker: Networking {
  func fetch(_ request: Request) -> AnyPublisher<Data, URLError> {
    let outputData: Data
  }
}

这个模拟网络将实现Networking协议，但为每个请求返回硬编码的值。 继续执行fetch(_😃，添加以下代码:

switch request {
case is ArticleRequest:
  let article = Article(
    name: "Article Name",
    description: "Article Description",
    image: URL(string: "https://image.com")!,
    id: "Article ID",
    downloadedImage: nil)
  let articleData = ArticleData(article: article)
  let articles = Articles(data: [articleData])
  outputData = try! JSONEncoder().encode(articles)
default:
  outputData = Data()
}

如果传入请求是一个ArticleRequest，您将创建一个假的文章(有时称为存根)并将其编码为JSON数据。

用以下代码完成该方法:

return Just<Data>(outputData)
  .setFailureType(to: URLError.self)
  .eraseToAnyPublisher()

在这里，您创建了编码数据的发布者，并从方法返回它。

有了模拟网络，您就可以使用它来创建将要测试的视图模型实例。在setUpWithError的末尾添加这一行:

viewModel = ArticlesViewModel(networker: MockNetworker())

在运行测试之前，您将创建一个新的视图模型实例并注入stub 网络。

现在，您可以开始编写测试了。已经有一个名为testarticlesarefetchedcorrect的方法。 顾名思义，该方法将验证您的视图模型获取文章并正确解码它们。将以下几行添加到方法中:

XCTAssert(viewModel.articles.isEmpty)
let expectation = XCTestExpectation(description: "Article received")

您将以检查articles数组最初是否为空来开始您的测试。然后，您将设置一个xctestexpect。期望用于测试异步代码。期望将保持测试进行，直到期望被满足或计时器耗尽。

继续写方法:

viewModel.$articles.sink { articles in
  guard !articles.isEmpty else {
    return
  }
  XCTAssertEqual(articles[0].id, "Article ID")
  expectation.fulfill()
}
.store(in: &cancellables)

这是测试的主要部分。在这里，您可以订阅对articles数组的更改，并一直等到它不是空的。然后获取数组的第一个元素，并验证ID是否与MockNetworker中的ID匹配。
如果是这样，您就知道视图模型正确地解码了文章。你也满足了你的期望，告诉测试它可以停止等待。

最后，用以下两行代码完成测试:

viewModel.fetchArticles()
wait(for: [expectation], timeout: 0.1)

您可以调用fetchArticles方法来启动获取和解码过程。您还告诉XCTest等待0.1秒，直到您的期望得到满足。

使用Command-U运行测试套件。

Delegating work

如果你在Swift和iOS中工作过一段时间，我相信你至少实现过一个委托属性。苹果的api和大量的社区库都使用了委托来完成各种任务:

• 将功能转移到不同的对象，将一项工作委托给其他人
• 通知另一个对象状态变化和生命周期事件，例如UITableViewDelegate的tableView(_:didSelectRowAt:)
• 请求委托提供信息，如UIScrollViewDelegate的viewForZooming(in:)
• 添加钩子和方法来影响对象的默认行为

在设计api时，特别是当你有一个执行大量复杂工作的复杂对象时，添加委托是确保你的类足够灵活，以在未来的各种上下文中使用的好方法。

Adding a delegate protocol

您将向networker类添加一个委托协议。

打开network.swift，并在类的顶部添加以下协议:

protocol NetworkingDelegate: AnyObject {
  func headers(for networking: Networking) -> [String: String]

  func networking(
    _ networking: Networking,
    transformPublisher: AnyPublisher<Data, URLError>
  ) -> AnyPublisher<Data, URLError>
}

Delegates是普通的老式Swift协议。但是在创建委托属性时，请记住两个额外的约定。你定义的NetworkingDelegate是从AnyObject继承。正如本章前面提到的，这限制了协议，因此只有类才能遵循它。因为委托通常用于影响类实例的行为，所以委托也是类也是有意义的

您可能还注意到有些奇怪的函数签名。根据苹果api的约定，委托方法有你应该遵循的特定签名。返回值的方法以它们返回的值命名，它们接收源对象(在本例中是Networking实例)作为它们的第一个参数。按照此约定，定义一个方法，该方法返回Networking将用于其所有请求的HTTP头。

另一方面，执行副作用的方法是以delegate的源对象(networking)命名的。第一个参数通常是源对象，而第二个参数可以让您更清楚地了解委托做什么。在本例中，您定义了一个函数，该函数可以在Networking实例将URLSession返回给它的使用者之前，对URLSession发布者执行额外的处理。

接下来，在协议下面添加以下扩展:

extension NetworkingDelegate {
  func headers(for networking: Networking) -> [String: String] {
    [:]
  }

  func networking(
    _ networking: Networking,
    transformPublisher publisher: AnyPublisher<Data, URLError>
  ) -> AnyPublisher<Data, URLError> {
    publisher
  }
}

通过在扩展中实现协议方法，您可以为每个符合协议的类提供默认实现。 这确保了如果他们不想提供实现，他们就不需要实现。

接下来，在Networking内部将委托作为可设置的属性要求公开:

var delegate: NetworkingDelegate? { get set }

在您的代码中有两种Networking的实现。第一个是在您刚刚定义的协议Networker的正下方。向类中添加delegate属性:

weak var delegate: NetworkingDelegate?

第二个实现在ArticlesViewModelTests.swift中。向MockNetworker添加相同的行。

weak references

您会注意到这个变量被标记为weak。 默认情况下，Swift总是在对象之间保持强引用。强引用保证了委托在Networking实例使用它时不会de-initialized。弱引用没有这样的保证:即使Networking保留了对委托的引用，委托照样可被释放。在委托的情况下，您几乎总是希望使用后一种行为。

原因是为了避免循环引用。考虑以下示例:您的ArticlesViewModel拥有一个Networker实例。它还将自己设置为Networker的委托，这意味着Networker现在有一个对视图模型的引用。

现在，两个类都具有对彼此的强引用。Networker不会被释放，除非ArticlesViewModel被释放，反之亦然。这意味着，即使你将视图模型(或网络)设置为nil，它仍然会挂在内存中。这就是为什么必须将其中一个引用设置为弱引用。在这种情况下，就Swift的内存管理而言，两个对象之间只有一个引用。 因此，删除一个对象将触发另一个对象的删除，从而完全释放内存。

Using the delegate

接下来，回到network .swift。现在Networker可以访问委托了，现在可以使用它了。在fetch(_😃中，在return之前添加以下行:

urlRequest.allHTTPHeaderFields = delegate?.headers(for: self)

确保请求委托将header添加到URLRequest中。接下来，将函数的其余部分替换为以下内容:

let publisher = URLSession.shared
  .dataTaskPublisher(for: urlRequest)
  .compactMap { $0.data }
  .eraseToAnyPublisher()

if let delegate = delegate {
  return delegate.networking(self, transformPublisher: publisher)
} else {
  return publisher
}

不是直接返回发布者，而是将其存储在一个变量中。创建发布者之后，如果存在委托，则调用委托方法来转换发布者。如果没有，你可以直接返回发布者。

现在是时候实现委托协议了。打开ArticlesViewModel.swift，并在文件底部添加一个扩展名:

extension ArticlesViewModel: NetworkingDelegate {
  func headers(for networking: Networking) -> [String: String] {
    return ["Content-Type": "application/vnd.api+json; charset=utf-8"]
  }
}

让视图模型成为委托。您还可以实现header (for:)方法，在该方法中返回API所期望的有效Content-Type头。

接下来，在扩展中添加另一个方法:

func networking(
  _ networking: Networking,
  transformPublisher publisher: AnyPublisher<Data, URLError>
) -> AnyPublisher<Data, URLError> {
  publisher.receive(on: DispatchQueue.main).eraseToAnyPublisher()
}

一开始可能看起来很奇怪，但这里有许多使用它的方法之一。在本例中，因为视图模型总是更新@Published值，而且这些更新必须发生在主线程上，所以您要确保将networkworker中的每个发布者转换为使用主线程。这种方法还可以用于日志记录、解码、重路由请求和一堆其他任务。最好的委托方法是灵活的，因为您不能总是预测未来的需求。

让视图模型成为委托还有最后一步。在**init(networker:)**的底部添加一行代码:

self.networker.delegate = self

这将视图模型设置为网络工作者的委托。现在你在委托中转换了每个发布者，你可以删除fetchArticles和**fetchImage(for:)**中的两个.receive(on: DispatchQueue.main)行。

最后一次运行项目，确保一切都能像以前一样工作。

Key points

• 协议允许您从具体类型中抽象出信息，允许您在同一位置使用更多类型。
• 您可以使用扩展扩展现有类型以符合协议，甚至限制特定子类型的一致性。
• 协议使用动态分派来实现函数调用，但协议扩展中定义的方法没有声明为协议必要方法。
• Swift将为Equatable, Hashable, Comparable和两种可编码协议，Encodable和Decodable 自动生成协议一致性。
• 依赖倒置是一种通过使用协议类型而不是具体实现来声明依赖项，从而使代码更加灵活的技术。
• 使用依赖倒置和依赖注入可以使代码更可测试。
• 将委托添加到复杂的类中，以赋予它们更多的灵活性。这样做时，请记住强引用循环，并使用弱引用来避免它们。