A-A+

RxSwift + MVVM 项目实战

2022年02月18日 iOS原创文章 暂无评论
博客主机

RxSwift 是什么? 为什么要引入它?它有什么优点、好处呢?

函数式编程:利用高阶函数,即将函数作为其它函数的参数。

响应式编程:关注于数据流及变化的传播。

概述

见名知意,RxSwift 是在 Apple 推出 Swift 后,针对 Swift 语言 ReactiveX 推出 Reactive Extensions 系列一个实现库;除此之外,ReactiveX 还推出了 RxJava,RxAndroid,RxPHP 等蕴含类似思想的框架。

为什么要学习RxSwift?

我们知道 C 语言的面向过程,Objective-C、C++ 面向对象编程, Java 的 Spring 框架提出了面向切面编程的思想,学习 RxSwift 不是学习如何使用第三方库,而是学习一种编程思想--函数响应式编程;

Target Action

传统实现方法:

button.addTarget(self, action: #selector(buttonTapped), for: .touchUpInside)
func buttonTapped() {
    print("button Tapped")
}

通过 Rx 来实现:

button.rx.tap
    .subscribe(onNext: {
        print("button Tapped")
    })
    .disposed(by: disposeBag)

你不需要使用 Target Action,这样使得代码逻辑清晰可见。

代理

传统实现方法:

class ViewController: UIViewController {
    ...
    override func viewDidLoad() {
        super.viewDidLoad()
        scrollView.delegate = self
    }
}

extension ViewController: UIScrollViewDelegate {
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        print("contentOffset: \(scrollView.contentOffset)")
    }
}

通过 Rx 来实现:

class ViewController: UIViewController {
    ...
    override func viewDidLoad() {
        super.viewDidLoad()

        scrollView.rx.contentOffset
            .subscribe(onNext: { contentOffset in
                print("contentOffset: \(contentOffset)")
            })
            .disposed(by: disposeBag)
    }
}

你不需要书写代理的配置代码,就能获得想要的结果。

通知

传统实现方法:

var ntfObserver: NSObjectProtocol!

override func viewDidLoad() {
    super.viewDidLoad()

    ntfObserver = NotificationCenter.default.addObserver(
          forName: .UIApplicationWillEnterForeground,
          object: nil, queue: nil) { (notification) in
        print("Application Will Enter Foreground")
    }
}

deinit {
    NotificationCenter.default.removeObserver(ntfObserver)
}

通过 Rx 来实现:

override func viewDidLoad() {
    super.viewDidLoad()

    NotificationCenter.default.rx
        .notification(.UIApplicationWillEnterForeground)
        .subscribe(onNext: { (notification) in
            print("Application Will Enter Foreground")
        })
        .disposed(by: disposeBag)
}

你不需要去管理观察者的生命周期,这样你就有更多精力去关注业务逻辑。

4、等待多个并发任务完成后处理结果

例如,需要将两个网络请求合并成一个,

通过 Rx 来实现:

/// 用 Rx 封装接口
enum API {

    /// 取得老师的详细信息
    static func teacher(teacherId: Int) -> Observable<Teacher> { ... }

    /// 取得老师的评论
    static func teacherComments(teacherId: Int) -> Observable<[Comment]> { ... }
}

/// 同时取得老师信息和老师评论
Observable.zip(
      API.teacher(teacherId: teacherId),
      API.teacherComments(teacherId: teacherId)
    ).subscribe(onNext: { (teacher, comments) in
        print("获取老师信息成功: \(teacher)")
        print("获取老师评论成功: \(comments.count) 条")
    }, onError: { error in
        print("获取老师信息或评论失败: \(error)")
    })
    .disposed(by: disposeBag)

这样你可用寥寥几行代码来完成相当复杂的异步操作。

Why use RxSwift?

A vast majority of the code we write involves responding to external events. When a user manipulates a control, we need to write an @IBAction handler to respond. We need to observe notifications to detect when the keyboard changes position. We must provide closures to execute when URL sessions respond with data. And we use KVO to detect changes to variables. All of these various systems makes our code needlessly complex. Wouldn't it be better if there was one consistent system that handled all of our call/response code? Rx is such a system.
RxSwift is the official implementation of Reactive Extensions (aka Rx), which exist for most major languages and platforms.

翻译:

我们编写的绝大多数代码涉及对外部事件的响应。当一个用户操作控制,我们需要写一个@IBAction处理器响应。当键盘改变位置时,我们需要观察通知来检测。当URL会话响应数据时,必须提供闭包来执行。我们使用KVO的变化来检测变量。所有这些不同的系统使我们的代码不必要的复杂。如果有一个一致的系统处理我们所有的呼叫/响应代码,这不是更好吗?Rx就是这样一个系统。
RxSwift是官方实现的Reactive扩展正(又名Rx),存在的最主要的语言和平台。

RxSwift的优点

  • Composable 可组合,在设计模式中有一种模式叫做组合模式,你可以方便的用不同的组合实现不同的类
  • Reusable 代码可重用,原因很简单,对应RxSwift,就是一堆Obserable
  • Declarative 响应式的,因为状态不可变,只有数据变化
  • Understandable and concise 简洁,容易理解, 因为它抽象的了异步编程,使我们统一了代码风格。
  • Stable 稳定,因为RxSwift写出的代码,单元测试时分方便
  • Less stateful “无”状态性,因为对于响应式编程,你的应用程序就是一堆数据流
  • Without leaks 没有泄漏,因为资源管理非常简单

响应式编程:ReactiveCocoa vs RxSwift 选谁好?

RAC是一个已经有着3年历史的项目,从Objective-C时期开始,后来从3.0开始支持了swift(可以通过bridge在OC下使用),接着就完全停止了在Objective-C上的维护。RxSwift项目的时间短一些只有几个月(作者写的时间是15年),但是社区似乎充满了动力。关于RxSwift有一件重要的事是项目是按照 ReactiveX这个组织的规定下开发的,并且所有其他语言的Rx项目也是一样。如果学会了如何使用RxSwift,再去学习Rx.Net, RxJava 或者 RxJS就是小菜一碟,只是语言语法上的差异。这真的就是learn once, apply everywhere.

![[email protected]](https://upload-images.jianshu.io/upload_images/5142622-f640a492764bc0f5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

如果项目中有oc,就用ReactiveCocoa;
要是用没有,就用RxSwift咯

RxSwift comprises five separate components depending on eachother in the following way:

RxSwift comprises.png

1.png

1、RxSwift 中文文档
https://github.com/beeth0ven/RxSwift-Chinese-Documentation
2、官网  Observable
http://reactivex.io/documentation/observable.html
3、官网  Operators
http://reactivex.io/documentation/operators.html
4、官网  Subject
http://reactivex.io/documentation/subject.html
5、官网  Single
http://reactivex.io/documentation/single.html
6、官网  Scheduler
http://reactivex.io/documentation/scheduler.html

RxSwift 核心流程

  1. 观察者(Observer)
  2. 被观察者(Observable)
  3. 订阅者(Subscriber) 事件的最终处理者
  4. 管道(Sink) Observer 和 Observable 沟通的桥梁

1 创建信号
2 订阅信号
3 发送信号

  /// MARK: - testDemo1
  private func testDemo1() {
    
    // 1.创建信号 observable
    requestObservable = Observable.create { (subscriber) -> Disposable in
      // 3.发送消息
      self.count += 1
      subscriber.on(.next("哈哈哈哈哈😂\(self.count)"))
      subscriber.on(.completed)
      
      return Disposables.create()
    }
    
    // 2.订阅信号
    requestObservable?.subscribe(onNext: { (text) in
      print("=== \(text)")
      self.mapPassword.text = text
    }).dispose()
  }

我们重点关注:

create 闭包什么时候执行,
subscribe 闭包又是什么时候执行的

[email protected]

Observable 继承体系

Observable的核心函数:

subscribe 订阅操作, Observable 和 Observer 通过订阅建立联系,
Observable 好比水源, Observer 好比水龙头(永远开着的水龙头), 订阅的过程就是在Observable 和 Observer 之间建立管道, 一旦建立管道即是永久性的,只要水源有谁, 水龙头就会有水。
run 对用户不可见,隐藏了大量的实现细节, 这个函数就是建立水管的过程
asObservable: 这个协议的存在使得Observable 的定义变得更加广泛。

首先说一下继承体系: AnonymousObservable -> Producer -> Observable -> ObservableType -> ObservableConvertibleType
每一层都只处理一点点事情,剩下的交给下一层处理

ObservableConvertibleType: 完全的抽象

ObservableType: 处理subscribe

Observable: 处理 asObservable

Producer: 重载subscribe

AnonymousObservable: 处理run

也就是说如果说如果我们要自定义一个Observable的话,通常只需要继承Producer, 并实现run方法。AnonymousObservable做的事情也不多,实现run方法,作为create闭包的持有者。

run方法涉及另外一个类AnonymousObservableSink,Sink作为Observer 和 Observable的衔接的桥梁,之前还在想为什么叫做ObservableSink,现在想明白了。Sink本身遵守ObseverType协议,与此同时实现了run方法,虽然没有实现subscribe方法,但是已经足够了,这样sink从某种程度来说也是Observable,通过sink就可以完成从Observable到Obsever的转变。

Observer 继承体系

核心语句

// Producer Class
  override func subscribe<O : ObserverType>(_ observer: O) -> Disposable where O.E == Element {
        if !CurrentThreadScheduler.isScheduleRequired {
            // The returned disposable needs to release all references once it was disposed.
            let disposer = SinkDisposer()
            let sinkAndSubscription = run(observer, cancel: disposer)
            disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

            return disposer
        }
        else {
            return CurrentThreadScheduler.instance.schedule(()) { _ in
                let disposer = SinkDisposer()
                let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)

                return disposer
            }
        }
    }

我们来看看run的逻辑

   // AnonymousObservable Class
    override func run<O : ObserverType>(_ observer: O, cancel: Cancelable) -> (sink: Disposable, subscription: Disposable) where O.E == Element {
        let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
        let subscription = sink.run(self)
        return (sink: sink, subscription: subscription)
    }

在进行订阅的过程中,Producer 的subscribe :方法里面,通过
let sinkAndSubscription = self.run(observer, cancel: disposer)这个核心语句
运行run()方法,通过实例AnonymousObservable实现的run()方法,调取AnonymousObservableSink 的run()方法,通过参数的形式,将自己传给了Sink 类,observer ;因为Sink类中持有一个observer 。 AnonymousObservableSink 的方法里面有

    func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }

终于触发subscribeHandler了,这里的subscribeHandler就是之前最开始的闭包。

Observable<String>.create { observer -> Disposable in
      observer.onNext("hello")
      return Disposables.create()
  }

稍微解释一下整个过程分为两个阶段:

Obsevable 构建阶段,这里使用create构造方法构造Obsevable,还有其他各种各样的构造方法,这里不一一赘述。
subscribe 阶段, Obsevable.subscribe ---> Obsevable.run ----> Sink.run ----> AnyObserver.On ----> Sink.on ----> Observer.On ---> Observer.OnCore ----> eventHandler

作者:xiaobeibei
链接:https://www.jianshu.com/p/e0970b524ab2
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

给我留言

Copyright © ios教程,苹果粉丝,苹果资讯,ios入门教程,ios学习,ios程序员,ios视频教程,ios粉丝网 保留所有权利.   Theme  Ality

用户登录