PromiseKit基本使用和源码

不凡的凡

2024-04-18 帮助1人

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

这篇好文章是转载于：学新通技术网

PromiseKit基本使用和源码

photoshop保存的图片太大微信发不了怎么办

《学习通》视频自动暂停处理方法

word里面弄一个表格后上面的标题会跑到下面怎么办

Android 11 保存文件到外部存储，并分享文件

photoshop扩展功能面板显示灰色怎么办

微信公众号没有声音提示怎么办

excel下划线不显示怎么办

excel打印预览压线压字怎么办

TikTok加速器哪个好免费的TK加速器推荐

怎样阻止微信小程序自动打开