一.基本概念
1.RxJava 简介
a library for composing asynchronous and event-based programs using observable sequences for the Java VM.一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。类似于 Android中的 AsyncTask 、Handler的作用。
这就是RxJava ，概括一个词就是：异步。
2.RxJava 优点
异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 Android 创造的AsyncTask和Handler ，其实都是为了让异步代码更加简洁。
RxJava 的优势也是简洁，但它的优势在于随着程序逻辑变得越来越复杂，它依然能够保持简洁。
3.RxJava原理
RxJava的异步实现，是通过一种扩展的观察者模式来实现的。
4.观察者模式详解
观察者模式面向的需求是：A 对象（观察者）对 B 对象（被观察者）的某种变化高度敏感，需要在B变化的一瞬间做出反应。举个例子，警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者，小偷是被观察者，警察需要时刻盯着小偷的举动变化，才能保证不会漏过任何瞬间。
程序的观察者模式和这种真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如A不需要每过2ms就检查一次B的状态），而是采用注册(Register)或者称为订阅(Subscribe)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。
Rxjava的扩展观察者模式中有4个角色：
<1> Observable 被观察者
<2> Observer 观察者
<3> subscribe 订阅
<4> Event 事件
Observable和Observer通过subscribe() 方法实现订阅关系，从而Observable可以在需要的时候发出事件来通知 Observer。
与传统观察者模式不同，RxJava的事件回调方法除了普通事件onNext() （相当于 onClick() / onEvent()）之外，还定义了两个特殊的事件：onCompleted() 和 onError()。
(1) onCompleted() 1.XX版本
事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
(2) onError()
事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
RxJava 的观察者模式大致如下图：
5.RxJava GitHub地址
https://github.com/ReactiveX/RxJava
6.RxAndroid GitHub地址
https://github.com/ReactiveX/RxAndroid/
二.基本使用 基于1.X版本
1.Gradle依赖 RxJava&RxAndroid 版本须一致 即都是1.x版本
//RxJava
implementation 'io.reactivex:rxjava:1.3.2'
//RxAndroid
implementation 'io.reactivex:rxandroid:1.2.1'
2.代码
package com.example.rxjava10demo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.rxjava10demo.R;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.Subscription;
public class RxJavaActivity extends AppCompatActivity {
private Observer mObserver = null;//观察者对象
private Observable mObservable = null;//被观察者对象
private Subscription mSubscription = null;//订阅后的对象 可取消订阅
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != mObserver && null != mObservable) {
mSubscription = mObservable.subscribe(mObserver);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
mObserver = new Observer<String>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者对象 onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者对象 onError方法执行！！！");
}
@Override
public void onNext(String s) {
Log.d("TAG", "观察者对象 onNext方法执行！！！结果：" + s);
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
mObservable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (null == subscriber) {
return;
}
final Subscriber mSubscriber = subscriber;
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者对象 发出第一波数据......");
subscriber.onNext("被观察者对象 发出第二波数据......");
subscriber.onNext("被观察者对象 发出第三波数据......");
subscriber.onCompleted();
}
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != mSubscription) {
if (mSubscription.isUnsubscribed()) {//订阅中
mSubscription.unsubscribe();//取消订阅
Log.d("TAG", "onDestroy方法 取消订阅");
}
}
}
}
3.结果
D/TAG: 观察者对象 onNext方法执行！！！结果：被观察者对象 发出第一波数据......
D/TAG: 观察者对象 onNext方法执行！！！结果：被观察者对象 发出第二波数据......
D/TAG: 观察者对象 onNext方法执行！！！结果：被观察者对象 发出第三波数据......
D/TAG: 观察者对象 onCompleted方法执行！！！
4.关闭页面
D/TAG: onDestroy方法 取消订阅
5.说明
<1> 观察者和被观察者发生订阅关系后。观察者才可收到被观察者发送的消息。
<2> 观察者模式，在适当的时候需要取消订阅。这样可以避免内存泄漏。具体做法。
1.X版本的RxJava发生订阅后会生成Subscription对象。可用此对象取消订阅。如上
订阅生成Subscription对象
if (null != mObserver && null != mObservable) {
mSubscription = mObservable.subscribe(mObserver);//完成订阅
}
取消订阅
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != mSubscription) {
if (mSubscription.isUnsubscribed()) {//订阅中
mSubscription.unsubscribe();//取消订阅
Log.d("TAG", "onDestroy方法 取消订阅");
}
}
}
<3> 如果 一个页面有多个订阅关系呢
代码
package com.example.rxjava10demo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.rxjava10demo.R;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
import rx.Subscription;
import rx.subscriptions.CompositeSubscription;
public class RxJavaActivity extends AppCompatActivity {
private Observer mObserver1 = null;//观察者对象1
private Observable mObservable1 = null;//被观察者对象1
private Observer mObserver2 = null;//观察者对象2
private Observable mObservable2 = null;//被观察者对象2
private Subscription mSubscription1 = null;//订阅后的对象1 可取消订阅
private Subscription mSubscription2 = null;//订阅后的对象2 可取消订阅
private CompositeSubscription mCompositeSubscription;//管理Subscription 统一取消订阅
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod1();//创建观察者对象1
createObservableMethod1();//创建被观察者对象1
if (null != mObserver1 && null != mObservable1) {
mSubscription1 = mObservable1.subscribe(mObserver1);//完成订阅
}
createObserverMethod2();//创建观察者对象2
createObservableMethod2();//创建被观察者对象2
if (null != mObserver2 && null != mObservable2) {
mSubscription2 = mObservable2.subscribe(mObserver2);//完成订阅
}
mCompositeSubscription = new CompositeSubscription();
mCompositeSubscription.add(mSubscription1);
mCompositeSubscription.add(mSubscription2);
}
/**
* 创建 观察者对象1
*/
public void createObserverMethod1() {
mObserver1 = new Observer<String>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者对象1 onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者对象1 onError方法执行！！！");
}
@Override
public void onNext(String s) {
Log.d("TAG", "观察者对象1 onNext方法执行！！！结果：" + s);
}
};
}
/**
* 创建 被观察者对象1
*/
public void createObservableMethod1() {
mObservable1 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (null == subscriber) {
return;
}
final Subscriber mSubscriber = subscriber;
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者对象1 发出第一波数据......");
subscriber.onNext("被观察者对象1 发出第二波数据......");
subscriber.onNext("被观察者对象1 发出第三波数据......");
subscriber.onCompleted();
}
}
});
}
/**
* 创建 观察者对象2
*/
public void createObserverMethod2() {
mObserver2 = new Observer<String>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者对象2 onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者对象2 onError方法执行！！！");
}
@Override
public void onNext(String s) {
Log.d("TAG", "观察者对象2 onNext方法执行！！！结果：" + s);
}
};
}
/**
* 创建 被观察者对象2
*/
public void createObservableMethod2() {
mObservable2 = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (null == subscriber) {
return;
}
final Subscriber mSubscriber = subscriber;
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者对象2 发出第1波数据......");
subscriber.onNext("被观察者对象2 发出第2波数据......");
subscriber.onNext("被观察者对象2 发出第3波数据......");
subscriber.onCompleted();
}
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != mCompositeSubscription) {
mCompositeSubscription.unsubscribe();
Log.d("TAG", "onDestroy方法 取消订阅");
}
}
}
结果
D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第一波数据......
D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第二波数据......
D/TAG: 观察者对象1 onNext方法执行！！！结果：被观察者对象1 发出第三波数据......
D/TAG: 观察者对象1 onCompleted方法执行！！！
D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第1波数据......
D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第2波数据......
D/TAG: 观察者对象2 onNext方法执行！！！结果：被观察者对象2 发出第3波数据......
D/TAG: 观察者对象2 onCompleted方法执行！！！
关闭页面
D/TAG: onDestroy方法 取消订阅
也就是说 1.X版本的RxJava。当有多个订阅关系时，可以使用CompositeSubscription对象统一管理Subscription对象。然后统一取消订阅。
6.单个订阅关系&多个订阅关系取消订阅源码
首先看Subscription。Subscription是一个接口 源码
public interface Subscription {
/**
* Stops the receipt of notifications on the {@link Subscriber} that was registered when this Subscription
* was received.
* <p>
* This allows deregistering an {@link Subscriber} before it has finished receiving all events (i.e. before
* onCompleted is called).
*/
void unsubscribe();
/**
* Indicates whether this {@code Subscription} is currently unsubscribed.
*
* @return {@code true} if this {@code Subscription} is currently unsubscribed, {@code false} otherwise
*/
boolean isUnsubscribed();
}可见，Subscription接口有两个方法，取消订阅方法和是否取消订阅方法。
再看统一管理每个订阅关系的类CompositeSubscription类
public final class CompositeSubscription implements Subscription {
...
}由此可见，CompositeSubscription类实现了Subscription接口。那么具体的添加订阅关系和取消订阅关系是怎么做的呢
添加订阅关系 即 添加Subscription对象到CompositeSubscription对象
mCompositeSubscription.add(mSubscription1);
mCompositeSubscription.add(mSubscription2);add方法源码
public void add(final Subscription s) {
if (s.isUnsubscribed()) {
return;
}
if (!unsubscribed) {
synchronized (this) {
if (!unsubscribed) {
if (subscriptions == null) {
subscriptions = new HashSet<Subscription>(4);
}
subscriptions.add(s);
return;
}
}
}
// call after leaving the synchronized block so we're not holding a lock while executing this
s.unsubscribe();
}分析：
<1> 如果要放入的单个Subscription对象已经取消了订阅，则直接返回。即此种情况没必要添加。
<2> <1>不满足。即要放入的单个Subscription对象没有被取消订阅。继续。
<3>
private volatile boolean unsubscribed;
@Override
public boolean isUnsubscribed() {
return unsubscribed;
}如果没有调用过CompositeSubscription对象的取消订阅的话，unsubscribed字段就是默认false。代码继续执行。
<4> 同步方法中声明了一个长度为4的HashSet集合。
private Set<Subscription> subscriptions;
subscriptions = new HashSet<Subscription>(4);
取消订阅关系
if (null != mCompositeSubscription) {
mCompositeSubscription.unsubscribe();
}unsubscribe方法源码
@Override
public void unsubscribe() {
if (!unsubscribed) {
Collection<Subscription> unsubscribe;
synchronized (this) {
if (unsubscribed) {
return;
}
unsubscribed = true;
unsubscribe = subscriptions;
subscriptions = null;
}
// we will only get here once
unsubscribeFromAll(unsubscribe);
}
}同样，如果没有取消过订阅关系。在同步方法中获取刚刚的HashSet集合subscriptions。然后调用unsubscribeFromAll(unsubscribe);方法
unsubscribeFromAll(unsubscribe)方法源码
private static void unsubscribeFromAll(Collection<Subscription> subscriptions) {
if (subscriptions == null) {
return;
}
List<Throwable> es = null;
for (Subscription s : subscriptions) {
try {
s.unsubscribe();
} catch (Throwable e) {
if (es == null) {
es = new ArrayList<Throwable>();
}
es.add(e);
}
}
Exceptions.throwIfAny(es);
}即此方法的核心(忽略catch代码块)就是 遍历HashSet集合subscriptions中存放的单个Subscription对象。然后调用单个Subscription对象的取消订阅的方法。
总结：CompositeSubscription对象统一管理Subscription对象。大概的原理就是先将Subscription对象存放在CompositeSubscription对象的Set集合中。统一取消订阅时。再遍历CompositeSubscription对象的Set集合。然后统一取消订阅。
三.观察者的其他实现方式
上述三处代码创建观察者时都是采用的Observer接口，下面讲解采用Subscriber抽象类创建观察者。
1. Observer接口
public interface Observer<T> {}
2. Subscriber抽象类
public abstract class Subscriber<T> implements Observer<T>, Subscription {}
由源码可知Subscriber抽象类实现了Observer接口。
3.代码
package com.example.rxjava10demo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.rxjava10demo.R;
import rx.Observable;
import rx.Subscriber;
import rx.Subscription;
public class RxJavaActivity extends AppCompatActivity {
private Subscriber mSubscriber = null;
private Observable mObservable = null;
private Subscription mSubscription = null;//订阅后的对象 可取消订阅
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != mSubscriber && null != mObservable) {
mSubscription = mObservable.subscribe(mSubscriber);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
mSubscriber = new Subscriber() {
@Override
public void onStart() {
super.onStart();
Log.d("TAG", "观察者 onStart方法执行！！！");
}
@Override
public void onCompleted() {
Log.d("TAG", "观察者 onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者 onError方法执行！！！");
}
@Override
public void onNext(Object o) {
Log.d("TAG", "观察者 onNext方法执行！！！结果：" + o.toString());
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
mObservable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (null == subscriber) {
return;
}
final Subscriber mSubscriber = subscriber;
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者 发出第1波数据......");
subscriber.onNext("被观察者 发出第2波数据......");
subscriber.onNext("被观察者 发出第3波数据......");
subscriber.onCompleted();
}
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != mSubscription) {
if (mSubscription.isUnsubscribed()) {
mSubscription.unsubscribe();
Log.d("TAG", "onDestroy方法 取消订阅");
}
}
}
}
4.结果
D/TAG: 观察者 onStart方法执行！！！
D/TAG: 观察者 onNext方法执行！！！结果：被观察者 发出第1波数据......
D/TAG: 观察者 onNext方法执行！！！结果：被观察者 发出第2波数据......
D/TAG: 观察者 onNext方法执行！！！结果：被观察者 发出第3波数据......
D/TAG: 观察者 onCompleted方法执行！！！
5.关闭页面
D/TAG: onDestroy方法 取消订阅
6.总结
由代码可知 Subscriber抽象类方式创建观察者重写的三个方法和Observer接口方式是完全一致的。那么两者就没有一点区别吗？其实是有的。
<1> Subscriber抽象类方式创建观察者 多了onStart方法。在还未响应事件前调用，用于做一些初始化工作。
四.观察者和被观察者的订阅方法的几个重载方法使用
上述观察者和被观察者发生订阅关系时 代码如下
if (null != mSubscriber && null != mObservable) {
mSubscription = mObservable.subscribe(mSubscriber);//完成订阅
}即。订阅关系调用的subscribe方法。
其实subscribe方法有好几个重载的方法。满足不同的需求。
1.传入Subscriber观察者对象 Subscriber抽象类方式创建观察者。
public final Subscription subscribe(Subscriber<? super T> subscriber) {
return Observable.subscribe(subscriber, this);
}
2.传入Observer观察者对象 Observer接口方式创建观察者。
public final Subscription subscribe(final Observer<? super T> observer) {
if (observer instanceof Subscriber) {
return subscribe((Subscriber<? super T>)observer);
}
if (observer == null) {
throw new NullPointerException("observer is null");
}
return subscribe(new ObserverSubscriber<T>(observer));
}以上两个都是在观察者和被观察者分开创建时最常用的两个订阅的方法。
3.传入Action1 onNext 对象 即观察者只监听onNext方法。
public final Subscription subscribe(final Action1<? super T> onNext) {
if (onNext == null) {
throw new IllegalArgumentException("onNext can not be null");
}
Action1<Throwable> onError = InternalObservableUtils.ERROR_NOT_IMPLEMENTED;
Action0 onCompleted = Actions.empty();
return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
}
4.传入Action1 onNext 对象+Action1 onError对象 即观察者监听onNext方法和onError方法。
public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError) {
if (onNext == null) {
throw new IllegalArgumentException("onNext can not be null");
}
if (onError == null) {
throw new IllegalArgumentException("onError can not be null");
}
Action0 onCompleted = Actions.empty();
return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
}
5.传入Action1 onNext 对象+Action1 onError对象+Action0 onCompleted对象 即观察者监听onNext方法和onError方法和onComplete方法。相当于Observer接口或者Subscriber抽象类创建观察者。
public final Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onCompleted) {
if (onNext == null) {
throw new IllegalArgumentException("onNext can not be null");
}
if (onError == null) {
throw new IllegalArgumentException("onError can not be null");
}
if (onCompleted == null) {
throw new IllegalArgumentException("onComplete can not be null");
}
return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
}
3+4+5重载方法举例
代码
package com.example.rxjava10demo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.rxjava10demo.R;
import rx.Observable;
import rx.Subscriber;
import rx.Subscription;
import rx.functions.Action0;
import rx.functions.Action1;
public class RxJavaActivity extends AppCompatActivity {
private Action1 mNextAction = null;
private Action0 mCompleteAction = null;
private Action1<Throwable> mErrorAction = null;
private Observable mObservable = null;
private Subscription mSubscription = null;//订阅后的对象 可取消订阅
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != mNextAction && null != mErrorAction && null != mObservable) {
mSubscription = mObservable.subscribe(mNextAction, mErrorAction, mCompleteAction);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
mNextAction = new Action1() {
@Override
public void call(Object o) {
if (null == o) {
return;
}
Log.d("TAG", "观察者 onNext方法执行 结果：" + o.toString());
}
};
mCompleteAction = new Action0() {
@Override
public void call() {
Log.d("TAG", "观察者 onCompleted执行");
}
};
mErrorAction = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
if (null == throwable) {
return;
}
Log.d("TAG", "观察者 onError方法执行 结果：" + throwable.toString());
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
mObservable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
if (null == subscriber) {
return;
}
final Subscriber mSubscriber = subscriber;
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者 发出第1波数据......");
subscriber.onNext("被观察者 发出第2波数据......");
subscriber.onNext("被观察者 发出第3波数据......");
subscriber.onCompleted();
}
}
});
}
/**
* onDestroy方法
*/
@Override
protected void onDestroy() {
super.onDestroy();
if (null != mSubscription) {
if (mSubscription.isUnsubscribed()) {
mSubscription.unsubscribe();
Log.d("TAG", "onDestroy方法 取消订阅");
}
}
}
}
结果
D/TAG: 观察者 onNext方法执行 结果：被观察者 发出第1波数据......
D/TAG: 观察者 onNext方法执行 结果：被观察者 发出第2波数据......
D/TAG: 观察者 onNext方法执行 结果：被观察者 发出第3波数据......
D/TAG: 观察者 onCompleted执行
说明
<1> 使用 Action1 onNext 对象+Action1 onError对象+Action0 onCompleted对象。也可以创建观察者且接收数据。效果和使用Observer接口方式创建观察者或者Subscriber抽象类方式创建观察者一样。
<2> onNext对象、onError对象、onComplete对象也可以单独使用，比如只使用onNext方法接收被观察者发送的消息(上述3)。比如使用onNext方法和onError方法接收被观察者发送的消息(上述4)。
<3> RxJava 1.x 提供了多个函数式接口 ，用于实现简便式的观察者模式。比如 上面用的Action1、Action0 等等 具体如下图
五.创建被观察者的其他操作符
创建 Observable(被观察者对象) 不同的方法也叫操作符。
1.Create方法
原始的创建操作符。使用一个函数从头开始创建一个Observable
注意点
<1> 建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态，以便在没有观察者的时候，让你的Observable停止发射数据或者做昂贵的运算。
<2> onError与onCompleted只能回调其中一个方法。
代码
如上
结果
如上
2.Just方法
创建一个发射指定值的Observable，just将单个数据转换为发射那个数据的Observable。
注意点
如果你传递null给Just，它会返回一个发射null值的Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），如果需要空Observable你应该使用Empty操作符。RxJava将这个操作符实现为just函数，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。
代码
package com.example.mydemo.rxjava;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import com.example.mydemo.R;
import rx.Observable;
import rx.Observer;
import rx.Subscriber;
public class RxJavaActivity extends AppCompatActivity {
private Observer observer = null;
private Observable observable = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != observer && null != observable) {
observable.subscribe(observer);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
observer = new Observer<Object>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者onError方法执行！！！");
}
@Override
public void onNext(Object s) {
Log.d("TAG", "观察者onNext方法执行！！！结果：" + s.toString());
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
observable = Observable.just(1, 2, 3);
}
}
结果
D/TAG: 观察者onNext方法执行！！！结果：1
D/TAG: 观察者onNext方法执行！！！结果：2
D/TAG: 观察者onNext方法执行！！！结果：3
D/TAG: 观察者onCompleted方法执行！！！
3.From方法
将其它种类的对象和数据类型转换为Observable，当你使用Observable时，如果你要处理的数据都可以转换成展现为Observables，而不是需要混合使用Observables和其它类型的数据，会非常方便。这让你在数据流的整个生命周期中，可以使用一组统一的操作符来管理它们。
代码
package com.example.mydemo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.mydemo.R;
import rx.Observable;
import rx.Observer;
public class RxJavaActivity extends AppCompatActivity {
private Observer observer = null;
private Observable observable = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != observer && null != observable) {
observable.subscribe(observer);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
observer = new Observer<Object>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者onError方法执行！！！");
}
@Override
public void onNext(Object s) {
Log.d("TAG", "观察者onNext方法执行！！！结果：" + s.toString());
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
Integer[] items = {0, 1, 2, 3, 4, 5};
observable = Observable.from(items);
}
}
结果
D/TAG: 观察者onNext方法执行！！！结果：0
D/TAG: 观察者onNext方法执行！！！结果：1
D/TAG: 观察者onNext方法执行！！！结果：2
D/TAG: 观察者onNext方法执行！！！结果：3
D/TAG: 观察者onNext方法执行！！！结果：4
D/TAG: 观察者onNext方法执行！！！结果：5
D/TAG: 观察者onCompleted方法执行！！！
4. Empty方法
创建一个不发射任何数据但是正常终止的Observable。
代码
package com.example.rxjava10demo.rxjava;
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.example.rxjava10demo.R;
import rx.Observable;
import rx.Observer;
public class RxJavaActivity extends AppCompatActivity {
private Observer observer = null;
private Observable observable = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_rxjava);
createObserverMethod();//创建观察者对象
createObservableMethod();//创建被观察者对象
if (null != observer && null != observable) {
observable.subscribe(observer);//完成订阅
}
}
/**
* 创建 观察者对象
*/
public void createObserverMethod() {
observer = new Observer<Object>() {
@Override
public void onCompleted() {
Log.d("TAG", "观察者onCompleted方法执行！！！");
}
@Override
public void onError(Throwable e) {
Log.d("TAG", "观察者onError方法执行！！！");
}
@Override
public void onNext(Object s) {
Log.d("TAG", "观察者onNext方法执行！！！结果：" + s.toString());
}
};
}
/**
* 创建 被观察者对象
*/
public void createObservableMethod() {
observable = Observable.empty();
}
}
结果
D/TAG: 观察者onCompleted方法执行！！！
即，empty方法，发送了一个空的被观察者。观察者只会收到一次onCompleted方法。然后正常关闭。
更多方法
5.Defer：Defer操作符会一直等待直到有观察者订阅它，并且为每个观察者创建一个新的Observable
注意点：Defer操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。在某些情况下，等待直到最后一分钟（就是知道订阅发生时）才生成Observable可以确保Observable包含最新的数据。
6.Nerver：创建一个不发射数据也不终止的Observable
7.Throw：创建一个不发射数据以一个错误终止的Observable
8.Interval：创建一个按固定时间间隔发射整数序列的Observable
注意点：Interval操作符返回一个Observable，它按固定的时间间隔发射一个无限递增的整数序列。
9.Range：创建一个发射特定整数序列的Observable，Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。
10.Repeat：创建一个发射特定数据重复多次的Observable,Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数。RxJava将这个操作符实现为repeat方法。它不是创建一个Observable，而是重复发射原始Observable的数据序列，这个序列或者是无限的，或者通过repeat(n)指定重复次数。
11.Timer：创建一个Observable，它在一个给定的延迟后发射一个值。
Timer 已经过时了，而是由interval操作符来间隔执行，推荐使用interval。
六.总结
1.X版本的RxJava使用总结
<1> 创建观察者可使用Observer接口，也可使用Subscriber抽象类。两者用法大体一致。详解上看。
<2> 创建被观察者可以使用很多的操作符，不只局限于create，just，from，empty，四种操作符。详解上看。
<3> 使用观察者模式时，需要注意取消订阅，防止内存泄漏。详解上看。
<4> 由于观察者可以取消订阅，所以被观察者发送数据时，一定要判断是否取消订阅。详解上看
//没有取消订阅的时候
if (!mSubscriber.isUnsubscribed()) {
subscriber.onNext("被观察者 发出第1波数据......");
subscriber.onNext("被观察者 发出第2波数据......");
subscriber.onNext("被观察者 发出第3波数据......");
subscriber.onCompleted();
}
<5> 观察者和被观察者发生订阅关系有几个重载方法。使用某一个重载的方法可以单独使用 onNext对象。也可以onNext对象+onComplete对象+onError对象结合使用。相当于使用Observer接口，或者使用Subscriber抽象类创建观察者 详解上看。
1706
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
