RxJava入门之路（一）

RxJava接触过蛮长时间了，但是让我说个所以然来还是说不出来，归根结底还是还是理解不够深刻，趁着年底这个时候争取写个系列出来给自己的学习做个记录

注意区分RxJava1.0和2.0的区别，以下默认是在2.0的基础上做的测试

先来理解几个概念：

1、Observable : 字面意思可观察的，被观察者，也就是事件的发生者

2、Observer：观察者，也就是事件的接受者

3、subscribe()：两者产生订阅关系，需要注意一点的是 observable.subscribe(observer),感觉像是被观察者订阅了观察者，与常理不符，为什么这么设计呢？我估计是为了链式调用吧。。

一、最简单的使用方式：

 1  Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                    　e.onNext(1);
                    　e.onNext(2);
                    　e.onNext(3);
                    　e.onComplete();
        }
        }).subscribe(new Observer<Integer>() {

                     @Override
                     public void onSubscribe(Disposable d) {
                         Log.i(TAG, "onSubscribe: ");
                     }

                     @Override
                     public void onNext(Integer integer) {
                         Log.i(TAG, "onNext: "+integer);
                     }

                     @Override
                     public void onError(Throwable e) {
                         Log.i(TAG, "onError: "+e.getMessage());
                     }

                     @Override
                     public void onComplete() {
                         Log.i(TAG, "onComplete: complete");
                     }
   });

　　1、onNext()可以多次发送事件，onComplete()发送一次，多次调用不会报错，onError()发送一次，多次调用会报错，不可和onComplete()共存

　　2、调用onComplete()或者onError()后，观察者也无法接受到onNext()

　　3、Disposable(2.0新增)，当调用了dispose()后，观察者就无法接受到事件了

二、Cold Observable和Hot Observable

　　Cold Observable：只有当订阅者订阅的时候，数据流才开始发送，并且每个订阅者订阅的时候都会独立执行一遍数据流的发送(create(),just()....)

　　Hot Observable ：不管有没有订阅者订阅，一旦创建，就开始发送数据流

　　publish转化：

  ConnectableObservable<Long> ob=  Observable.interval(200, TimeUnit.MILLISECONDS).publish();//转化成Cold Observable
  ob.connect();//开始发送数据流

　　如果不调用connnect(),不会发送数据流，一旦调用，就会创建一个subscription并订阅到原Observable,将接受的数据转发给订阅者。

　　connect()与disConnect()

　　1.0 connect() 返回Subscription

　　2.0 connect() 返回Disposable

    //注意区分要释放哪个
    //释放s，则代表中断数据传输，再次连接则重新发送数据
    //释放d1或者d2,则代表取消注册，数据已然在传输
    public  void doSubscribe(View v){
        s= ob.connect();
      //public final void subscribe(Observer<? super T> observer) {} 无返回值，无法取消注册
      d1=  ob.subscribe(new Consumer<Long>() {
           @Override
           public void accept(Long aLong) throws Exception {
               Log.i(TAG, "onNext: first============"+aLong);
           }
       });
        d2=ob.subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.i(TAG, "accept: second=========="+aLong);
            }
        });
    }

　　RefCount

 Observable<Long> ob=  Observable.interval(200, TimeUnit.MILLISECONDS).publish().refCount();

　　如果有订阅者就会发送数据流，无订阅数据流即停止,再次订阅重新开始发送（可能会和Cold Observable混淆，注意此处每个订阅者接受到的数据是相同的）

　　Reply

 ConnectableObservable<Long> ob=  Observable.interval(200, TimeUnit.MILLISECONDS).replay();
 ob.connect();

　　当和源 Observable 链接后，开始收集数据。当有 Observer 订阅的时候，就把收集到的数据线发给 Observer。然后和其他 Observer 同时接受数据

　　可以同时设置收集数据的个数及时间

　　Cache

Observable<Long> ob=  Observable.interval(200, TimeUnit.MILLISECONDS).take(5).cache();//只有当订阅者订阅后才开始发送数据

　　与Reply类似，订阅者全部取消后也不会停止发送。