Swift5.0 - day13 - 响应式编程

一、响应式编程

• 1.1、响应式编程(Reactive Programming，简称RP)
  响应式编程是一种编程范式，于1997年提出，可以简化异步编程，提供更优雅的数据绑定，一般与函数式融合在一起，所以也会叫做:函数响应式编程(Functional Reactive Programming，简称FRP)
• 1.2、响应式编程比较著名的、成熟的响应式框架
  • (1)、ReactiveCocoa，简称RAC，有Objective-C、Swift版本
    官网
    github
  • (2)、ReactiveX，简称Rx，有众多编程语言的版本，比如RxJava、RxKotlin、RxJS、RxCpp、RxPHP、RxGo、RxSwift等等
    官网
    github

二、RxSwift

• 2.1、RxSwift(ReactiveX for Swift)，ReactiveX的Swift版本
  RxSwift 源码
  RxSwift中文文档
  建议：RxSwift 是一个比较重的框架，用到它可以说整个项目都可离不开它，与 RAC 差不多

• 2.2、 RxSwift 在github上已经有详细的安装教程，这里只演示CocoaPods方式的安装

  // 第一步
  cd 项目
  // 第二步 生成Podfile文件
  pod init   
  
  // 第三步，用Xcode打开Podfile文件，导入RxSwift
  platform :ios, '9.0'
  
  target '项目名称' do
      use_frameworks!
  
      pod 'RxSwift', '~> 5'
      pod 'RxCocoa', '~> 5'
  
  end
  // 第四步 自动导入RxSwift
  pod install
  

  提示：项目名称就是 target_name

• 2.3、导入 RxSwift

  import RxSwift
  import RxCocoa
  

  模块说明

  • RxSwift:Rx标准API的Swift实现，不包括任何iOS相关的内容
  • RxCocoa:基于RxSwift，给iOS UI控件扩展了很多Rx特性

• 2.4、RxSwift 的核心角色

  • Observable:负责发送事件(Event)

  • Observer:负责订阅Observable，监听Observable发送的事件(Event)

    

    public enum Event {
         /// Next element is produced. 
         case next(Element)
         /// Sequence terminated with an error.
         case error(Swift.Error)
         /// Sequence completed successfully.
         case completed
    }
    

  • Event有3种

    • next: 携带具体数据
    • error: 携带错误信息，表明Observable终止，不会再发出事件
    • completed: 表明Observable终止，不会再发出事件

• 2.5、创建、订阅 Observable 一

  let observable = Observable.create { observer in
        
        observer.onNext(1)
        observer.onCompleted()
        return Disposables.create()
  }
    
  observable.subscribe { (event) in
        switch event {
        case .next(let element):
            print(element)
        case .error(let error):
            print(error)
        case .completed:
            print("completed")
        }
    }
  

  上面的observable创建等价于下面的

  • let observable = Observable.just(1) // just后面是一个整体，可以是数组，如：Observable.just([1,2,3])
  • let observable = Observable.of(1)
  • let observable = Observable.from([1])

  订阅 observable.subscribe 还可以写为如下的表达式

  observable.subscribe(onNext: { (element) in
      print(element)
  }, onError: { (error) in
      print(error)
  }, onCompleted: {
      print("completed")
  })                                            
  

  如果我们只想 subscribe 执行一次可以加上 dispose(),也就是subscribe的返回值调用 dispose()，如下，那么再次发送订阅也不会再去执行

  observable.subscribe { (event) in
  }.dispose()
  
  observable.subscribe(onNext: { (element) in
       print(element)
  }, onError: { (error) in
       print(error)
  }, onCompleted: {
       print("completed")
  }).dispose()
  

• 2.6、创建、订阅 Observable 二

  let bag = DisposeBag()
  
  let label = UILabel(frame: CGRect(x: 10, y: 100, width: 100, height: 30))
  label.backgroundColor = UIColor.white
  self.view.addSubview(label)
    
  let observable = Observable.timer(.seconds(3),period: .seconds(1),scheduler: MainScheduler.instance)
  observable.map { "数值是\($0)" }.bind(to: label.rx.text) .disposed(by: bag)
  

• 2.7、创建 observer

  let observer = AnyObserver.init { event in switch event {
       case .next(let data):
          print(data)
       case .completed:
          print("completed")
       case .error(let error):
          print("error", error)
  } }
  Observable.just(1).subscribe(observer).dispose()
  let binder = Binder(label) { label, text in label.text = text }
  Observable.just(1).map { "数值是\($0)" }.subscribe(binder).dispose() 
  Observable.just(1).map { "数值是\($0)" }.bind(to: binder).dispose()
  

• 2.8、扩展 Binder 属性

  extension Reactive where Base: UIView {
      var hidden: Binder {
         Binder(base) { view, value in
             view.isHidden = value
         } 
      }
  }
  
  let observable = Observable.interval(.seconds(1),
                                      scheduler: MainScheduler.instance)
  observable.map { $0 % 2 == 0 }.bind(to: button.rx.hidden).disposed(by: bag)
  

• 2.9、传统状态的监听，在开发中经常要对各种状态进行监听，传统的常见监听方案有

  • KVO
  • Target-Action
  • Notification
  • Delegate pBlock Callback

  传统方案经常会出现错综复杂的依赖关系、耦合性较高，还需要编写重复的非业务代码

• 2.10、RxSwift的状态监听一

  • button 事件的监听

    button.rx.controlEvent(UIControl.Event.touchUpInside).subscribe(onNext: { (sender) in
        print("点击了target,tag=\(sender)")
    }).disposed(by: bag)
    

    提示：如果仅仅是点击事件我们可以使用 button.rx.tap

  • tableview 数据的绑定监听

    let data = Observable.just([ Person(name: "Jack", age: 10), Person(name: "Rose", age: 20)])
    
    data.bind(to: tableView.rx.items(cellIdentifier: "cell")) { row, person, cell in
        cell.textLabel?.text = [person.name](person.name)
        cell.detailTextLabel?.text = "\(person.age)" 
    }.disposed(by: bag)
    
    tableView.rx.modelSelected(Person.self) .subscribe(onNext: { person in
        print("点击了", [person.name](person.name)) 
    }).disposed(by: bag)
    
    tableView.rx.itemSelected.subscribe(onNext: { path in 
        print("点击了", path) 
    }).disposed(by: bag)
    

    提示：如果cell使我们自定义的，那么 .items(cellIdentifier: "cell"))，后面的type要写：.items(cellIdentifier: "cell", cellType: 自定义cell的名字.self))

• 2.11、RxSwift的状态监听二

  class Dog: NSObject {
      @objc dynamic var name: String?
  }
  
  dog.rx.observe(String.self, "name").subscribe(onNext: { name in
  
      print("name is", name ?? "nil")
  
  }).disposed(by: bag)
  
  [dog.name](dog.name) = "larry"
  [dog.name](dog.name) = "wangwang"
  

• 2.12、RxSwift的状态监听三：通知，下面是进入后台的通知

  NotificationCenter.default.rx.notification(UIApplication.didEnterBackgroundNotification).subscribe(onNext: { notification in
         print("APP进入后台", notification) 
  }).disposed(by: bag)
  

• 2.12、既是Observable，又是Observer

  [Observable.just(0.8).bind(to](Observable.just(0.8).bind(to): slider.rx.value).dispose()
  

  滑块的value

  slider.rx.value.map { "当前数值是:\($0)"}.bind(to: textField.rx.text).disposed(by: bag)
  

  textField内容的监听

  textField.rx.text.subscribe(onNext: { text in
     print("text is", text ?? "nil")
  }).disposed(by: bag)
  

  诸如UISlider.rx.value、UTextField.rx.text这类属性值，既是Observable，又是Observer ，它们是 RxCocoa.ControlProperty 类型

• 2.13、Disposable

  • 每当Observable被订阅时，都会返回一个Disposable实例，当调用Disposable的dispose，就相当于取消订阅
  • 在不需要再接收事件时，建议取消订阅，释放资源。有3种常见方式取消订阅

    • 立即取消订阅(一次性订阅)

      observable.subscribe { event in
           print(event)
      }.dispose()
      

    • 当bag销毁(deinit)时，会自动调用Disposable实例的dispose

      observable.subscribe { event in
           print(event)
      }.disposed(by: bag)
      

    • self销毁时(deinit)时，会自动调用Disposable实例的dispose

      let _ = observable.takeUntil(self.rx.deallocated).subscribe { event in
          print(event)
      }
      

最后：航歌里面有更多的RxSwift的用法，大家可以学习