PromiseKit基本使用及源码解析

最新推荐文章于 2024-08-10 07:33:43 发布

扬帆起航&d

最新推荐文章于 2024-08-10 07:33:43 发布

阅读量245

点赞数

文章标签： swift 开发语言 ios

本文链接：https://blog.csdn.net/weixin_37543822/article/details/128911232

版权

Promise处理一系列异步操作的应用框架，能够保证顺序执行一系列异步操作，当出错时可以通过catch捕获错误进行处理。Promise框架也是很好的诠释了swift的面相协议编程以及函数式编程

两种类型 1Promise，2Guarantee 其中Guarantee没有实现 CatchMixin 协议，不能捕获错误，他是不允许抛出错误，常用的就是第一种类型，便于错误处理。Promise是承诺执行，有可能不执行；而guarantee是保证，保证一定执行

基本使用形式：

func threeRequest111() {
         firstly {
                request1(with: ["test1": "first"])
            }
            .then { (v) -> Promise<NSDictionary> in
                print("🍀", v)
                return self.request2(para: ["test2": "second"])
            }
            .then { (v) -> Promise<NSDictionary> in
                print("🍀🍀", v)
                return self.request3(para: ["test3": "third"])
            }
            .map({ (dic) -> [String:String]  in
                if let dic1 = dic as? [String:String]{
                    return dic1
                }else{
                    return [String:String]()
                }
            }).done({ (dic) in
                print(dic)
            })
            .catch { (error) in
                print(error.localizedDescription)
        
            }.finally {
                print("finaly")
        }
    }

func request1(with parameters: [String: String]) -> Promise<(NSDictionary)> {

return Promise<NSDictionary>(resolver: { (resolver) in

Alamofire.request("https://httpbin.org/get", method: .get, parameters: parameters).validate().responseJSON() { (response) in

switch response.result {

case .success(let dict):

delay(time: 1, task: {

resolver.fulfill(dict as! NSDictionary)

})

case .failure(let error):

resolver.reject(error)

}

            }

        })

}

func request2(para:[String:String]) -> Promise<NSDictionary> {

return request1(with: para)

}

func request3(para:[String:String]) -> Promise<NSDictionary> {

        return request1(with: para)

源码解析

一开始带着问题去想研究下源码

1.如何保证一系列block顺序执行的呢

把外部传入的thenBlock等保存起来了，保存到一个数组中，handlers.append(to)，当自己的任务执行完去执行存在数组的任务

2.闭包中返回值promise 如何与 firstly函数中的promise联系起来的

rv.pipe(to: rp.box.seal)

二。Promise 主要函数

1.then函数

func then<U: Thenable>(on: DispatchQueue? = conf.Q.map, flags: DispatchWorkItemFlags? = nil, _ body: @escaping(T) throws -> U) -> Promise<U.T> {
        let rp = Promise<U.T>(.pending)
        pipe {//向上一个promise中添加任务
            switch $0 {
            case .fulfilled(let value):
                on.async(flags: flags) {
                    do {
                        let rv = try body(value)
                        guard rv !== rp else { throw PMKError.returnedSelf }
                        rv.pipe(to: rp.box.seal)
                    } catch {
                        rp.box.seal(.rejected(error))
                    }
                }
            case .rejected(let error):
                rp.box.seal(.rejected(error))
            }
        }
        return rp
    }

then函数中将pipe闭包(包括了外部需要执行的闭包)添加进上一个promise.box.handers中：

handlers.append(to)

to就是then函数中的pipe闭包，并且添加的时候时用栅栏函数同步添加的，保证了任务的顺序执行

barrier.sync(flags: .barrier) {//栅栏同步

当上一个promise中的闭包(外部耗时任务)执行完，resever调用fufill：

resolver.fulfill(T) -> box.seal(.fulfilled(value)) ->

override func seal(_ value: T) {
        var handlers: Handlers<T>!
        barrier.sync(flags: .barrier) {
            guard case .pending(let _handlers) = self.sealant else {
                return  // already fulfilled!
            }
            handlers = _handlers
            self.sealant = .resolved(value)
        }
        if let handlers = handlers {
            handlers.bodies.forEach{ $0(value) }
        }
    }
带着结果值执行handlers.bodies里边的任务(也就是下一个then中的block)实际上就是上边天加进去的pipe闭包：

  pipe {//向上一个promise中添加任务

            switch $0 {

            case .fulfilled(let value):

                on.async(flags: flags) {

                    do {

                        let rv = try body(value)

                        guard rv !== rp else { throw PMKError.returnedSelf }

                        rv.pipe(to: rp.box.seal)//执行rp.handlers.foreach这个任务添加到rv.handlers

                    } catch {

                        rp.box.seal(.rejected(error))

                    }

                }

            case .rejected(let error):

                rp.box.seal(.rejected(error))

            }

        }

这里边又个比较绕的东西就是switch $0 是Result<T>类型，而调用的地方handlers.bodies.forEach{ $0(value) }，传入的value是T类型，不匹配，绕了一圈看了一下，初始化resolve时T表示了ResultT，这样就时匹配的没错

我们知道then函数block中需要返回一个Promise：rv，而then函数中有创建了一个Promise：rp，传入下一个then函数中，下面以相邻的两个then函数再简化的理解一下then{rv1:Promise}.then{rv2:promise}

rv1的handler中存的是rp1.box.seal也就是是否要执行rv2所在的那个pipe

2.catch 错误捕获函数，为什么promise连中无论哪一环节报错，都能走到catch中去呢

catch定义在CatchMixin协议中，promise是实现了这个协议的，catch它有默认实现：

@discardableResult
    func `catch`(on: DispatchQueue? = conf.Q.return, flags: DispatchWorkItemFlags? = nil, policy: CatchPolicy = conf.catchPolicy, _ body: @escaping(Error) -> Void) -> PMKFinalizer {
        let finalizer = PMKFinalizer()
        pipe {
            switch $0 {
            case .rejected(let error):
                guard policy == .allErrors || !error.isCancelled else {
                    fallthrough
                }
                on.async(flags: flags) {
                    body(error)
                    finalizer.pending.resolve(())
                }
            case .fulfilled:
                finalizer.pending.resolve(())
            }
        }
        return finalizer
    }

catch一般在promise链中的最后或者finally前边，所以它的返回值是PMKFinalizer

通过pipe把pipe的内容添加到了上一个promise的handels中

当promise链中任何一环执行reject(error)时,执行下一个promise中的seal

rp.box.seal(.rejected(error))

顺着promise链一直往下走，每一个都是执行这个，直到catch，走catch中的代码任务

3.firstly，了解了t很函数之后再看firstly就容易理解多了，它比then不同地一点是，它是先执行因为他前边没有promise，它一个函数而不是promise的方法，返回值和then一样，是个promise

public func firstly<U: Thenable>(execute body: () throws -> U) -> Promise<U.T> {
    do {
        let rp = Promise<U.T>(.pending)
        try body().pipe(to: rp.box.seal)//执行body，创建Promise，返回后执行pipe(外部可能是异步的耗时操作，所以会先执行pipe(to)，return rp，接着是外部的.then函数等)
        return rp
    } catch {
        return Promise(error: error)
    }
}

4.when函数，主要是实现前边几个任务同时进行，等他们都执行完，精心后边的顺序执行任务。

基本使用方式：

//request1和request2，并行执行，都执行完再执行request3；参数是个promise数组，多个任务同时执行
        when(fulfilled: [request1(with: ["para1":"hello"]),request2(para: ["para2":"nihao"])])
        .then { (dic) -> Promise<NSDictionary> in
            self.request3(para: ["uhu":"nih"])
            }.catch { (error) in
                print(error.localizedDescription)
        }
        //promises数组中是结果不同类型的promise，最多支持5种不同类型的Promise
        when(fulfilled: request1(with: ["para1":"hello"]), request4())
            .then { (arg0) -> Promise<[String:String]> in
            let (dic, str) = arg0
            return Promise<[String:String]>(resolver: { (res) in
                res.fulfill([str : "\(dic)"])
            })
            }.catch { (error) in
                print(error.localizedDescription)
        }
查看其源码，通过两个Int值，表示已经执行完的任务数和总共的任务数
private func _when<U: Thenable>(_ thenables: [U]) -> Promise<Void> {
    var countdown = thenables.count
    guard countdown > 0 else {
        return .value(Void())
    }

    let rp = Promise<Void>(.pending)

#if PMKDisableProgress || os(Linux)
    var progress: (completedUnitCount: Int, totalUnitCount: Int) = (0, 0)
#else
    let progress = Progress(totalUnitCount: Int64(thenables.count))
    progress.isCancellable = false
    progress.isPausable = false
#endif

    let barrier = DispatchQueue(label: "org.promisekit.barrier.when", attributes: .concurrent)

    for promise in thenables {
        promise.pipe { result in
            barrier.sync(flags: .barrier) {
                switch result {
                case .rejected(let error):
                    //如果是pending(等待)状态，将错误往下传递，这个判断确保了几个并行的任务
                    //只有第一个出错的任务它错误往下传递，因为一旦出错其他的任何任务都再无意义
                    if rp.isPending {
                        progress.completedUnitCount = progress.totalUnitCount
                        rp.box.seal(.rejected(error))
                    }
                case .fulfilled:
                    //这个条件确保了，如果几个并行的任务有一个已经出错，后来正确完成的任务到这里不再往下传递
                    guard rp.isPending else { return }
                    progress.completedUnitCount += 1
                    countdown -= 1
                    if countdown == 0 {
                        rp.box.seal(.fulfilled(()))
                    }
                }
            }
        }
    }

    return rp
}

5.race函数，和when函数对比来看，race参数也是几个promise，不同的是它只有其中一个返回成功就往下传递继续promise链，不用等这几个任务全执行完，每个执行完了都往下走一遍promise链这种需求可能应用的少一点

private func _race<U: Thenable>(_ thenables: [U]) -> Promise<U.T> {

let rp = Promise<U.T>(.pending)

for thenable in thenables {

thenable.pipe(to: rp.box.seal)

}

return rp

}

二.看一下Promise提供的其他函数

Map 转换函数，将结果进行转换
public func map<U>(on: DispatchQueue? = default, flags: DispatchWorkItemFlags? = default, _ transform: @escaping (Self.T) throws -> U) -> PromiseKit.Promise<U>
done函数，done函数和then函数的区别就是是block返回值是void，只是顺序执行，二不需要上一步的结果值是用done函数
func done(on: DispatchQueue? = conf.Q.return, flags: DispatchWorkItemFlags? = nil, _ body: @escaping(T) throws -> Void) -> Promise<Void> 
Get函数，他和done差不多，只是会自动的返回上部的结果值
 func get(on: DispatchQueue? = conf.Q.return, flags: DispatchWorkItemFlags? = nil, _ body: @escaping (T) throws -> Void) -> Promise<T>
tap函数，他会返回一个Result<T>，你可以从这里查看返回的值，而不会对整个链产生任何副作用
func tap(on: DispatchQueue? = conf.Q.map, flags: DispatchWorkItemFlags? = nil, _ body: @escaping(Result<T>) -> Void) -> Promise<T>
asVoid函数，它返回一个新的promise，与上一个promise连起来，而上一个promise的值被抛弃
func asVoid() -> Promise<Void>

还有一些当结果值是Sequence(也就是数组)时的函数，对数组的一些理，和数组的一些高阶函数差不多
public extension Thenable where T: Sequence 
func mapValues<U>(on: DispatchQueue? = conf.Q.map, flags: DispatchWorkItemFlags? = nil, _ transform: @escaping(T.Iterator.Element) throws -> U) -> Promise<[U]>

附带1，框架还封装了一个KVO实现KVOProxy,为Guarantee打造的一个KVO，任何一个类都可以添加一个观察者，当收到观察属性变化时窒执行guarantee的内容，guarantee是一个保证，一定会执行，所以KVO中，KVOProxy自己持有自己，retainCycle = self，不收到回掉不会释放

extension NSObject {
    public func observe(_: PMKNamespacer, keyPath: String) -> Guarantee<Any?> {
        return Guarantee { KVOProxy(observee: self, keyPath: keyPath, resolve: $0) }
    }
}

private class KVOProxy: NSObject {
    var retainCycle: KVOProxy?
    let fulfill: (Any?) -> Void

    @discardableResult
    init(observee: NSObject, keyPath: String, resolve: @escaping (Any?) -> Void) {
        fulfill = resolve
        super.init()
        observee.addObserver(self, forKeyPath: keyPath, options: NSKeyValueObservingOptions.new, context: pointer)
        retainCycle = self
        //持有自己造成循环引用，不收到回掉不会释放
    }

    fileprivate override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        if let change = change, context == pointer {
            defer { retainCycle = nil }//延时执行，所在作用域内最后执行，收到回掉后才进行释放
            fulfill(change[NSKeyValueChangeKey.newKey])
            if let object = object as? NSObject, let keyPath = keyPath {
                object.removeObserver(self, forKeyPath: keyPath)
            }
        }
    }

    private lazy var pointer: UnsafeMutableRawPointer = {
        return Unmanaged<KVOProxy>.passUnretained(self).toOpaque()
    }()
}

附带2，框架对alamofire做了了一些extension，请求的返回值可以直接是一个promise，进行链式操作