SwiftUI Combine的Future

Promise 2022-10-14

Future在苹果官方文档的解释为：最终发布一个数据并立即结束。

这个解释过于简单了，其实Future的作用是：我将在未来的某一时刻，发布一个数据，并伴随着成功或失败的状态。

这个功能你可能听起来比较耳熟，对，他就是逃逸闭包(@escaping closure)的功能。

查看Future的源代码，我们可以看到

final public class Future<Output, Failure> : Publisher where Failure : Error {

    /// A type that represents a closure to invoke in the future, when an element or error is available.
    ///
    /// The promise closure receives one parameter: a `Result` that contains either a single element published by a ``Future``, or an error.
    public typealias Promise = (Result<Output, Failure>) -> Void

    /// Creates a publisher that invokes a promise closure when the publisher emits an element.
    ///
    /// - Parameter attemptToFulfill: A ``Future/Promise`` that the publisher invokes when the publisher emits an element or terminates with an error.
    public init(_ attemptToFulfill: @escaping (@escaping Future<Output, Failure>.Promise) -> Void)

    /// Attaches the specified subscriber to this publisher.
    ///
    /// Implementations of ``Publisher`` must implement this method.
    ///
    /// The provided implementation of ``Publisher/subscribe(_:)-4u8kn``calls this method.
    ///
    /// - Parameter subscriber: The subscriber to attach to this ``Publisher``, after which it can receive values.
    final public func receive<S>(subscriber: S) where Output == S.Input, Failure == S.Failure, S : Subscriber
}

它包含一个Promise类型和一个带有@escaping闭包的初始化函数。

Future和PassthroughSubject、CurrentValueSubject一样，是一个类，不同的是Future实现的是Publiser协议，而PassthroughtSubject和CurrentValueSubject实现的是Subject协议，所以后两个可以使用send方法，而Future不能。

Future功能实现

让我们按照惯例先在playground中测试下Future的基本用法。

新建一个playground文件，输入以下代码

let futurePublisher = Future<Int, Never> { promise in
    promise(.success(10))
}

let subscription = futurePublisher
    .print("_Future_")
    .receive(on: RunLoop.main)
    .sink { completion in
        switch completion {
        case .finished:
            print("finished")
        case .failure(let error):
            print("Got a error: \(error)")
        }
    } receiveValue: { value in
        print(value)
    }

// Output
_Future_: receive subscription: (Future)
_Future_: request unlimited
_Future_: receive value: (10)
_Future_: receive finished

我们首先创建了一个Future的publisher，可以看到，他和Pass和Current两个Publisher不同，创建时需要实现@escaping闭包，闭包的参数是Promise类型，我们将他命名为promise。

在闭包中，我们发布一个10的整型值。紧接着我们订阅并接收这个publihser，从打印信息中可以看到，一切都和PassthroughSubject和CurrentValueSubject没什么区别。

但是Future带有一个@escaping闭包，意味着我们可以在闭包中进行异步调用，比如dispathQueue，我们试一下。我们将闭包声明改为

let futurePublisher = Future<Int, Never> { promise in
    dispatchQueue.main.asyncAfter(deadline: .Now() + 2) {
        promise(.success(10))
    }
}

订阅方式不变，此时运行，打印信息会先打印

_Future_: receive subscription: (Future)
_Future_: request unlimited

过2秒后，接着打印

_Future_: receive value: (10)
_Future_: receive finished
10
finished

注意：如果使用订阅的时候，没有使用futurePublisher.sink后的结果，也就是没有赋值给subscription的话，会出现 request cancel的打印，同时会不能接收到2秒后的数据。这涉及到Combine的内存管理的部分，我们在其他章节再讨论。

Future实战应用

既然Future有@escaping闭包的功能，我们在实际工程里，可以将它用来获取网络数据上。

（实际使用中，Future通常被用来当作函数返回值或计算属性来使用）

这里我们利用https://jsonplaceholder.typicode.com/todos/1 来测试Future的功能，他返回的json如下

{
  "userId": 1,
  "id": 1,
  "title": "delectus aut autem",
  "completed": false
}

首先创建一个SwiftUI的工程，在View中先加入网络处理部分的代码

// MARK：- 数据结构
struct JSONData: Decodable {
    var userId: Int
    var id: Int
    var title: String
    var completed: Bool
}
// MARK：- 错误枚举
enum NetworkError: Error {
    case someError
}

// MARK：- 网络数据处理类
class NetworkService {
    static let shared = NetworkService()
    private init() { }
    
    var cancellables = Set<AnyCancellable>()

    // @escaping closure的写法
    func getWebDatanormal(completion: @escaping (Result<String, Error>) -> Void) {
        URLSession.shared.dataTaskPublisher(for: URL(string: "https://jsonplaceholder.typicode.com/todos/1")!)
            .print("_webdata_")
            .filter { ($0.response as! HTTPURLResponse).statusCode == 200 }
            .map { $0.data }
            .decode(type: JSONData.self, decoder: JSONDecoder())
            .sink { result in
                switch result {
                case .finished:
                    print("finished")
                case .failure(let error):
                    print("Got a error: \(error)")
                    completion(.failure(NetworkError.someError))
                }
            } receiveValue: { data in
                completion(.success(data.title))
            }
            .store(in: &self.cancellables)
    }

    // Combine Future的写法
    func getWebData() -> Future<String, Error> {
        return Future() { [weak self] promise in
            if let self = self {
                URLSession.shared.dataTaskPublisher(for: URL(string: "https://jsonplaceholder.typicode.com/todos/1")!)
                    .print("_webdata_")
                    .filter { ($0.response as! HTTPURLResponse).statusCode == 200 }
                    .map { $0.data }
                    .decode(type: JSONData.self, decoder: JSONDecoder())
                    .sink { completion in
                        switch completion {
                        case .finished:
                            print("finished")
                        case .failure(let error):
                            print("Got a error: \(error)")
                            promise(.failure(NetworkError.someError))
                        }
                    } receiveValue: { data in
                        promise(.success(data.title))
                    }
                    .store(in: &self.cancellables)
            }
        }
    }
}

在代码中，我们只想要显示获取json中的“title”数据。我们在Future的闭包中，调用dataTaskPublisher来获取网络数据，并接收，如果有错误，用promise(.failure())来发布错误，没有错误，用promise(.success())来发布数据。

我们用两种写法实现了获取数据的功能，一个是@escaping闭包的方式，一个是Combine Future的方式，大家可以看下区别。

使用combine时，future可以替代@escaping闭包的功能。

然后我们新建一个viewmodel，来调用网络数据处理的功能

extension FutureView {
    
    class viewmodel: ObservableObject {
        private var cancellables = Set<AnyCancellable>()
        // MARK：- 刷新视图用的变量
        @Published var title: String = ""
        
        func fetchData() {
            // getWebData的返回值是publisher，所以用Combine方式处理
            NetworkService.shared.getWebData()
                .print("_fetchData_")
                .receive(on: RunLoop.main)
                .sink { completion in
                    switch completion {
                    case .failure(let err):
                        // promise发布的错误
                        print("Error is \(err.localizedDescription)")
                    case .finished:
                        print("Finished")
                    }
                }
                receiveValue: { [weak self] data in
                    print("fetchWebData: \(data)")
                    // promise发布的数据，存储到title
                    self?.title = data
                }
                .store(in: &cancellables)
        }
    }
}

最后实现我们的View

struct FutureView: View {
    @StateObject var vm = viewmodel()
    private var cancellables = Set<AnyCancellable>()
    
    var body: some View {
        Text(vm.title)
            .onAppear {
                vm.fetchData()
            }
    }
}

最后运行，得到结果

 

相关文章

javascript – 使用mongoose进行Promise / async-await,返回空数组
最后的控制台返回空数组.控制台在ids.map函数完成之前运行va...
rxJava和promises之间的关系
我正在尝试将rxJava与我已经知道的内容联系起来,特别是来自J...
微信小程序前端promise封装
config.jsconstconfig={base_url_api:"https://douban....
javascript – 回复承诺？
我正在阅读MDN中的javascript,并且遇到了这个谈论承诺并且不...
微信小程序前端promise封装
config.jsconstconfig={base_url_api:"https://douban....
我怎么在这里滥用C承诺和期货？
这是我的代码main.cpp：#include<string>#include<...