RxJava算是最新最常用的，也是程序员们最喜欢的框架之一了。
RxJava的核心由Observable（被观察者，事件源）和Subscriber（观察者）构成，Observable负责发出一系列事件，Subscriber处理这些事件。
一个Observble可以发出零个或多个事件，直到结束或出错。每发出一个事件，就会调用与之关联的所有观察者Subscriber的onNext()方法；如果中途出错，则会回调这个观察者的onError()方法；事件发布给所有观察者之后，会回调最后一个观察者的onCompleted()方法。
RxJava很像设计模式中的观察者模式，但有一点不同，就是当一个被观察者没有任何与之关联的观察者时，这个被观察者不会发出任何事件。
在Android中使用RxJava，需要先导入RxJava和RxAndroid的依赖：
compile 'io.reactivex:rxjava:1.2.2'
compile 'io.reactivex:rxandroid:1.2.1'
DEMO 1：
Observable<String> observabele = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello RxJava");
subscriber.onCompleted();
}
});
Observer<String> observer = new Observer<String>() {
@Override
public void onCompleted() {
System.out.println("-------------------->>>>Completed");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
System.out.println("------------onNext---------->>>>>>>" + s);
}
};
observabele.subscribe(observer);
通过Observable的create()方法创建一个自定义的Observable被观察者，在参数传入的OnSubscribe内部类中通过调用子方法的Subscriber对象参数的onNext()、onError()、onCompleted()三个方法，操作与这个被观察者绑定的所有观察者。
通过new Observer()方法来创建一个观察者，需要实现onNext()、onError()、onCompleted()三个方法。
通过Observeable对象的subscribe()方法绑定一个观察者，此时这个观察者就可以接收到被观察者发送的消息了。
DEMO2：
Observable<String> observable = Observable.just("Hello RxJava", "My", "Name");
Action1<String> next = new Action1<String>() {
@Override
public void call(String s) {
// onNext()中执行的代码
}
};
Action1<Throwable> error = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
// onError()中执行的代码
}
};
Action0 completed = new Action0() {
@Override
public void call() {
// onCompleted()中执行的代码
}
};
observable.subscribe(next, error, completed);
Subscriber中的三个子方法可以拆分成两个Action1和一个Action0。onNext()和onError()两个方法对应的Action1，onCompleted()方法对应的是Action0。
Observable对象的subscribe()方法可以传入三个Action对象，即表示被观察者已经绑定了一个观察者，这个观察者是由这三个Action组成的。subscribe()方法有多个重载，可以只有一个onNext()方法的Action1，可以有一个onNext()方法的Action1和一个onError()方法的Action1，也可以像上面代码一样有三个Action。
Observable对象的just()方法可以有任意个参数，表示将这些对象逐个通过onNext()方法发送出去。
DEMO3：
String[] array = {"Hello RxJava", "My", "Name"};
Observable<String> observable = Observable.from(array);
Action1<String> next = new Action1<String>() {
@Override
public void call(String s) {
// onNext()中执行的代码
System.out.println("----------------------->>>>>>>>>>" + s);
}
};
Action1<Throwable> error = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
// onError()中执行的代码
}
};
Action0 completed = new Action0() {
@Override
public void call() {
// onCompleted()中执行的代码
}
};
observable.subscribe(next, error, completed);
Observable.from()方法和Observable.just()方法的效果是一样的，都是将一组数据逐个发送出去，区别是from()方法是将一个数组中的数据逐个发送，而just()方法是将各个参数中的数据进行逐个发送。
DEMO4：
Observable<String> observable = Observable
.just("Hello RxJava", "aaaa", "bbbbb", "aaaaaacccc")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return "string=========" + s;
}
}); Action1<String> next = new Action1<String>() {
@Override
public void call(String s) {
// onNext()中执行的代码
System.out.println("----------------------->>>>>>>>>>" + s);
}
}; Action1<Throwable> error = new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
// onError()中执行的代码
}
}; Action0 completed = new Action0() {
@Override
public void call() {
// onCompleted()中执行的代码
}
}; observable.subscribe(next, error, completed);
map方法是将just中的数据进行进一步的处理，例如，上面的代码中就是在每个字符串前面加了另一端字符串。
DEMO5：
Observable.just("https://api.github.com/users/basil2style")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
StringBuffer result = null;
try {
URL url = new URL(s);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setDoInput(true);
connection.connect();
int responseCode = connection.getResponseCode();
if (responseCode == 200) {
result = new StringBuffer();
BufferedInputStream bis = new BufferedInputStream(connection.getInputStream());
byte[] b = new byte[1024];
int len = -1;
while ((len = bis.read(b)) != -1) {
result.append(new String(b, 0, len));
}
bis.close();
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("------------------->>>>>" + result.toString());
return result.toString();
}
})
.map(new Func1<String, InfoData>() {
@Override
public InfoData call(String s) {
InfoData infoData = new InfoData();
try {
JSONObject object = new JSONObject(s);
infoData.setId(object.getInt("id"));
infoData.setUrl(object.getString("url"));
infoData.setType(object.getString("type"));
infoData.setName(object.getString("name"));
} catch (JSONException e) {
e.printStackTrace();
}
return infoData;
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<InfoData>() {
@Override
public void onCompleted() {
System.out.println("---------------------->>>>>>Completed");
}
@Override
public void onError(Throwable e) {
Toast.makeText(MainActivity.this, "获取网络数据失败", Toast.LENGTH_SHORT).show();
}
@Override
public void onNext(InfoData infoData) {
Toast.makeText(MainActivity.this, infoData.getName(), Toast.LENGTH_SHORT).show();
}
});
这是用RxJava结合原生的JAVA API完成网络访问的代码，通过map()方法在不同的参数之间进行转换，最终得到InfoData对象并输出数据。
现在，开发人员更喜欢将RxJava和Retrofit结合使用，原因是RxJava可以设置一段代码执行的线程，这样就可以轻松的、解耦的替换Handler和AsyncTask进行异步数据的访问。
有关RxJava和Retrofit结合使用的案例我会写在我的下一个帖子中，敬请期待~~