swift 同步 网络请求_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(value: true)

private let inputWrite= PublishSubject()

var outputRead: Observable

var outputWrite: Observable

init(){

outputRead = inputStudy.asObservable().map({ (_) -> Bool in

Global.hasLogined()

})

.flatMapLatest { isRefreshing -> Observable in

guard isRefreshing else { return .empty() }

return NetManager.standard.read()

}.share(replay: 2, scope: SubjectLifetimeScope.forever)

outputWrite = inputClock.asObservable().flatMapLatest{ (isRefreshing) -> Observable 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.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.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()

}

}

}