Android从零开搞系列：网络框架系列（4）Retrofit+RxJava+MVP（中-上）RxJava篇（上）

转载请注意：http://blog.csdn.net/wjzj000/article/details/54312035

本菜开源的一个自己写的Demo，希望能给Androider们有所帮助，水平有限，见谅见谅…

https://github.com/zhiaixinyang/PersonalCollect （拆解GitHub上的优秀框架于一体，全部拆离不含任何额外的库导入）

https://github.com/zhiaixinyang/MyFirstApp（Retrofit+RxJava+MVP）

写在前面

这一篇的内容是关于RxJava。

主要内容将围绕我自己带队RxJava的理解进行记录。

此篇博客并未按正常的顺序进行记录。而是按照我学习过程中出现的问题来进行总结。所以，如果感觉不适…那就多看几遍习惯习惯。

开始

关于使用，我们都只知道要在Gradle中进行依赖：

compile 'io.reactivex:rxjava:1.1.0'
compile 'io.reactivex:rxandroid:1.1.0'

RxJava和RxAndroid有什么区别和联系，让我们看一下它们二者的源码结构图：

RxAndroid：



RxJava



通过结构的复杂程度，我们就能要看出端倪，RxAndroid是适配拓展RxJava的。

诚如官方解释的那样：

为Android特定的绑定RxJava。此模块将最小的类添加到RxJava，使得在Android应用程序中编写反应性组件（reactive components）容易和无忧。更具体地，它提供了一个Scheduler主线程或任何给定的上日程Looper。

说白了就是设配android，并且拓展更多的功能，以适应android开发。一个最直接的拓展，我们在线程转换的时候会这样用：

.observeOn(AndroidSchedulers.mainThread())

很明显这就是RxAndroid中的。

我相信能够去搜索RxJava，获得或少都会对RxJava有所了解。不少前辈们的博客都会在最开始的时候，提到：如果把RxJava压缩成一个词，那么就是异步。

所以我最开始的时候有过这样的疑问：既然是异步，有很多方案可以替代啊，为什么一定要用它？？

哪有这么多为什么，叭叭的。大神们说好用那就用…

最简单的用法

最开始的时候先写一个Demo，先梳理一下这个过程以及观察者模式。

Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("我作为被观察者，我想告诉你一件事：mdzz");
}}).subscribe(new Observer<String>() {
@Override
public void onCompleted() {
//当不会再有新的 onNext() 发出时，此方法回调
/**
* 官方的解释：
* 通知观察者{@link Observable}已完成发送基于推送的通知。
* 如果{@link #onError}调用{@link Observable}，则不会调用此方法。
*/
//（并没找到触发回调的时机...）
}
@Override
public void onError(Throwable e) {
//此处是错误时的回调
}
@Override
public void onNext(String s) {
tvContent1.setText("观察者收到："+s);
}
});

效果（很简单，就是一行字）：

变种

这是很常规的写法，随意显的有些啰嗦。看了一些开源项目后，发现好多作者都喜欢直接这么写：

.subscribe(new Action1<String>() {
@Override
public void call(String s) {
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
}
});

我们可以看到上文中的new Observer的过程被替换成了Action1，并且这里显然剔除了onCompleted()的回调。Ok，这是用法的变种…当然这些统统不重要，重要的还是梳理这个过程！

梳理

我在学习的过程之中感受最大的就是，对概念的不清晰导致了自己在看博客的时候感觉很混乱。

尤其是观察者、被观察者、被订阅者、订阅者、订阅等一系列概念给搞的鞭长莫及…

这里我们进行简单的对应一下，被观察者和被订阅者是同一个概念。观察者和订阅者是用一个概念。

不同的是它们的命名导致了它们翻译的不同，但是本质都是继承了同一个类。

订阅这个概念就可以理解成绑定，二者形成（订阅/观察）关系。

开始之前让我们先明确一些类的含义：

Observer:

public interface Observer<T>

很明显是一个接口，它就是我们作为观察者模式中的观察者。实现这个接口的类都可以理解成观察者，而观察者的作用就是去观察一个东西的状态，如果这个东西状态发生变化，那么自己就进行相关方法的调用。

与之类似的还有：（这就是订阅者）

Subscriber:

public abstract class Subscriber<T> implements Observer<T>, Subscription

很明显实现了Observer接口，那么必然是另一种形式的观察者。

让我们翻译一下这个词：订购者，订阅用户。其实观察者模式又叫订阅者模式的原因就是出于此。

订阅者（Subscriber）还实现了Subcription接口，让我们看一看它。

PS:这里提到了订阅以及观察模式的概念，这里先放一放。等我们梳理完这些类都是什么意思的时候，我们在把视线的聚焦点提到设计模式上来。

Subscription:

public interface Subscription

它仅仅是一个接口。官方给出了如下的解释：

Subscription从{@link Observable＃subscribe（Subscriber）}返回，以允许取消订阅。

比较难理解，我们看一下它内部的方法就明白了，其实就是一个拓展，方便与取消订阅这个过程。

public interface Subscription {
void unsubscribe();
boolean isUnsubscribed();

}

Observable:

public class Observable<T>

这就是我们常说的被观察者，也就是观察者观察的对象。

OnSubscribe:

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>>

它是Obserable中的一个内部接口，它的内部什么都没有，所以我们需要看一看Action1

/**
* Invoked when Observable.subscribe is called.
*/
public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
// cover for generics insanity
}

Action1:

public interface Action1<T> extends Action {
void call(T t);
}

它并没有直接或间接的继承或实现Observer相关的类或者接口。

是不是很熟悉？我们在上述变种中这么写：

.subscribe(new Action1<String>() {
@Override
public void call(String s) {
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
}
});

可是为什么它没有直接和Observer发生关系…怎么可以传入subscribe中呢？

关于这个问题下篇博客有详细的说明。

简单解释一下：原因是，subscribe在这里是俩个不同的重载方法。Action1借助了另一个类完成了订阅这个过程。

收尾

OK，概念性的东西，我们就梳理到这。接下来是我们的重头。设计模式！

由于章节有点长，所以在这里拆分成俩个部分，下半部分在：

http://blog.csdn.net/wjzj000/article/details/54314319

最后希望各位看官可以star我的GitHub，三叩九拜，满地打滚求star：

https://github.com/zhiaixinyang/PersonalCollect

https://github.com/zhiaixinyang/MyFirstApp