RxJava简单入门

最新推荐文章于 2024-06-29 16:34:22 发布

原创最新推荐文章于 2024-06-29 16:34:22 发布 · 249 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#对象 #RxJava

android 同时被 2 个专栏收录

9 篇文章

订阅专栏

RxJava

1 篇文章

订阅专栏

RxJava简单介绍

前言

RxJava其实是一种观察者模式，而观察者模式，就必定存在事件源、事件的观察者。而观察者跟事件源也存在着一种订阅的关系，只有事件源被观察者所订阅，观察者才能接收到事件源发生的变化，观察者不用时刻的关注事件源，只有事件源发生改变，观察者便能收到通知。

基本概念

现在说说RxJava所主要涉及到的对象
1. Observable : 发射源，在观察者模式中担当着“被观察这”和“可观察对象”；
2. Observer : 观察者，可接收发射源所发射的数据；
3. Subject : 即可充当发射源，也可充当接受源。为了避免混淆，本文对subject不做详细讲解，将在以后的详细讲解中介绍；
4. Subscriber : 订阅者，也是接收源，subscriber是继承自observer，可对已订阅的事件取消订阅。observer在subscribe()过程中最终也会转换成subscriber对象；
5. Subscription : observer调用subscribe()方法返回的对象，同样具有unsubscribe()方法，用来取消订阅；
6. Action0 : RxJava的一个接口，只有一个无参的call()方法，无返回值，类似的也有Action1、Action2…Action9，call()的参数也依次是1到9个；
7. Func0 : 与Action0相似，有call()方法，但是有返回值的，同样也有Func1、Func2…Func9。

基本用法

observable的创建

最基本的创建方式，create()

Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
    // 发射一个hello的字符串
    subscriber.onNext("hello");    
    }
});

使用just()方法，会创出observable对象，并自动调用onNext()方法

Observable.just(6).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        // integer就是just()方法传入的参数6
    }
});

使用from()，会遍历集合或数组，发送每一个item

Observable.from(new String[]{ "hello", "android" })
.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        // 会依次的拿到"hello"、"android"
    }
});

observer的创建
只能通过一般的new来创建

Observer<String> observer = new Observer<String>() {
    @Override
    public void onCompleted() {
        // 数据接收完成
    }

    @Override
    public void onError(Throwable e) {
        // 数据接收出错
    }

    @Override
    public void onNext(String s) {

    }
};

有了observable跟observer对象，就可以订阅事件，想怎么玩都行了。上面通过just()跟from()创建的observable对象，是通过new Action1来订阅的，下面将通过另外一种方式，就是observable直接订阅observer对象。

Observable.just("hello").subscribe(observer);

在上面的onNext()中就可以拿到”hello”字符串，然后就可以做一系列处理，是不是很简单明了。当然，如果不需要关心数据是否接收完成跟是否会出错，可以直接用上面的new Action1作为参数传入subscribe()，在call()中做处理。

以上就是RxJava最简单的用法，虽然代码并没有比一般写法要少，但代码结构很整洁，逻辑也十分清晰，或者到了代码逻辑变了很多时，才能更好地体现RxJava的优雅。
现在有这样一个需求，有一个字符串，使用逗号间隔开的一串数字，要把大于0的取出来，然后再把拿到的数的两倍在打印出来。下面就直接上RxJava代码：

Observable.just("2, 4, 0, -3, 5, 7, -6, -2, 9, -10")
                .flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) {
        // 返回每个item的一个observable对象
        return Observable.from(s.split(","));
    }})
    .filter(new Func1<String, Boolean>() {
        @Override
        public Boolean call(String s) {
            // 过滤掉不大于0的数
            return Integer.valueOf(s) > 0;
    }})
    .map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            // 对拿到的每一个数进行处理
            Integer integer = Integer.valueOf(s);
            integer *= 2;
            return integer;
        }})
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            // 得到最后结果
            Log.d("result", String.valueOf(integer));
    }});