经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 移动开发 » iOS » 查看文章
PromiseKit基本使用及源码解析
来源:cnblogs  作者:不停奔跑的蜗牛  时间:2019/11/15 8:53:39  对本文有异议

     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,进行链式操作

原文链接:http://www.cnblogs.com/duzhaoquan/p/11857773.html

 友情链接: NPS