RxSwift: 网络请求，数据共享分发

本文主要是介绍RxSwift: 网络请求，数据共享分发，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一般 OOP 常见的一步，网络请求，获取数据，刷新 UI

使用 RxSwift, 这一步，可拆分成两步，

网络请求，获取数据，是一步

刷新 UI，是第二步

多个控制器，有同样的网络请求，去做数据共享与同步

的场景下，有用

• 采用通知：

去做一个网络请求，刷新界面。

这样的指令会有两条

NotificationCenter.default.rx.notification(.readNetRequest)
            .takeUntil(self.rx.deallocated)
            .subscribe(onNext: { [weak self] ( noti ) in
            guard let `self` = self else { return }
            
                self.doReadNetRequestAndDoRefreshUI()
          
        }).disposed(by: rx.disposeBag)
复制代码

• 采用 RxSwift：

去请求一次网络，订阅了的界面去刷新

比起用通知，网络请求少了一次。

NetMangerPublisher.f.outputStudy.subscribe(onNext: { (data) in
            self.doRefreshUI()
        }).disposed(by: rx.disposeBag)
复制代码

读操作的网络请求，体现较少。写操作的网络请求，体现明显。

网络请求管理，由行为驱动，需要时请求数据，

改为数据驱动，数据更新，UI 更新。

UI 状态，总是和最新的数据保持一致。

这样方便的实现了数据共享

struct NetMangerPublisher {
    static var f = NetMangerPublisher()

 
    private let inputRead = BehaviorSubject<Bool>(value: true)
    
    private let inputWrite= PublishSubject<Bool>()
    
    var outputRead: Observable<[String: Any]?>
    var outputWrite: Observable<[String: Any]?>
    
    
    
    init(){

        outputRead = inputStudy.asObservable().map({ (_) -> Bool in
            Global.hasLogined()
        })
        .flatMapLatest { isRefreshing -> Observable<[String: Any]?> in
                            guard isRefreshing else { return .empty() }
                            return NetManager.standard.read()
        }.share(replay: 2, scope: SubjectLifetimeScope.forever)
        
        
        outputWrite = inputClock.asObservable().flatMapLatest{ (isRefreshing) -> Observable<[String: Any]?> in
            return NetManager.standard.write()
        }.share(replay: 4, scope: SubjectLifetimeScope.forever)
    }
    
    
    func doRead(){
        inputRead.onNext(true)
    }
    
    func doWrite(){
        inputWrite.onNext(true)
    }
}
复制代码

BehaviorSubject ，可以设置默认值。因为需要一个初始界面，一个 viewDidLoad 内的网络请求。一个初始的状态

PublishSubject， 适合用户的操作。用户不操作，什么事都不发生。

RxSwift 创建 Observable 的简单例子：

let disposeBag = DisposeBag()
        Observable<String>.create { observer in
            
            
            observer.onNext("1")
            observer.onCompleted()
            
            return Disposables.create()
        }
        .subscribe(
            onNext: { print($0) },
            onError: { print($0) },
            onCompleted: { print("Completed") },
            onDisposed: { print("Disposed") }
        )
        .disposed(by: disposeBag)
复制代码

create 方法定义了，发送给订阅者的所有事件

create 方法，有一个尾随闭包，里面有一个 AnyObserver 的泛型，充当观察者 observer

该 observer 可以添加事件，形成事件序列，发送给订阅者

上文中的网络例子：

func readData() -> Observable<[]>{
        return Observable<[String: Any]?>.create{ (observer) -> Disposable in
            self.readDataTask?.cancel()
            self.readDataTask = Base.netHud.request(.readData){ (result) in
                               // ......
                               observer.onNext(dat)
                               observer.onCompleted()
                                   
                              
                }
                return Disposables.create{
                    self.readDataTask?.cancel()
                }
            }
    }
复制代码

这篇关于RxSwift: 网络请求，数据共享分发的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！