从2015年10月份知道RxJava并使用过一次之后，因为工作忙的原因一直没有再去接触过这个让人无法抗拒的编程接口。经过几天的学习之后把学习的东西总结一下，毕竟才接触，若有不对的地方，请留言指正。
我的学习资料
1、Reactive ——强烈推荐，Rx官网
2、Awesome RxJava
创建操作
真可惜不支持锚点
这篇文章只是介绍操作符中的创建操作，其实创建操作包括了一些其他方面知识，比如调度器，我们会在后面的文章中讲解。
- Create
- Defer
- Empty/Never/Throw(不做介绍，很少用，一般用作测试)
- From
- Interval
- Just
- Range
- Repeat
- Timer
Create
使用一个函数从头开始创建一个Observable，并设置一个接受观察者函数作为参数，并让其恰当的调用观察者的onNext，onError，onCompeleted方法。
（ps：建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态，以便在没有观察者的时候，让其停止发射数据或者做昂贵的运算。）
public static void create() {
Observable.create(new OnSubscribe() { //这里泛型所指的参数既为发射数据的类型
@Override
public void call(Subscriber observer) {
try {
if (observer.isUnsubscribed()) { //
for (int i = 0; i < 3; i++) {
observer.onNext(i); //发射数据给观察者
}
}
observer.onCompleted(); //发射完毕
} catch (Exception e) {
observer.onError(e); //发射出错
}
}
}).subscribe(new Observer() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("onError :" + e.getMessage());
}
@Override
public void onNext(Integer t) {
System.out.println("onNext : " + t);
}
});
}
}
Defer
直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable。也就是说，只要有观察者订阅了它，就将其包含的数据全部发送给观察者。
在这里我先补充一点，观察者订阅有很多种形式存在，我们可以查看subscribe的API
public final Subscription subscribe(final Action1 onNext) {
...
return subscribe(new ActionSubscriber(onNext, onError, onCompleted));
}
public final Subscription subscribe(final Action1 onNext, final Action1 onError) {
...
return subscribe(new ActionSubscriber(onNext, onError, onCompleted));
}
public final Subscription subscribe(final Action1 onNext, final Action1 onError, final Action0 onCompleted) {
...
return subscribe(new ActionSubscriber(onNext, onError, onCompleted));
}
以上三种都是根据情况来设置相应参数，比如我只用处理发送过来的数据，其他的都不管，就可以使用第一个方法，以此类推。
public final Subscription subscribe(final Observer observer) {
if (observer instanceof Subscriber) {
return subscribe((Subscriber)observer);
}
if (observer == null) {
throw new NullPointerException("observer is null");
}
return subscribe(new ObserverSubscriber(observer));
}
public final Subscription subscribe(Subscriber subscriber) {
return Observable.subscribe(subscriber, this);
}
这二个种方法比较特殊。以上方法其实最后调用的都是
Observable.subscribe(subscriber, this)
总而言之就是将订阅者和被观察者绑定起来。
说了这么多，我们看下defer的用法：
public static void defer() {
Observable defer = Observable.defer(new Func0>() {
@Override
public Observable call() {
return Observable.just("1","2","3") ;
}
});
Action1 observer1 = new Action1() {
@Override
public void call(String t) {
System.out.println("observer1 onNext :" + t);
}
};
defer.subscribe(observer1);
Subscriber observer2 = new Subscriber() {
@Override
public void onStart() {
System.out.println("onStart");
}
@Override
public void onNext(String t) {
System.out.println("observer2 onNext :" + t);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onCompleted() {
System.out.println("observer2 onCompleted :");
}
};
defer.subscribe(observer2);
}
第一次使用的编辑功能，发现太多的MarkDown功能都不支持。
在这个例子中，使用了Action和Subscribe作为参数绑定被观察者，而且defer方法中返回的是一个Observable对象，刚好和我们之前讲的会为每个观察者创建一个新的Observable。这个Observable再将数据发射给观察者。
输出结果：
observer1 onNext :1
observer1 onNext :2
observer1 onNext :3
onStart
observer2 onNext :1
observer2 onNext :2
observer2 onNext :3
observer2 onCompleted
From
from操作可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或者数组的每一项数据。
将create操作符中的示例代码用from操作符写出来
public static void from() {
Integer[] ints = {1,2,3};
Observable.from(ints)
.subscribe(new Observer() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("onError :" + e.getMessage());
}
@Override
public void onNext(Integer t) {
System.out.println("onNext : " + t);
}
});
}
这种方法简单，但是不能判断出是否观察者取消了订阅，可能会造成浪费。
Interval
创建一个按固定时间间隔发射整数序列的Observable。
public static void interval() {
Observable.interval(1000,TimeUnit.MILLISECONDS,Schedulers.immediate())
.subscribe(new Action1() {
@Override
public void call(Long value) {
// TODO Auto-generated method stub
System.out.println("interval value : " + value);
}
});
}
Just
Just类似于From,但是From会将数组取出然后逐个发射，而Just只是简单的原样发射。
Observable.just("hello","world")
.observeOn(Schedulers.immediate())
.subscribe(new Action1() {
@Override
public void call(String t) {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName());
System.out.println(t);
}
});
Range
发射一个范围类有序的整数序列，你可以指定范围的起始和长度
Observable.range(0, 10)
.subscribe(new Action1() {
@Override
public void call(Integer t) {
// TODO Auto-generated method stub
System.out.println(t);
}
});
Repeat
Observable.just("1","2")
.repeat(3)
.subscribe(new Observer() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
System.out.println("error : "+e.getMessage());
}
@Override
public void onNext(String t) {
System.out.println(t + " " + Thread.currentThread().getName());
}
});
Timer
创建一个Observable，它在一个给定的延迟会发射一个特殊的值（0）
Observable.timer(5, TimeUnit.SECONDS)
.subscribe(new Action1() {
@Override
public void call(Long t) {
System.out.println("hello world!");
}
});