Combine 中常见的 Publisher 类型

1. 典型的 Combine 类型

在 Combine 中，常见的 Publisher 类型包括：

  1. Just<Output>：用于发布单个值，并且完成。失败时没有错误。
  2. Future 是一个会异步发出一个值或错误的 Publisher。
  3. PassthroughSubject<Output, Failure>：用于主动发布事件，适用于需要手动发送值的场景。
  4. CurrentValueSubject<Output, Failure>：与 PassthroughSubject 相似，但它会保留当前值，新的订阅者会立即收到该值。
  5. AnyPublisher<Output, Failure>：类型擦除的 Publisher，用于隐藏内部的实现细节，暴露统一的输出类型和错误类型。

以下是针对 Just<Output>、PassthroughSubject<Output, Failure> 和 CurrentValueSubject<Output, Failure> 的三个简单示例，它们分别展示了这些类型的使用场景。

  • Just<Output> 示例
    Just<Output> 用于发布一个单一的值，并在发布后完成。这是一个最简单的 Publisher 类型，适用于你只需要发送一个固定值并结束的场景。
import Combine

let publisher = Just("Hello, Combine!")
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Completed")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { value in
        print("Received value: \(value)")
    })


// 输出：
// Received value: Hello, Combine!
// Completed

// Just 创建了一个 Publisher，这个 Publisher 发布了一个单一的值 "Hello, Combine!"，然后就完成了。
// sink 用来订阅并处理值和完成事件。
  • Future 示例
    Future 是一个会异步发出一个值或错误的 Publisher，它的类型是 Future<Output, Failure>，通常用于封装异步操作。
import Combine

let future = Future<String, Error> { promise in
    // 模拟异步操作
    DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
        promise(.success("Async Result"))
    }
}
  • PassthroughSubject<Output, Failure> 示例
    PassthroughSubject<Output, Failure> 是一个允许手动发布事件的 Publisher，它可以在运行时主动发布多个值。它是最常用的 Subject 类型之一。
import Combine

// 定义一个 PassthroughSubject
let passthroughSubject = PassthroughSubject<String, Never>()

// 订阅者
let subscriber = passthroughSubject
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Completed")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { value in
        print("Received value: \(value)")
    })

// 主动发送值
passthroughSubject.send("First message")
passthroughSubject.send("Second message")
passthroughSubject.send("Third message")

// 完成发送
passthroughSubject.send(completion: .finished)


// 输出：
// Received value: First message
// Received value: Second message
// Received value: Third message
// Completed

// `PassthroughSubject` 可以在运行时主动发送多个值，直到通过 `.send()` 方法发送一个值。
// `sink` 用来订阅并处理这些值，直到 `PassthroughSubject` 发送 `.finished` 完成事件。
  • CurrentValueSubject<Output, Failure> 示例
    CurrentValueSubject<Output, Failure> 类似于 PassthroughSubject，但它会保持当前值，当新的订阅者订阅时，它会立即接收到最新的值。
import Combine

// 定义一个 CurrentValueSubject，初始值为 "Initial Value"
let currentValueSubject = CurrentValueSubject<String, Never>("Initial Value")

// 订阅者1
let subscriber1 = currentValueSubject
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Completed")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { value in
        print("Subscriber1 received: \(value)")
    })

// 主动发送新值
currentValueSubject.send("Updated Value")

// 订阅者2：将会立即接收到 "Updated Value"
let subscriber2 = currentValueSubject
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Completed")
        case .failure(let error):
            print("Failed with error: \(error)")
        }
    }, receiveValue: { value in
        print("Subscriber2 received: \(value)")
    })

// 发送新的值
currentValueSubject.send("Another Update")


// 输出：
// Subscriber1 received: Initial Value
// Subscriber1 received: Updated Value
// Subscriber1 received: Another Update
// Subscriber2 received: Updated Value
// Subscriber2 received: Another Update

// `CurrentValueSubject` 初始化时会有一个默认值（此处为 `"Initial Value"`）。当一个新的订阅者订阅时，它会立即接收到这个默认值。
// 随后，任何通过 `send()` 发送的新值都会被当前的订阅者接收到。

Just<Output>：用于发布一个固定的单一值，并完成。适合简单的场景。
PassthroughSubject<Output, Failure>：允许手动发布多个值，适合动态发布事件的场景。
CurrentValueSubject<Output, Failure>：会保留当前值，新的订阅者会立即接收到当前的值。适合需要持有状态并向新订阅者提供当前状态的场景。

2. 如何创建 AnyPublisher

以下是一个简化版的例子，展示如何在 Combine 中使用 AnyPublisher 来隐藏具体的 Publisher 类型。

方法 eraseToAnyPublisher() 在这一过程中非常关键：

import Combine

enum DownloadError: Error {
    case networkError
    case fileNotFound
}

// 自定义 Publisher 类型
func downloadFile(from url: URL) -> AnyPublisher<Data, DownloadError> {
    // 模拟网络请求的返回
    let data = Data("Downloaded content".utf8)
    
    // 使用 Just 来模拟返回数据
    return Just(data)
        .setFailureType(to: DownloadError.self)  // 设置错误类型
        .eraseToAnyPublisher()  // 转换为 AnyPublisher
}

// 使用自定义 Publisher
let publisher = downloadFile(from: URL(string: "https://example.com/file")!)
publisher.sink(receiveCompletion: { completion in
    switch completion {
    case .finished:
        print("Download finished")
    case .failure(let error):
        print("Download failed with error: \(error)")
    }
}, receiveValue: { data in
    print("Received data: \(data)")
}).store(in: &cancellables)

组合多个 Publisher 并隐藏类型：假设你有两个异步任务，分别返回不同类型的 Publisher。你可以使用 eraseToAnyPublisher() 将它们组合为统一的类型，方便在外部使用。

import Combine

class DataFetcher {
    var cancellables = Set<AnyCancellable>()
    
    func fetchName() -> AnyPublisher<String, Error> {
        Just("John")
            .setFailureType(to: Error.self)
            .eraseToAnyPublisher() // 转换为 AnyPublisher
    }
    
    func fetchAge() -> AnyPublisher<Int, Error> {
        Just(30)
            .setFailureType(to: Error.self)
            .eraseToAnyPublisher() // 转换为 AnyPublisher
    }
    
    func fetchData() -> AnyPublisher<(String, Int), Error> {
        // 使用 combineLatest 合并两个 Publisher
        return Publishers.CombineLatest(fetchName(), fetchAge())
            .eraseToAnyPublisher() // 将合并后的 Publisher 转换为 AnyPublisher
    }
}

let fetcher = DataFetcher()

fetcher.fetchData()
    .sink(receiveCompletion: { completion in
        switch completion {
        case .finished:
            print("Data fetch complete")
        case .failure(let error):
            print("Error occurred: \(error)")
        }
    }, receiveValue: { name, age in
        print("Received data: \(name), \(age)")
    })
    .store(in: &fetcher.cancellables)
3. 总结

AnyPublisher<ProgressResult, APIError> 是 Combine 中的一个类型擦除的 Publisher，表示它发布 ProgressResult 类型的值，并且可能会失败并发布 APIError 类型的错误。

通过 eraseToAnyPublisher() 将具体的 Publisher 类型转换为统一的类型，这样外部代码只需要关心输出类型和错误类型，而不需要关心内部具体的实现类型。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Swift Combine 入门导读
    在具体介绍 Combine 之前，有两个重要的概念需要简要介绍一下： 观察者模式 响应式编程 观察者模式 观察者模...
    没八阿哥的程序阅读 9,134评论 2赞 21
  • Swift Combine
    简介 Combine是Apple在2019年WWDC上推出的一个新框架。该框架提供了一个声明性的Swift API...
    云天涯丶阅读 24,574评论 5赞 22
  • Combine -- 概述
    响应式异步编程的抽象和特点： 异步操作在合适的时机发布事件，这些事件带有数据，使用一个或多个操作来处理这些事件以及...
    jancywen阅读 532评论 0赞 0
  • SwiftUI - Combine
    前言 “一个随时间处理数据的声明式的 Swift API。”Combine 苹果采用的一种函数响应式编程的库，类似...
    Lcr111阅读 1,516评论 0赞 2
  • Combine Publisher详解
    摘自《SwiftUI和Combine编程》---《Publisher 和常见 Operator》 Publishe...
    一粒咸瓜子阅读 1,289评论 0赞 1