RxJava学习笔记1

RxJava：Reactive ->响应式编程框架

整体采用观察者设计模式<被观察着Observable ,观察者(订阅者) Observer (Subscriber) >

作用总结为：异步操作 观察者模式本身的目的就是『后台处理，前台回调』的异步机制

优势:简洁<这里说的是使逻辑简单明了,并不是单纯的代码数量> 所有的复杂的逻辑都可以简化成一条链上的操作 这个稍后用代码来实际验证一下

概念介绍: 既然是观察者模式,RxJava也包含了下列四个对象:

• Observable (可观察者，即被观察者)、
• Observer (观察者)、
• subscribe (订阅)、

• 事件。
  Observable 和 Observer 通过 subscribe() 方法实现订阅关系，
  从而 Observable 可以在需要的时候发出事件来通知 Observer。

  就和设置事件监听器的感觉一样,有木有,这下感觉有木有清晰点,能干嘛知道了吧
  不知道,这么说吧,
  你室友跟你说，吃饭的时候叫我一起,然后你到了吃饭的时候，你就会叫他，然后一起去吃饭
  Observable ——你
  Observer——你室友
  subscribe——跟你说好的
  事件 ——吃饭
  

//注意这是我去掉了许多不是重点的重要代码 什么重写标识,我就不留着了占地方 我们看重点Observer<String> observer = new Observer<String>() { //监听器么,重写了三个方法,可以在这三个方法里做自己想做的事情，注意,<T> 这里面的类型就是 传递给观察者的数据类型,    public void onNext(String s) {}//这里的数据也是相应的数据类型    public void onCompleted() {} //完成了就完成了呗，没必要把数据传给你吧    public void onError(Throwable e) {} //错误了，传回来了一个错误信息体，可以打印出来让我们知道怎么了};

注意,请看我的前面的观察者后面有一个订阅者Subscriber，可以说和观察者一样的哦，用起来也差不多，也是实现了Observer 的一个抽象类: 既然名字不一样 我们直接看区别吧
区别:
1.多出来了一个回调方法(这是一个可选方法，默认情况下它的实现为空)onStart():

会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。

注意，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。想指定工作线程后面说，现在不说多了，以免乱了

2.多出来一个可以调用的方法 unsubscribe()
Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅，取消订阅之后就不会再接收到相应事件。

调用前，可以使用 isUnsubscribed() 先判断一下。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

2.创建 Observable

Observable 即被观察的对象，它决定什么时候触发事件以及触发怎样的事件。

RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则：

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {    public void call(Subscriber<? super String> subscriber) {         subscriber.onNext("Aloha");        subscriber.onCompleted();    }});

传入一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的相当于一个计划表

当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定顺序依次触发（对于上面的代码，就是观察者Subscriber 将会被调用1次 onNext() 和1次 onCompleted()）。

被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

这是个比较完整的创建模式,对于创建对观察对象，还有几个常用的创建方法

just(T…): 将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");// 将会依次调用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

from(T[])将传入的数组 拆分成具体对象后，依次发送出来
from(Iterable

String[] words = {"Hello", "Hi", "Aloha"};Observable observable = Observable.from(words);// 将会依次调用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

3.Subscribe (订阅)

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。代码形式很简单：

observable.subscribe(observer);// 或者：observable.subscribe(subscriber);

分析subcribe()的方法内部 ,核心代码部分

public Subscription subscribe(Subscriber subscriber) {    subscriber.onStart(); //先调用 start方法     onSubscribe.call(subscriber);//再将订阅者传入call方法 实现进一步回调      //Observable 并不是在创建的时候就立即开始发送事件，而是在它调用subscribe() 方法执行的时候。    return subscriber;//返回观察者}

//订阅者的不完整实现  Action0, 1, 2, 3, 4 >>> > 参数的个数        无参数 -> onComplete()        一个参数（Throwable e）->onError        一个参数(T t)->onNext()        Action1<String> onNext = new Action1<String>() {            public void call(String s) {            }        }; //next        Action1<Throwable> onError = new Action1<Throwable>() {            public void call(Throwable throwable) {            }        };        Action0 onCompleted = new Action0() {            public void call() {            }        };

// 自动创建 Subscriber

//使用 onNext 来定义 onNext()
observable.subscribe(onNext);

// 使用 onNext 和 onError 来定义 onNext() 和 onError()
observable.subscribe(onNext, onError);

// 使用 onNext、 onError 和 onCompleted 来定义 onNext()、 onError() 和 onCompleted()
observable.subscribe(onNext, onError, onCompleted);

“`

在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。
只用上面的方法，实现的只是一个同步的观察者模式。
观察者模式本身的目的就是
“后台处理，前台回调”的异步机制，
要实现异步(异步才是RxJava的重点)，
需要使用RxJava中的重头戏 >>>>>>>>>>>>”Scheduler” 来实现线程调度
下一篇吧
——————————————————————————————