美文网首页iOS 开发继续加油iOS KitiOS Developer
iOS的异步处理神器——Promises

iOS的异步处理神器——Promises

作者: 落影loyinglin | 来源:发表于2019-07-12 16:28 被阅读158次

    前言

    你是否因为多任务的依赖而头疼?你是否被一个个嵌套的block回调弄得晕头转向?
    快来投入Promises的怀抱吧。

    正文

    回调任务是很正常的现象,比如说购买一个商品,需要下单,然后等后台返回。
    单一任务,通常只需要一个block,非常清晰;
    以上面的下单为例,传给网络层一个block,购买完成之后回调即可。

    但是出现多个任务的时候,逻辑就开始有分支,同样以购买商品为例,在下单完成后,需要和SDK发起支付,然后根据支付结果再进行一些提示:
    任务1是下单,执行完回调error指针(或者状态码)表示完成状态,同时待会下单信息,此时产生一个分支,成功继续下一步,失败执行错误block;
    然后是执行任务2购买,执行异步的支付,根据支付结果又会产生一个分支。

    当连续的任务超过2个之后,分支会导致代码逻辑非常混乱。


    简单画一个流程图来分析,上述的逻辑变得复杂的原因是因为每一级的block需要处理下一级block的失败情况,导致逻辑分支的增多。

    其实所有的失败处理都是类似的:打日志、提示用户,可以放在一起统一处理。
    然后把任务一、任务二等串行执行,流程就非常清晰。

    Promises就是用来辅助实现这样设计的库。
    实现的代码效果如下:

    - (void)workflow {
        [[[[self order:@"order_id"] then:^id _Nullable(NSString * _Nullable value) {
            return [self pay:value];
        }] then:^id _Nullable(id  _Nullable value) {
            return [self check:value];
        }] catch:^(NSError * _Nonnull error) {
            NSLog(@"error: %@", error);
        }];
    }
    

    Promises的使用

    Promises库的引入非常简单,可以使用CocoaPod,Podfile如下:

      pod 'PromisesObjC'
    

    也可以到GitHub手动下载。

    按照Promise设计模式的规范,每一个Promise应该有三种状态:pending(等待)、fulfilled(完成)、rejected(失败);
    对应到Promises分别是:

    [FBLPromise pendingPromise]; // pending等待
    [FBLPromise resolvedWith:@"anyString"]; // fulfilled完成
    [FBLPromise resolvedWith:[NSError new]]; // rejected失败
    

    实际使用中,我们更多使用的Promises库已经提供好的便捷函数:

    启动一个异步任务

        [FBLPromise onQueue:dispatch_get_main_queue()
                      async:^(FBLPromiseFulfillBlock fulfill,
                              FBLPromiseRejectBlock reject) {
                          BOOL success = arc4random() % 2;
                          if (success) {
                              fulfill(@"success");
                          }
                          else {
                              reject([NSError errorWithDomain:@"learn_promises_error" code:-1 userInfo:nil]);
                          }
                      }];
    

    或者简单使用do方法

        [FBLPromise do:^id _Nullable{
            BOOL success = random() % 2;
            if (success) {
                return @"success";
            }
            else {
                return [NSError errorWithDomain:@"learn_promises_error" code:-1 userInfo:nil];
            }
        }];
    

    不管是async方法还是do方法,他们的返回值都是创建一个Promise对象,可以在Promise对象后面挂一个then方法,表示这个Promise执行完毕之后,要继续执行的任务:

       [[[FBLPromise do:^id _Nullable{
            BOOL success = arc4random() % 2;
            return success ? @"do_success" : [NSError errorWithDomain:@"learn_promises_do_error" code:-1 userInfo:nil];
        }] then:^id _Nullable(id  _Nullable value) {
            BOOL success = arc4random() % 2;
            return success ? @"then_success" : [NSError errorWithDomain:@"learn_promises_then_error" code:-1 userInfo:nil];
        }] catch:^(NSError * _Nonnull error) {
            NSLog(@"error: %@", error);
        }];
    

    上面的catch方法表示统一的error处理。
    promise在完成任务之后,如果满足下面的条件会调用then的方法:
    1、直接调用fulfill;
    2、在do方法中返回一个值(不能为error);
    3、在then方法中返回一个值;

    调用reject方法或者返回一个NSError对象,都会转到catch方法处理。

    用上面的do、then、catch方法组合,就完成多个异步任务的依赖执行:

    - (void)workflow {
        [[[[self order:@"order_id"] then:^id _Nullable(NSString * _Nullable value) {
            return [self pay:value];
        }] then:^id _Nullable(id  _Nullable value) {
            return [self check:value];
        }] catch:^(NSError * _Nonnull error) {
            NSLog(@"error: %@", error);
        }];
    }
    
    - (FBLPromise<NSString *> *)order:(NSString *)orderParam {
        return [FBLPromise do:^id _Nullable{
            return @"order_success";
        }];
    }
    
    - (FBLPromise<NSString *> *)pay:(NSString *)payParam {
        return  [FBLPromise do:^id _Nullable{
            BOOL success = arc4random() % 2;
            return success ? @"pay_success" : [NSError errorWithDomain:@"pay_error" code:-1 userInfo:nil];
        }];
    }
    
    - (FBLPromise<NSString *> *)check:(NSString *)checkParam {
        return  [FBLPromise do:^id _Nullable{
            return @"check success";
        }];
    }
    

    Promises还提供了很多附加特性,以All和Any为例:
    All是所有Promise都fulfill才算完成;
    Any是任何一个Promise完成都会执行fulfill;

    - (void)testAllAndAny {
        NSMutableArray *arr = [NSMutableArray new];
        [arr addObject:[self work1]];
        [arr addObject:[self work2]];
        
        [[[FBLPromise all:arr] then:^id _Nullable(NSArray * _Nullable value) {
            NSLog(@"then, value:%@", value);
            return value;
        }] catch:^(NSError * _Nonnull error) {
            NSLog(@"all error:%@", error);
        }];
        
        [[[FBLPromise any:arr] then:^id _Nullable(NSArray * _Nullable value) {
            NSLog(@"then, value:%@", value);
            return value;
        }] catch:^(NSError * _Nonnull error) {
            NSLog(@"any error:%@", error);
        }];
    }
    
    - (FBLPromise<NSString *> *)work1 {
        return [FBLPromise do:^id _Nullable{
            BOOL success = arc4random() % 2;
            return success ? @"work1 success" : [NSError errorWithDomain:@"work1_error" code:-1 userInfo:nil];
        }];
    }
    
    - (FBLPromise<NSNumber *> *)work2 {
        return  [FBLPromise do:^id _Nullable{
            BOOL success = arc4random() % 2;
            return success ? @"work2 success" : [NSError errorWithDomain:@"work2_error" code:-1 userInfo:nil];
        }];
    }
    

    Promises原理解析

    Promises库的设计很简单,基于Promise设计模式和iOS的GCD来实现。
    整个库由Promise.m/.h和他的Catagory组成。Catagory都是附加特性,基于Promise.m/.h提供的方法做扩展,所以这里重点解析下Promise.m/h。
    Promise类public头文件只有寥寥数个方法:

    // 静态方法
    [FBLPromise pendingPromise]; // pending等待
    [FBLPromise resolvedWith:@"anyString"]; // fulfilled完成
    [FBLPromise resolvedWith:[NSError new]]; // rejected失败
    // 实例方法
    - (void)fulfill:(nullable Value)value; // 完成一个promise
    - (void)reject:(NSError *)error;// rejected一个promise
    

    重点在于private.h提供的两个方法:

    /**
     对一个promise添加fulfill和reject的回调
     */
    - (void)observeOnQueue:(dispatch_queue_t)queue
                   fulfill:(FBLPromiseOnFulfillBlock)onFulfill
                    reject:(FBLPromiseOnRejectBlock)onReject NS_SWIFT_UNAVAILABLE("");
    
    /**
    创建一个promise,并设置fulfill、reject方法为传进来的block
     */
    - (FBLPromise *)chainOnQueue:(dispatch_queue_t)queue
                  chainedFulfill:(FBLPromiseChainedFulfillBlock)chainedFulfill
                   chainedReject:(FBLPromiseChainedRejectBlock)chainedReject NS_SWIFT_UNAVAILABLE("");
    
    

    observeOnQueue方法是promise的实例方法,根据promise当前的状态,如果是fulfilled或者rejected状态则会dispatch_group_async到下一次执行对应的onFulfill和onReject回调;如果是pending状态则会创建_observers数组,往_observers数组中添加一个block回调,当promise执行完毕的时候,根据state选择onFulfill或者onReject回调。

    chainOnQueue方法同样是promise的实例方法,返回的是一个FBLPromise的对象(状态是pending)。
    方法首先创建的是promise对象,接着创建了resolver的回调,然后调用observeOnQueue方法。
    当self(也是一个promise)执行完毕后,会根据fulfill、reject回调类型接着执行chainedFulfill、chainedReject;
    最后将结果抛给resolver执行,resolver会根据返回值value进行判断,如果仍是promise则递归执行,否则直接调用fulfill方法。
    fulfill方法则会判断value是否为NSError,如果是NSError则转为reject,否则将状态改为Fulfilled,并且通知observer数组。

    - (FBLPromise *)chainOnQueue:(dispatch_queue_t)queue
                  chainedFulfill:(FBLPromiseChainedFulfillBlock)chainedFulfill
                   chainedReject:(FBLPromiseChainedRejectBlock)chainedReject {
      NSParameterAssert(queue);
    
      FBLPromise *promise = [[FBLPromise alloc] initPending];
      __auto_type resolver = ^(id __nullable value) {
        if ([value isKindOfClass:[FBLPromise class]]) {
          [(FBLPromise *)value observeOnQueue:queue
              fulfill:^(id __nullable value) {
                [promise fulfill:value];
              }
              reject:^(NSError *error) {
                [promise reject:error];
              }];
        } else {
          [promise fulfill:value];
        }
      };
      [self observeOnQueue:queue
          fulfill:^(id __nullable value) {
            value = chainedFulfill ? chainedFulfill(value) : value;
            resolver(value);
          }
          reject:^(NSError *error) {
            id value = chainedReject ? chainedReject(error) : error;
            resolver(value);
          }];
      return promise;
    }
    

    Promises中的dispatch_group_enter() 和 dispatch_group_leave() 是成对使用,但是和平时使用GCD不同,这里并没有用到dispath_group_notify方法。
    在刚开始看Promises源码时,产生过一个疑问,为什么所有Promises的操作要放在同一个group内?

    + (dispatch_group_t)dispatchGroup {
      static dispatch_group_t gDispatchGroup;
      static dispatch_once_t onceToken;
      dispatch_once(&onceToken, ^{
        gDispatchGroup = dispatch_group_create();
      });
      return gDispatchGroup;
    }
    

    直到发现FBLWaitForPromisesWithTimeout方法,里面有一个dispatch_group_wait方法(等待group中所有block执行完毕,或者在指定时间结束后回调)。
    dispatch_group_wait方法与dispath_group_notify方法类似,只是多了一个超时时间,如果调用dispatch_group_wait(DISPATCH_TIME_FOREVER)则和dispath_group_notify方法一样。

    总结

    附加的特性有很多,类似Retry、Delay等,但实际使用中Promise用do、then、catch、async等少数几个已经可以满足需求。
    能够实现Promise设计模式的库比较多,Promises是性能和接口调用清晰度都比较不错的。
    使用设计模式可以简化逻辑代码,同时也使得代码的健壮性更强。

    附录

    Promises
    PromiseKit

    相关文章

      网友评论

        本文标题:iOS的异步处理神器——Promises

        本文链接:https://www.haomeiwen.com/subject/gbxffctx.html