RXSwift 初次探索

RXSwift的最初探索

iOS 中 我们常用到的函数式编程 oc中的RAC 和 swift中的RXSwift 是非常有影响力的，最近也是尝试着查看RXSwift的相关信息，今天就从rxswif 入手：

rxswift 的使用方式

例如 我们常见使用的观察者模式：在swift 中的使用方式是：

self.person.addObserver(self, forKeyPath: "name", options: .new, context: nil)   
//然后 实现代理

  override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
     print("响应")
     print(change as Any)
 }

 deinit {
    self.removeObserver(self.person, forKeyPath: "name", context: nil)
        }

这样去执行 并且去观察 对象的输出变化
但是在rxswift 中 的代码块是这样子的

 self.person.rx.observeWeakly(String.self, "name")
         .subscribe(onNext: { (value) in
             print(value as Any)
         })
         .disposed(by: disposeBag)

这样 能实现以上观察者模式相同的代码内容，完成业务需求。同理，我们可以执行一些其他的对象rx的使用方式：

// UItextFiled:
   self.textFiled.rx.text.orEmpty
         .subscribe(onNext: { (text) in
            print(text)
         })
         .disposed(by: disposeBag)
//UIButton:的使用方式    
     self.button.rx.tap
         .subscribe(onNext: { () in
            print("点击来了")
        })
                   .disposed(by: disposeBag)    
         
//            

此时，会有疑惑，为什么多个对象都是拥有rx这个属性的。 这个就需要进入到rx 的里面去查询
以button为例子：

 associatedtype CompatibleType

   /// Reactive extensions.
   static var rx: Reactive.Type { get set }

   /// Reactive extensions.
   var rx: Reactive { get set }

associatedtype 拓展

定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分将会非常有用。关联类型为协议中的某个类型提供了一个占位名（或者说别名），其代表的实际类型在协议被采纳时才会被指定。
在这里，因为作者开发大多是用于oc 对iOS APP的开发，对于oc开发者来说，associatedtype类似于扩展和类别，实现这个的方法。 ok 我们继续下去

在所有的对象文件rx 文件中，我们能看到public protocol ReactiveCompatible,那么 我们就能能理解为，rxswift 在对每个对象，做到了协议 然后关联到了对象上面，那么rxswift 是怎么去关联的呢？

extension NSObject: ReactiveCompatible { }
//万物皆对象啊 兄弟们 /// 打个666

然后讲讲Observable

 let ob = Observable.create { (obserber) -> Disposable in
            发送信号
            obserber.onNext("")
            obserber.onCompleted()
            obserber.onError(NSError.init(domain: "error info ", code: 8888, userInfo: nil))
            return Disposables.create()
        }

这个地方是对创建的信号序列 的创建 以及信息的发送，

   let _ = ob.subscribe(onNext: { (text) in
            print("\(text)")
        }, onError: { (error) in
            print("error: \(error)")
        }, onCompleted: {
            print("完成")
        }) {
            print("销毁")
        }
       

这里 是对信息的接收 那么 rx 内部的实现 就是对序列 信号的响应
在这里 可以思考下 为什么 UI层能够被rx 所捕捉到呢？
思考：

@available(iOS 2.0, *)
open class UIControl : UIView {

   // add target/action for particular event. you can call this multiple times and you can specify multiple target/actions for a particular event.
   // passing in nil as the target goes up the responder chain. The action may optionally include the sender and the event in that order
   // the action cannot be NULL. Note that the target is not retained.
   open func addTarget(_ target: Any?, action: Selector, for controlEvents: UIControl.Event)

点击controller 不难发现 我们看到了 addTarget
在此 是否可以理解为 rx内部的实现 是否是有对addTarget的监听 然后 通过selector 去执行了onNext 方法发送信号呢？

继续...

  public static func create(_ subscribe: @escaping (AnyObserver) -> Disposable) -> Observable {
       return AnonymousObservable(subscribe)
   }
   返回一个匿名的内部类
   
   final private class AnonymousObservable: Producer {
   typealias SubscribeHandler = (AnyObserver) -> Disposable

   let _subscribeHandler: SubscribeHandler

   init(_ subscribeHandler: @escaping SubscribeHandler) {
       self._subscribeHandler = subscribeHandler
   }

   override func run(_ 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 的 并且 typealias SubscribeHandler = (AnyObserver) -> Disposable

   let _subscribeHandler: SubscribeHandle

对这个闭包 做了保存处理

那么 继续看subscribe

内容里面 我们看到
let observer = AnonymousObserver
是对observer 的初始化，但是并没有对应上Observable的obserber
点击asObservable（） 发现返回的就是ob对象，并且 我们从Observable 中 并没有发现subscribe 的方法，那么继续 我们根据之前的AnonymousObservable 这个匿名函数 点击进去发现了 继承与Producer

在点击进去之后 有个 override func subscribe 的方法，这个里面

  let sinkAndSubscription = self.run(observer, cancel: disposer)
                disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
                
     func run(_ parent: Parent) -> Disposable {
        return parent._subscribeHandler(AnyObserver(self))
    }
                

是将这个交给了子类去实现 run 方法
然后子类实现就是把之前保存的
typealias Parent = AnonymousObservable parent._subscribeHandler(AnyObserver(self)) 当前保存的闭包 提交了出去 ，那么 看到的

  return Disposables.create(
              self.asObservable().subscribe(observer),
              disposable
          )

将我们之前ob 创建的对象内容提交到了 subscribe

也就是说 obserber.onNext("我就玩玩")
发送后 subscribe里面的

 let observer = AnonymousObserver { event in
               
               #if DEBUG
                   synchronizationTracker.register(synchronizationErrorMessage: .default)
                   defer { synchronizationTracker.unregister() }
               #endif
               
               switch event {
               case .next(let value):
                   onNext?(value)
               case .error(let error):
                   if let onError = onError {
                       onError(error)
                   }
                   else {
                       Hooks.defaultErrorHandler(callStack, error)
                   }
                   disposable.dispose()
               case .completed:
                   onCompleted?()
                   disposable.dispose()
               }
           }

就捕捉到了信号 然后根据闭包 返回到了 我们所需要的onnet 接收器内

目前 这就是我所理解的信号 0点了 睡觉 有问题的 大家帮我找下 我好纠正我的观点