Combine 框架，从0到1 —

本文首发于 Ficow Shen's Blog，原文地址： Combine 框架，从0到1 —— 1.核心概念。

内容概览

前言
核心概念
RxSwift
Combine
总结
参考内容

前言

未来已来，只是尚未流行！

响应式编程 这个名词已经久负盛名，但是在实际项目中采用了响应式编程的公司其实不多。如果您有 iOS 开发经历，那么您多半听说过 RxSwift，而 Rx 源自微软。提到Rx，往往也会提到源自微软的 MVVM模式。不过，本文不会讲解 MVVM。

由于 Combine 借鉴了 Rx 的思想，二者具有基本相同的特性，所以本文会同时讨论这两个大框架。

而且，如果有必要的话，我们可以通过学习开源的 RxSwift 源码来了解 Combine 的工作原理。您甚至可以这么简单粗暴的认为：Combine 就是苹果官方的 RxSwift。

核心概念

简而言之，Combine 和 Rx 都基于观察者模式，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

只不过，这些框架对这个模式进行了一点扩充，在被观察者与观察者之间引入了可选的转换操作(操作符：Operators)。

采用响应式编程框架的优势与劣势：

优势：

同时支持 一对一、一对多 观察操作，比 代理、通知中心 易用；
常用的操作符可以极大地提高开发效率，如：map, flatMap, filter, reduce, throttle 等；
代码更加优雅、代码量更少；
搭配 MVVM 模式，可以写出更容易测试的 ViewModel；

劣势：

学习成本略高；
调试的难度会提高，有时候甚至需要去阅读框架的源码；
传统的MVC模式无法发挥响应式编程框架的最大威力，需要为项目配备合适的架构模式，比如 MVVM；

RxSwift

在讲解 Combine 之前，我想介绍一下 Rx 宝石图，这个图可以帮助我们更好地理解某个常用操作符的意图。

下图就是一张Rx宝石图，箭头线代表一个序列(sequence)，中间的方块代表操作符(operator)。序列中的竖线代表结束，X代表错误。一个序列中可以发射无限个元素，当序列发射完成或者错误元素后，序列就不会再继续发射任何元素。

如果所示，上方的序列(方块上方的箭头线)中有各种形状的元素，经过中间的 flip 操作(方块)转换之后，下方的序列接收到了某些元素转换后的结果。而中间的淡蓝色元素在 flip 过程中发生了错误，导致了下方的序列接收到的是一个错误而不是正常的元素。由此，接收序列停止接收。

如果您感兴趣的话，可以参考我的这篇文章来学习 RxSwift 以及 RxCocoa。

Combine

在 Combine 中，被观察者是 Publisher(发布者) 是一个协议类型。

@available(OSX 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)

public protocol Publisher {

    /// 这个发布者发布的值的类型

    associatedtype Output

    /// 这个发布者可能发布的错误的类型

    ///

    /// 如果这个发布者不发布错误，就用 `Never`

    associatedtype Failure : Error

    /// 在调用 `subscribe(_:)` 方法时，这个方法会被触发，并连接指定的 `Subscriber 到这个发布者

    ///

    /// - SeeAlso: `subscribe(_:)`

    /// - Parameters:

    ///     - subscriber: 被连接到这个发布者上的订阅者。连接后，订阅者就可以开始接收值

    func receive<S>(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input

}

同样，观察者 Subscriber(订阅者) 也是协议类型。

@available(OSX 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)

public protocol Subscriber : CustomCombineIdentifierConvertible {

    /// 这个订阅者要接收的值的类型

    associatedtype Input

    /// 这个订阅者可能接收到的错误的类型

    ///

    /// 如果这个订阅者不会接收到错误，使用 `Never`

    associatedtype Failure : Error

    /// 告知订阅者成功订阅了发布者，并且可以获取发布项

    ///

    /// 使用收到的 `Subscription` 来向发布者请求内容

    /// - Parameter subscription: 订阅，代表发布者和订阅者之间的连接

    func receive(subscription: Subscription)

    /// 告知订阅者，发布者已经发布了一个元素

    ///

    /// - Parameter input: 发布了的元素

    /// - Returns: 命令，指明订阅者还期望接收多少元素

    func receive(_ input: Self.Input) -> Subscribers.Demand

    /// 告知订阅者，发布者已经结束了发布，可能是正常结束，也可能是因为发生了错误

    ///

    /// - Parameter completion: 完成，指明发布结束是正常结束还是由于错误而结束

    func receive(completion: Subscribers.Completion<Self.Failure>)

}

现在，让我们使用 Combine 来写一个发起网络请求的示例：

class CombineDemo {

    var cancellable: AnyCancellable?

    func makeRequest() {

        let url = URL(string: "https://ficow.cn")!

        let dataTaskPublisher = URLSession.shared.dataTaskPublisher(for: url)

        cancellable = dataTaskPublisher.sink(

            receiveCompletion: { completion in

                // 发布结束的时候会被调用一次

                switch completion {

                case .failure(let error):

                    print(error)

                case .finished:

                    print("success")

                }

            }, receiveValue: { value in

                // 每次接收到发布者发送的值都会被调用一次

                // 因为发起的是网络请求，所以这里只会被调用一次

                print(value.data)

                print(value.response)

            })

    }

}

dataTaskPublisher 是系统提供的方法，它会返回一个发布者（Publisher）。然后我们可以对这个 publisher 调用 sink（此处应翻译为：接收）方法，以此创建一个基于闭包的订阅者（Subscriber）。

sink 方法也有一个返回值，类型为 AnyCancellable，我们可以用这个值来取消订阅。当这个值在内存中被销毁时，订阅也会被自动取消。所以，如果我们不希望这个订阅在 makeRequest() 方法执行结束时停止，就要在实例中强引用这个 cancellable。

如果你想提前结束订阅，可以对这个 cancellable 调用 cancel 方法：

cancellable?.cancel()

此时，我们还没有用到操作符。现在，对上面的示例稍作调整：

        cancellable = dataTaskPublisher

            .delay(for: .seconds(2), scheduler: DispatchQueue.global()) // 在后台线程中去延时执行

            .receive(on: RunLoop.main) // 在主线程上接收发布的内容

            .sink(receiveCompletion: { completion in

如果使用传统的GCD，这里的代码就会变成两个闭包：

        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {

            // 发起网络请求操作

            dataTask() { (response) in

                DispatchQueue.main.async {

                    // 切换到主线程

                }

            }

        }

可以看到，使用 Combine 之后，代码变得简洁优雅，非常清晰易懂！不过，如果只是这样，也许还不够过瘾。

接下来，我们研究一下官方提供的一个基于 AppKit 的示例，我稍微做了一些处理以适应UIKit。如下所示：

class OfficialDemo {

    class MyViewModel {

        var filterString = ""

    }

    private let filterField = UITextField()

    private let myViewModel = MyViewModel()

    private var subscription: AnyCancellable?

    func bind() {

        subscription = NotificationCenter.default

            .publisher(for: UITextField.textDidChangeNotification, object: filterField)

            .map( { (($0.object as! UITextField).text ?? "") } )

            .filter( { $0.unicodeScalars.allSatisfy({CharacterSet.alphanumerics.contains($0)}) } )

            .debounce(for: .milliseconds(500), scheduler: RunLoop.main)

            .receive(on: RunLoop.main)

            .assign(to:\MyViewModel.filterString, on: myViewModel)

    }

}

bind 方法中的代码完成了很多任务：

通过通知中心来订阅输入框 filterField 的 textDidChangeNotification 通知；
通过 map 将接收到的内容转换为输入框中的文本；
通过 filter 来过滤掉无效的文本内容，阻止内容继续沿着订阅链往后传递；
通过 debounce(for:scheduler:) 来控制内容往后传递的频率（收到内容之后的500毫秒后执行后续操作，如果在这个时间段内收到了新内容，则重新计时500毫秒再执行后续操作）；
通过 receive(on:) 来指定执行后续操作的调度器（线程）；
通过 assign(to:on:) 来使用 keypath 为指定的对象赋值（每次收到内容就会执行一次）；

如果不使用 Combine，上面这一系列的任务可能需要写非常多的代码才能完成。而且代码的组织结构将会变得很庞大，你可能需要写很多方法来封装这些操作。

如果您想学习非常详细的用法，可以参考这个网页的内容：Using Combine。

总结

学习 Combine 有一定的成本，但是这是非常值得的，因为它可以帮助你：

改善代码质量、减小代码量、提升工作效率；
更好地学习 SwiftUI，毕竟 SwiftUI 中需要大量使用 Combine 的特性；
更好地应用 MVVM 模式，这是苹果的目标，当然也是我们的目标；
写出更容易测试的代码（聚焦于输入与输出）；

参考内容

Combine - Customize handling of asynchronous events by combining event-processing operators.

ReactiveX - An API for asynchronous programming with observable streams

RxSwift - Reactive Programming in Swift

Patterns - WPF Apps With The Model-View-ViewModel Design Pattern

Rx Marbles - Interactive diagrams of Rx Observables

Using Combine

Combine Essentials - Receiving and Handling Events with Combine