Android打造自己的网络框架----RxJava的基础学习使用

现在流行RxJava,Retrofit,加上okhttp做网络框架，我当然不能落后。一步步的来，先认识RxJava.
在GitHub主页上的介绍：

一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库

讲道理有点抽象，我觉得它就是一个实现异步操作的库。

先说下它的优点吧

• RxJava的好处就在于它的简洁性，逻辑简单的时候看不出RxJava的优势，想必大家都知道在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。这时候RxJava的优势就来了，随着程序逻辑变得越来越复杂，它依然能够保持简洁

观察者模式

首先要先介绍一下观察者模式；（这里是照搬别人的理解）

• 观察者：监视着被观察者的行为，当被观察者某个状态改变的时候会通知观察者，观察者会执行对应的操作；
• 被观察者：被监视的对象，当某个状态改变的时候会通知观察者；
• 订阅（或注册）：将观察者和被观察者建立联系。

举个例子
button触发点击事件

• 观察者：OnClickListener；
• 被观察者：Button；
• 订阅（或注册）：setOnClickListener()。

RxJava

在上面介绍了观察者模式，这里也将RxJava中的三个角色进行一下角色分配

被观察者：Observable；
订阅（或注册）：subscribe()。

• 观察者：Observer；

Observer 即观察者，它决定事件触发的时候将有怎样的行为。
RxJava 观察者的事件回调方法除了普通事件onNext()之外，还定义了两个特殊的事件：onCompleted()和onError()。
这里我觉得理解为观察发生变化时观察进行的操作处理。

onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的onNext()发出时，需要触发onCompleted()方法作为标志。

onError(): 事件队列异常。在事件处理过程中出异常时，onError()
会被触发，同时队列自动终止，不允许再有事件发出。

在一个正确运行的事件序列中,onCompleted()和onError()有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted()
和onError()二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

• 被观察者

Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。可以使用create()、just(T...)、from(T[])或from(Iterable<? extends T>)来创建一个 Observable ，并为它定义事件触发规则。

• 订阅

创建了Observable和Observer之后，再用subscribe()方法将它们联结起来
直接看代码吧，这里只展示了RxJava的基本用法，暂时看不出RxJava的优势。

上面的内容有抄袭的嫌疑,这里我看了别人的博客有的话直接搬过来了
0。0

好了，下面我们开始谈谈使用
首先添加依赖

compile 'io.reactivex:rxjava:1.0.14'
compile 'io.reactivex:rxandroid:1.0.1'

首先给个简单的例子

       //创建一个观察者
        Observer<String> observer = new Observer<String>() {

            @Override
            public void onCompleted() {
                Log.i(TAG, "Completed");
            }

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

            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        };
        //使用Observable.create()创建被观察者
        Observable observable1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Wrold");
                subscriber.onCompleted();
            }
        });
        //订阅
        observable1.subscribe(observer);

上面就可以看到触发了，另一方面除了Observer接口之外，RxJava 还内置了一个实现了Observer的抽象：Subscriber。

• Subscriber

  基本相同

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e("====", "Item: " + s);
            }

            @Override
            public void onCompleted() {
                Log.e("====", "Completed!");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("====", "Error!");
            }
        };
        //使用Observable.create()创建被观察者
        Observable observable1 = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Wrold");
                subscriber.onCompleted();
            }
        });
        observable1.subscribe(subscriber);

有人可能回想这两个方法除了名字不是一模一样么，Subscriber有什么用呢？
其实如果只是用基本的功能二者确实没有什么太大的差异，但是Subscriber多两个方法onStart()，unsubscribe()

onStart(): 这是Subscriber增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行），onStart()就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用doOnSubscribe()方法，具体可以在后面的文中看到。

unsubscribe(): 这是Subscriber所实现的另一个接口Subscription
的方法，用于取消订阅。在这个方法被调用后，Subscriber将不再接收事件。一般在这个方法调用前，可以使用isUnsubscribed()先判断一下状态。unsubscribe()这个方法很重要，因为在subscribe()之后，Observable会持有Subscriber的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如onPause()onStop()等方法中）调用unsubscribe()来解除引用关系，以避免内存泄露的发生。

简单的来说，onStart()可以做些准备工作但是不能做有线程要求的准备。而unsubscribe()是用来实现取消订阅。

下面再介绍Observable的其他几种创建方法，

Observable observable2 = Observable.just("Hello", "World");

String [] words = {"Hello", "World"};
Observable observable3 = Observable.from(words);

List<String> list = new ArrayList<String>();
list.add("Hellow");
list.add("Wrold");
Observable observable4 = Observable.from(list);

就目前来就是觉得能用，但是代码有点多下面咱们瘦瘦身
接下来就是使用本次的主角Action来代替Subscriber
话不多说上代码

Observable.just("Hello", "World")
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, s);
                    }
                });

是不是忽然少了很多

介绍下
Action是RxJava 的一个接口，常用的有Action0和Action1。

Action0： 它只有一个方法 call()，这个方法是无参无返回值的；由于 onCompleted() 方法也是无参无返回值的，因此 Action0 可以被当成一个包装对象，将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。

Ation1：它同样只有一个方法 call(T param)，这个方法也无返回值，但有一个参数；与 Action0 同理，由于 onNext(T obj) 和 onError(Throwable error) 也是单参数无返回值的，因此 Action1 可以将 onNext(obj)和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调

介绍下使用
分别打包onNext(obj)、onError(error) 、onCompleted()。

    Observable observable = Observable.just("Hello", "World");
      //处理onNext()中的内容
      Action1<String> onNextAction = new Action1<String>() {
          @Override
          public void call(String s) {
              Log.i(TAG, s);
          }
      };
      //处理onError()中的内容
      Action1<Throwable> onErrorAction = new Action1<Throwable>() {
          @Override
          public void call(Throwable throwable) {

          }
      };
      //处理onCompleted()中的内容
      Action0 onCompletedAction = new Action0() {
          @Override
          public void call() {
              Log.i(TAG, "Completed");

          }
      };

//使用 onNextAction 来定义 onNext()
Observable.just("Hello", "World").subscribe(onNextAction);

//使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()
Observable.just("Hello", "World").subscribe(onNextAction, onErrorAction);

//使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()
Observable.just("Hello", "World").subscribe(onNextAction, onErrorAction, onCompletedAction);

那为什用Action也可以呢？我们来看看subscribe方法吧

    public final Subscription subscribe(final Action1<? super T> onNext) {
        if (onNext == null) {
            throw new IllegalArgumentException("onNext can not be null");
        }

        return subscribe(new Subscriber<T>() {

            @Override
            public final void onCompleted() {
                // do nothing
            }

            @Override
            public final void onError(Throwable e) {
                throw new OnErrorNotImplementedException(e);
            }

            @Override
            public final void onNext(T args) {
                onNext.call(args);
            }

        });
    }

可以看到首先参数允许，其次内部直接将其转换为subscribe

现在代码看上去简介多了吧！！！！！