MVVM模式在iOS中常用場景

使用MVVM模式可以讓Model--ViewModel--UI間形成綁定關系，Model數據變化可以通過VM直接更新UI；
在實際的場景，比如一些復雜的情況：

  • 多個異步請求，獲取到全部回調才更新UI
  • 依賴請求，第二個請求依賴于第一個請求結果
  • 失敗重試，需要自定義重試次數

那MVVM該如何設計呢？
核心業務邏輯還是交給ViewModel處理，暴露接口給外部調用，ViewController/View只做訂閱。使用RACSubject(ReactiveObjc)或PublishSubject(RxSwift)來發送數據。

一.Controller/View層的處理

OC

/// 綁定
- (void)bind {
    [self.viewModel.dataSubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"直接獲取所有信息信息%@", x);
    }];
    [self.viewModel.moneySubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"通過用戶信息獲取的錢包信息%@", x);
    }];
    [self.viewModel.orderListSubject subscribeNext:^(id  _Nullable x) {
        NSLog(@"獲取的訂單列表%@", x);
    }];
}

#pragma mark - 場景1：多個異步請求，全部處理完才回調到同一處去處理
- (void)mutiRequestSingleCompletion {
    [self.viewModel multiRequestSingleCompletion];
}

#pragma mark - 場景2：多個異步請求，有序，A請求完再繼續B請求（B依賴于A）
- (void)multiRequestDependsOnRequest {
    [self.viewModel multiRequestDependsOnRequest];
}

#pragma mark - 場景3：在失敗情況下重新請求的
- (void)requestMultiTimesWhenFailed {
    [self.viewModel requestMultiTimesWhenFailed];
}

Swift

    override func viewDidLoad() {
        super.viewDidLoad()
        self.bind()

        self.baseViewModel.multiRequestSingleCompletion()
        self.baseViewModel.multiRequestDependsOnRequest()
        self.baseViewModel.requestMultiTimesWhenFailed()
    }
    
    // MARK: -綁定
    func bind() {
        self.baseViewModel.dataSubject.subscribe { val in
            print(val.element!);
        }.disposed(by: disposeBag)
        
        self.baseViewModel.moneySubject.subscribe { val in
            print(val.element!);
        }.disposed(by: disposeBag)
        
        self.baseViewModel.orderListSubject.subscribe { val in
            print(val.element!);
        }.disposed(by: disposeBag)
    }
1.多個異步請求，全部處理完才回調到同一處去處理。

假設同時有以下請求：用戶信息、錢包信息、訂單信息；拿到全部回調后才會更新UI
OC

/// 獲取完用戶信息、錢包信息、訂單信息才會回調一次
- (void)multiRequestSingleCompletion {
    //  定義信號
    RACSubject *userProfileSubject = [RACSubject subject];
    RACSubject *walletSubject      = [RACSubject subject];
    RACSubject *orderSubject       = [RACSubject subject];
    //  組合
    @weakify(self);
    [[RACSignal combineLatest:@[userProfileSubject, walletSubject, orderSubject]]subscribeNext:^(RACTuple * _Nullable x) {
        @strongify(self);
        NSArray *array = [x allObjects];        
        [self.dataSubject sendNext:array];
    }];
    //  發送信號值，沒有對subject強引用，直接調用
    [self requestUserProfile:^(id  _Nonnull info) {
        [userProfileSubject sendNext:info];
    }];
        
    [self requestUserWallet:^(id  _Nonnull info) {
        [walletSubject sendNext:info];
    }];
        
    [self requestUserOrder:^(id  _Nonnull info) {
        [orderSubject sendNext:info];
    }];
}

Swift

/// 獲取完用戶信息、錢包信息、訂單信息才會回調一次
    func multiRequestSingleCompletion() {
        //  定義信號
        let userProfileSubject = PublishSubject<Any>()
        let walletSubject      = PublishSubject<Any>()
        let orderSubject       = PublishSubject<Any>()
        //  組合
        Observable.combineLatest([userProfileSubject, walletSubject, orderSubject]).subscribe { val in
            self.dataSubject.onNext(val.element!)
        }.disposed(by: disposeBag)
        
        // 發送
        self.requestUserProfile { info in
            userProfileSubject.onNext(info)
        }
        self.requestUserWallet { info in
            walletSubject.onNext(info)
        }
        self.requestUserOrder { info in
            orderSubject.onNext(info)
        }
    }
2.多個異步請求，有序，A請求完再繼續B請求（B依賴于A）

需要先獲取用戶信息，再通過用戶信息獲取錢包信息
OC

/// 獲取完用戶信息，再通過用戶信息獲取錢包
- (void)multiRequestDependsOnRequest {
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@{@"name":@"Tom"}];
        [subscriber sendCompleted];
        return nil;
    }];
        
    @weakify(self);
    signal = [signal flattenMap:^__kindof RACSignal * _Nullable(id  _Nullable value) {
        NSLog(@"用戶%@", value);
        return [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
            @strongify(self);
            [self requestUserWallet:^(id  _Nonnull info) {
                [subscriber sendNext:@{@"money":@"100"}];
                [subscriber sendCompleted];
            }];
            return nil;
        }];
    }];
        
    [signal subscribeNext:^(id  _Nullable x) {
        @strongify(self);
        [self.moneySubject sendNext:x];
    }];    
}

Swift

/// 獲取完用戶信息，再通過用戶信息獲取錢包
    func multiRequestDependsOnRequest() {
        var observable = Observable<Any>.create { observer in
            observer.onNext(["name":"Tom"])
            return Disposables.create()
        }
        observable = observable.flatMap { val in
            return Observable<Any>.create { observer in
                self.requestUserWallet { val in
                    observer.onNext(["money":"100"])
                }
                return Disposables.create()
            }
        }
        observable.subscribe { val in
            self.moneySubject.onNext(val.element!)
        }.disposed(by: disposeBag)
    }
3.在失敗情況下重新請求

最多允許請求失敗的次數為retryTimes，超過retryTimes則停止任務，發送錯誤原因
OC

/// 請求失敗后重試
- (void)requestMultiTimesWhenFailed {
    @weakify(self);
    __block NSInteger failedTimes = 0;
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        @strongify(self);
        [self requestOrderList:^(BOOL status, id  _Nonnull info) {
            if (!status) {
                failedTimes ++;
                if (failedTimes <= self.retryTimes) {
                    NSLog(@"請求失敗次數%ld", failedTimes);
                    [subscriber sendError:nil];
                } else {
                    NSLog(@"請求失敗次數%ld，不再自動請求", failedTimes);
                }
            } else {
                [subscriber sendNext:info];
            }
        }];
        return nil;
    }];
    
    RACSignal *retrySignal = [signal retry];
    [retrySignal subscribeNext:^(id  _Nullable x) {
        @strongify(self);
        [self.orderListSubject sendNext:x];
    }];
}

Swift

/// 請求失敗后重試，獲取訂單信息
    func requestMultiTimesWhenFailed() {
        Observable<Any>.create { observer in
            self.requestOrderList { status, val in
                if status == true {
                    observer.onNext(val)
                } else {
                    self.curFailedTimes += 1
                    if self.retrytimes < self.curFailedTimes {
                    } else {
                        print("失敗\(self.curFailedTimes)")
                        observer.onError(NSError(domain: "網絡異常", code: 502, userInfo: nil))
                    }
                }
            }
            return Disposables.create()
        }.retry(self.retrytimes).subscribe { val in
            self.orderListSubject.onNext(val)
        } onError: { error in
            print(error.localizedDescription);
        }.disposed(by: disposeBag)
    }
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容