RxSwift初体验之实战演习

概述

Rx 通过 Observable<Element>接口来表达计算型泛型抽象 (generic abstraction of computation) 的概念，而 RxSwift 是 Rx 的 Swift 版本。无疑，这个内容非常庞大，所以我打算用真是代码侧面描述一下自己对使用的一些心得体会以一种稍微简单点的介绍方式来讲解这个框架。

1.首先我们要了解几个关键词
（1）Variable
Variable表示一个可监听的数据结构。使用Variable，你可以监听数据的变化，也可以把其他值绑定到它身上。

例子一
class VariableController: UIViewController {
    
    @IBOutlet weak var label: UILabel!
    var disposeBag = DisposeBag()
    var timer:Timer?
    var count = Variable(0)
    override func viewDidLoad() {
        super.viewDidLoad()
        timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector:#selector(VariableController.updateValue) , userInfo: nil, repeats: true)
        _ = count.asObservable().subscribe(onNext: { (num) in
            self.label?.text = "VariableValue:\(num)"
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
    }
    func updateValue(){
        count.value = count.value + 1
    }
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        timer?.invalidate()
    }
}
例子二
//我们在viewmodel里面创建Variable的变量
var isValidLoading: Variable = Variable("")
self.isValidLoading.value = "show"
//在vc里面去监听做操作
self.viewModel.isValidLoading.asObservable().subscribe(onNext: { (result) in
            if result == "show"{
                self.showLoading()
            }else{
                self.hideLoading()
            }
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
//注意这里的subscribe后会的到next（），必须通过onNext去取到里面的值

(2)Observable
Observable表示可监听或者可观察，也就是说RxSwift的核心思想是可监听的序列。并且，Observable sequence可以接受异步信号，也就是说，信号是可以异步给监听者的
Observable分为两种
(1)在有限的时间内会自动结束（Completed/Error）,比如一个网络请求当作一个序列，当网络请求完成的时候，Observable自动结束，资源会被释放
(2)信号不会自己结束，最简单的比如一个Timer，每隔一段时间发送一个新的信号过来，这时候需要手动取消监听，来释放相应的资源,又比如一个label.rac_text是一个Obserable，通常需要这样调用addDisposableTo(disposeBag)来让其在deinit，也就是所有者要释放的时候，自动取消监听。

信号处理的顺序
Observable有个隐式的约定，那就是在一个信号处理完成之前，不会发送下一个信号，不管发送信号的线程是并发的or串行的。

someObservable
  .subscribe { (e: Event<Element>) in
      print("Event processing started")
      // processing
      print("Event processing ended")
  }
//只会出现
Event processing started
Event processing ended
Event processing started
Event processing ended
Event processing started
Event processing ended
//不会出现
Event processing started
Event processing started
Event processing ended
Event processing ended

实例

//我们监听textfield的文字变化，然后，Log出text，当button点击的时候，取消这次监听
class ObservableAndCancelController : UIViewController{
    var subscription:Disposable?
    @IBOutlet weak var textfield: UITextField!
    @IBAction func cancelObserve(sender: AnyObject) {
        subscription?.dispose()
    }
    override func viewDidLoad() {
        super.viewDidLoad()
        subscription = textfield.rx.text.asObservable().subscribe(onNext:  { (text) in
            print(text)
        })
    }
}

map： 对信号（Element）进行映射处理。比如输入是String，影射到Bool
filter： 对信号(Element)进行过滤处理。返回信号，和输入的信号是同一种类型
combineLatest： 对两种信号的值进行结合。可以返回不同种类的信号。

 let firstObserverable = firstTextfield.rx.text.map({"first" + $0})
     let secondObserverable = secondTextfield.rx.text.filter({$0.characters.count > 3})
      _ =  Observable.combineLatest(firstObserverable, secondObserverable, resultSelector:{ ($0 + $1,$0.characters.count + $1.characters.count)}).subscribe(onNext:  { (element) in
            print("combineLatest:\(element)")
      }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)       
//打印
combineLatest:("first1234abcd", 13)
combineLatest:("first1234abcde", 14)
combineLatest:("first1234abcdef", 15)
combineLatest:("first1234abcdefg", 16)

Observerable可以用来处理任务，并且异步返回Event信号（Next,Error,Completion）

//Observable就是处理输入，并且把description发送出去
func createObserveable(object:AnyObject?)->Observable<String?>{
    return Observable.create({ observer in
        observer.onNext(object?.description)
        observer.onCompleted()
        return NopDisposable.instance
    })
}
_ = createObserveable(test).subscribe({ (event) in
      switch event{
      case .Next(let value):
          print(value)
      case .Completed:
          print("Completed")
      case .Error(let error):
          print(error)
      }
  })

创建一个Observable相当容易，调用Observable.create，在必要的时候发送onNext,onError,onCompleted信号。然后返回一个Disposable用来取消信号
(3)bindTo
数据绑定是开发的时候很常见的，比如根据文本的输入动态调整textfield的背景色，动态调整按钮的enable。亦或者根据textfield的输入变化，动态的去反馈到model层。如果你听过MVVM，那你肯定知道，MVVM的难点就是ViewModel与View的数据绑定问题。

//我们在viewmodel里面创建Observable的变量
var isValidSendButton: Observable<Bool>!
//在vc里面去和按钮的是否点击进行绑定
var disposeBag = DisposeBag()
self.viewModel.isValidSendButton.asObservable().bindTo(self.sendBtn!.rx.isEnabled).addDisposableTo(self.disposeBag)

讲到这里我们已经可以简单的来尝试做一下事情了

class ObservableAndCancelController : UIViewController{
    //userName 用来监听输入框的值
   //password 用来监听输入框的值
    var disposeBag = DisposeBag()
    //这里的UITextField和UIButton的布局就根据自己的想法实例化，这里没有写，所以直接运行是没有效果的
    var nameTextfield:UITextField?
    var passwordTextfield:UITextField?
    var registerButton:UIButton?
    
    var userName:Variable = Variable("")
    var password:Variable = Variable("")
    var validUserName:Observable<Bool>!
    var validPassword:Observable<Bool>!
    var isValidSendButton: Observable<Bool>!
    override func viewDidLoad() {
        super.viewDidLoad()
        self.nameTextfield?.rx.text.asObservable().subscribe(onNext:{ [weak self](result) in
            self?.userName.value = result!
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
        self.passwordTextfield?.rx.text.asObservable().subscribe(onNext:{ [weak self](result) in
            self?.password.value = result!
            }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
        
        validUserName = userName.asObservable().map({$0.characters.count >= 6}).shareReplay(1)
        validPassword = password.asObservable().map({$0.characters.count >= 8}).shareReplay(1)

        _ = validUserName.subscribe(onNext: { (valid) in
            self.nameTextfield?.backgroundColor = valid ? UIColor.clear:UIColor.lightGray
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
        _ = validPassword.subscribe(onNext: { (valid) in
            self.passwordTextfield?.backgroundColor = valid ? UIColor.clear:UIColor.lightGray
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)//addDisposableTo(disposeBag)是为了自动释放
        isValidSendButton = Observable.combineLatest(validUserName, validPassword) {$0 && $1}
        isValidSendButton?.subscribe(onNext: {(result:Bool) in
            if result{
            self.registerButton?.isEnabled = true
            self.registerButton?.backgroundColor = UIColor.red
            }else{
            self.registerButton?.isEnabled = false
            self.registerButton?.backgroundColor = UIColor.darkGray
            }
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
        self.isValidSendButton.asObservable().bindTo(self.registerButton!.rx.isEnabled).addDisposableTo(self.disposeBag)
        self.registerButton?.rx.tap.shareReplay(1).subscribe(onNext: { (result) in
            print("Button tapped")
        }, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(self.disposeBag)
    }
}

以上是在网上的一些学习体会和自己的实战总结，讲的不多，直讲到一些基础的使用方法，希望对入门的同学有些帮助，谢谢