一个发布者可以发布多个值，可以有两种可能的状态：成功或失败。在成功状态下，发布者会发送 Output 类型的值；在失败状态下，发布者则会发送 Failure 类型的错误。如果发布者不会失败，Failure 类型通常会被设置为 Never，表示不会产生错误。

Combine 框架内置了很多发布者，包括 Just、Future、Deferred、Empty、Fail、Record 以及 PassthroughSubject 和 curValueSubject。

一些 Publisher 举例：

1. Future：

   • 用于表示一个异步操作，该操作最终会产生一个值或一个错误。

   • 在以下例子中模拟一个异步操作，随机决定成功或失败。

     less
      代码解读
     复制代码
     let futureP = Future<Int, Error> { promise in
         DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
             let success = Bool.random()
             if success {
                 promise(.success(2))
             } else {
                 promise(.failure(NSError(domain: "ExampleError", code: 0, userInfo: nil)))
             }
         }
     }
     

2. Just：

   • 创建一个只发出单个值然后立即完成的 Publisher。

     ini
      代码解读
     复制代码
     let justP = Just("Hello, World!")
     

3. Deferred：

   • 延迟创建 Publisher 直到有订阅者订阅。

     bash
      代码解读
     复制代码
     let deferredPublisher = Deferred {
         Just("Hello, World!")
     }
     

ConnectablePublisher

ConnectablePublisher 可以让开发者控制数据流的开始发送时机。通常情况下，Publisher 在有订阅者时会立即开始发送数据，但 ConnectablePublisher 可以通过调用 connect() 来显式启动数据流。这在需要同步多个订阅者的场景中非常有用，例如网络请求或数据库查询。

比如当多个订阅者订阅了同一个非 ConnectablePublisher 的 Publisher，有可能会出现其中一个订阅者收到了订阅内容，而另外一个订阅者却没收到的情况。这时候就可以使用 使用 makeConnectable() 和 connect() 控制发布。

scss
 代码解读
复制代码
import Combine
​
class PublisherExample {
    private var cancellables = Set()
    
    func demonstratePublishers() {
        // 1. Publisher
        print("🍎普通 Publisher🍎")
        let numbers = PassthroughSubject()
        
        // 第一个订阅者
        numbers.map { value -> Int in
            print("处理数据: (value)")
            return value * 2
        }.sink { value in
            print("订阅者A: (value)")
        }.store(in: &cancellables)
        
        // 第二个订阅者
        numbers.map { value -> Int in
            print("处理数据: (value)")
            return value * 2
        }.sink { value in
            print("订阅者B: (value)")
        }.store(in: &cancellables)
            
        // 发送数据
        numbers.send(1)
        numbers.send(2)
        
        // 2. ConnectablePublisher
        print("\n🍎ConnectablePublisher🍎")
        let subject = PassthroughSubject()
        let connectablePublisher = subject.map { value -> Int in
            print("处理数据: (value)")
            return value * 2
        }.makeConnectable()
        
        // 第一个订阅者
        connectablePublisher.sink { value in
            print("订阅者A: (value)")
        }.store(in: &cancellables)
        
        // 第二个订阅者
        connectablePublisher.sink { value in
            print("订阅者B: (value)")
        }.store(in: &cancellables)
        
        // 连接发布者
        connectablePublisher.connect().store(in: &cancellables)
        
        // 发送数据
        subject.send(1)
        subject.send(2)
    }
}
​
let exp = PublisherExample()
exp.demonstratePublishers()
​
/* 输出:
🍎普通 Publisher🍎
处理数据: 1
订阅者A: 2
处理数据: 1
订阅者B: 2
处理数据: 2
订阅者A: 4
处理数据: 2
订阅者B: 4
​
🍎ConnectablePublisher🍎
处理数据: 1
订阅者B: 2
订阅者A: 2
处理数据: 2
订阅者B: 4
订阅者A: 4
*/

• 普通 Publisher:

  • 每个订阅者订阅时都会触发一次完整的数据流
  • 耗时操作会被执行多次
  • 订阅者获得的是独立的数据流

• ConnectablePublisher:

  • 在调用 connect() 之前不会开始发送数据
  • 所有订阅者共享同一个数据流
  • 耗时操作只执行一次
  • 适合需要等待所有订阅者准备就绪才开始发送数据的场景

引用共享

在 Combine 中，引用共享通常是指多个订阅者（Subscriber）共享同一个发布者（Publisher）的输出，而不是每个订阅者都触发一次数据生成。这可以通过 .share() 操作符实现。

关于 ConnectablePublisher 和引用共享所使用的 share 操作符号，在此先不展开讲解，后面讲到操作符的时候再举例说明。

Subject

A publisher that exposes a method for outside callers to publish elements. 一个公开了方法供外部调用者发布元素的发布者。

Subject 是一个特殊的 Publisher。它的特殊之处在于：

1. 主动发送能力：

   0. 普通的 Publisher 只能在创建时定义数据
   1. Subject 通过 send(_:) 方法可以在外部主动发送值到数据流中

2. 控制权的不同：

   0. 普通 Publisher 的数据流是由内部逻辑控制的（比如 Just、Future）
   1. Subject 允许外部代码通过 send 方法控制数据流

   scss
    代码解读
   复制代码
   // 普通 Publisher：只能在创建时定义数据
   let publisher = [1, 2, 3].publisher  // 数据流固定
   ​
   // Subject：可以随时发送新数据
   let subject = PassthroughSubject()
   subject.send(1) 
   subject.send(2)
   subject.send(completion: .finished)  // 还可以主动结束
   

swift
 代码解读
复制代码
public protocol Subject<Output, Failure> : AnyObject, Publisher {
​
    /// Sends a value to the subscriber.
    ///
    /// - Parameter value: The value to send.
    func send(_ value: Self.Output)
​
    /// Sends a completion signal to the subscriber.
    ///
    /// - Parameter completion: A `Completion` instance which indicates whether publishing has finished normally or failed with an error.
    func send(completion: Subscribers.Completion<Self.Failure>)
​
    /// Sends a subscription to the subscriber.
    ///
    /// This call provides the ``Subject`` an opportunity to establish demand for any new upstream subscriptions.
    ///
    /// - Parameter subscription: The subscription instance through which the subscriber can request elements.
    func send(subscription: any Subscription)
}

Combine 内置了两种 Subject，分别是 PassthrougSubject 和 CurrentValueSubject。

PassthroughSubject:

• 无初始值或当前值存储

• 只转发接收到的值给订阅者

• 适用于：

  • 按钮点击等事件触发的场景
  • 不需要保存状态的场景
  • 一次性通知

CurrentValueSubject:

• 必须提供初始值

• 维护一个当前值

• 新订阅者立即收到当前值

• 可通过 .value 属性读写当前值

• 适用于：

  • 状态管理（如开关状态）
  • 需要缓存最新值的场景
  • 需要立即知道当前状态的场景

swift
 代码解读
复制代码
import Combine
import Foundation
​
// PassthroughSubject
let passthroughSubject = PassthroughSubject<String, Never>()
​
// curValueSubject
let curValueSubject = CurrentValueSubject<String, Never>("初始值")
​
// 订阅 PassthroughSubject
passthroughSubject
    .sink { value in
        print("PassthroughSubject 接收到: (value)")
    }
​
// 发送俩值
passthroughSubject.send("第一个值")
passthroughSubject.send("第二个值")
​
// 订阅 curValueSubject
curValueSubject
    .sink { value in
        print("curValueSubject 接收到: (value)")
    }
​
// 发送新值
curValueSubject.send("更新后的值")
​
//输出当前值
print("curValueSubject 当前值: (curValueSubject.value)")
​
// 发送另一个新值
curValueSubject.send("再次更新的值")
​
// 打印当前值
print("curValueSubject 当前值: (curValueSubject.value)")
​
/* 
输出
PassthroughSubject 接收到: 第一个值
PassthroughSubject 接收到: 第二个值
curValueSubject 接收到: 初始值
curValueSubject 接收到: 更新后的值
curValueSubject 当前值: 更新后的值
curValueSubject 接收到: 再次更新的值
curValueSubject 当前值: 再次更新的值
*/

结语

Publisher 是 Combine 框架的基础组件之一，它为数据流的生成和传递提供了灵活而强大的工具。通过学习 Publisher 的工作原理和使用方式，开发者可以更有效地管理应用中的数据流。在下一篇文章中，将继续探讨介绍 Combine 中的订阅者（Subscriber）机制，进一步完善 Combine 知识体系。

• Swift Combine 学习（三）：Subscription和 Subscriber