rxJava

最新推荐文章于 2023-03-20 15:03:24 发布

leeyushi

最新推荐文章于 2023-03-20 15:03:24 发布

阅读量179

点赞数

本文链接：https://blog.csdn.net/a1003434346/article/details/83474432

版权

资料整理：

Rxjava2(一)、基础概念及使用

Rxjava2(二)、五种观察者模式创建及背压

Rxjava2(三)、操作符的使用（未完待续）

大佬们，一波RxJava 3.0来袭，请做好准备~

https://www.jianshu.com/c/299d0a51fdd4?utm_campaign=haruki&utm_content=note&utm_medium=reader_share&utm_source=weixin

https://www.jianshu.com/p/b39afa92807e

https://blog.csdn.net/SilenceOO/article/details/77677114?utm_source=blogxgwz8&from=timeline

使用整理：

引入版本依赖：

implementation 'io.reactivex.rxjava2:rxjava:2.x.y'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

rxJava2所需要的方法,导入包基本都为:

import io.reactivex.XXX

如是其它包,会在例子时注明,不注明默认为:import io.reactivex.XXX

RxJava常用功能:

延迟操作
        // 延迟3s再发送
        Observable.just(1)
                .delay(3, TimeUnit.SECONDS)
                .subscribe(integer->{
                  
                });

Observable是上游，用来发送事件和数据
Observer是下游,用来处理事件和数据
//建立连接,只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe()方法之后才开始发送事件.
observable.subscribe(observer);

示例：

//创建一个上游 Observable：Integer为映射的数据类型,可以为其它数据类型
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);   //发送一个事件,1是数据
        emitter.onNext(2);   //再发送一个事件,2是数据
        emitter.onNext(3);   //再发送一个事件,3是数据
        emitter.onComplete();
    }
});
//创建一个下游 Observer
Observer<Integer> observer = new Observer<Integer>() {
     //onSubscribe方法为开始连接,既开始订阅
    @Override
    public void onSubscribe(Disposable d) {
        //Disposable 参数可以做切断连接的操作,该方法开始连接产生时,只会执行一次(上游发送多个onNext只会执行一次)
        Log.d(TAG, "subscribe");
    }

    @Override
    public void onNext(Integer value) {
        //依次接收事件,根据不同的数据,做不同的方法处理
        Log.d(TAG, "onNext:" + value);
    }

    @Override
    public void onError(Throwable e) {
        //当发生错误执行这里
        Log.d(TAG, "error");
    }

    @Override
    public void onComplete() {
        //全部事件依次执行完毕,执行这里
        Log.d(TAG, "complete");
    }
};
//建立连接
observable.subscribe(observer);

//链式写法

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "subscribe");
    }

    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "" + value);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "error");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "complete");
    }
});

Observable里的方法subscribe:

用来发送事件和数据；

subscribe方法里的bservableEmitter参数:

Emitter是发射器的意思，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

上游可以发送无限个onNext, 下游也可以接收无限个onNext.
当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
上游可以不发送onComplete或onError.
最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然；

Observer里的onSubscribe方法里的Disposable参数:

当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.(调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.)

看个例子, 我们让上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 切断水管, 看看运行结果:

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        Log.d(TAG, "emit 1");
        emitter.onNext(1);
        Log.d(TAG, "emit 2");
        emitter.onNext(2);
        Log.d(TAG, "emit 3");
        emitter.onNext(3);
        Log.d(TAG, "emit complete");
        emitter.onComplete();
        Log.d(TAG, "emit 4");
        emitter.onNext(4);
    }
}).subscribe(new Observer<Integer>() {
    private Disposable mDisposable;
    private int i;

    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "subscribe");
        mDisposable = d;
    }

    @Override
    public void onNext(Integer value) {
        Log.d(TAG, "onNext: " + value);
        i++;
        if (i == 2) {
            Log.d(TAG, "dispose");
            mDisposable.dispose();
            Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
        }
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "error");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "complete");
    }
});

运行结果为:

12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: subscribe
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: dispose
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: isDisposed : true    //判断切断的状态,返回为true
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 3                //还在发送事件,后面下游不再接收事件
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit complete
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 4

Observable里的subscribe建立连接方法里,有多个重载参数分别为:

public final Disposable subscribe() {}
public final Disposable subscribe(Consumer<? super T> onNext) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
public final void subscribe(Observer<? super T> observer) {}

最后一个带有Observer(下游接收事件)参数的我们已经使用过了,这里对其他几个方法进行说明:

不带任何参数的,表示下游不关心任何事件,你上游尽管发你的数据去吧,下游不做操作
带有一个Consumer参数的方法表示下游只关心onNext事件, 其他的事件我假装没看见, 因此我们如果只需要onNext事件可以这么写:

.subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "onNext: " + integer);
    }
});

其他几个方法同理, 这里就不一一解释了.

上下游默认是在同一个线程工作.

我们需要先改变上游发送事件的线程, 让它去子线程中发送事件, 然后再改变下游的线程, 让它去主线程接收事件. 通过RxJava内置的线程调度器可以很轻松的做到这一点. 接下来看一段代码:

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        //正常操作
        Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());
        Log.d(TAG, "emit 1");
        emitter.onNext(1);
    }
});

Consumer<Integer> consumer = new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        //正常操作
        Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());
        Log.d(TAG, "onNext: " + integer);
    }
};

observable.subscribeOn(Schedulers.newThread())       //设置上游的线程
        .observeOn(AndroidSchedulers.mainThread())    //设置下游的线程
        .subscribe(consumer);                         //连接下游

多次指定上游的线程只有第一次指定的有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.

多次指定下游的线程是可以生效的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.

Schedulers类型:

在RxJava中, 已经内置了很多线程选项供我们选择, 例如有

Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
Schedulers.newThread() 代表一个常规的新线程
AndroidSchedulers.mainThread() 代表Android的主线程
Schedulers.immediate() 直接在当前线程运行,相当于不指定线程
这些内置的Scheduler已经足够满足我们开发的需求, 因此我们应该使用内置的这些选项, 在RxJava内部使用的是线程池来维护这些线程, 所有效率也比较高.

实战网络请求:
Android中有名的网络请求库就那么几个, Retrofit能够从中脱颖而出很大原因就是因为它支持RxJava的方式来调用,模拟结合Retrofit调用RxJava2:
首先定义Api接口:
public interface Api {
    @GET
    Observable<LoginResponse> login(@Body LoginRequest request);

    @GET
    Observable<RegisterResponse> register(@Body RegisterRequest request);
}

接着创建一个Retrofit客户端(详细使用请参看Retrofit):

private static Retrofit create() {
    OkHttpClient.Builder builder = new OkHttpClient().newBuilder();
    builder.readTimeout(10, TimeUnit.SECONDS);
    builder.connectTimeout(9, TimeUnit.SECONDS);

    if (BuildConfig.DEBUG) {
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        builder.addInterceptor(interceptor);
    }

    return new Retrofit.Builder().baseUrl(ENDPOINT)
            .client(builder.build())
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build();
}

开始发起请求:

Api api = retrofit.create(Api.class);
api.login(request)
        .subscribeOn(Schedulers.io())               //上游在IO线程进行网络请求
        .observeOn(AndroidSchedulers.mainThread())  //下游回到主线程去处理请求结果
        .subscribe(new Observer<LoginResponse>() {   //建立连接
            @Override
            public void onSubscribe(Disposable d) {}

            @Override
            public void onNext(LoginResponse value) {}

            @Override
            public void onError(Throwable e) {
                Toast.makeText(mContext, "登录失败", Toast.LENGTH_SHORT).show();
            }

            @Override
            public void onComplete() {
                Toast.makeText(mContext, "登录成功", Toast.LENGTH_SHORT).show();
            }
        });

看似很完美, 但我们忽略了一点, 如果在请求的过程中Activity已经杀死退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了Disposable , 说它是个开关, 调用它的dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它的下游接收即可.

那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管.

实战读写数据库:

上面说了网络请求的例子, 接下来再看看读写数据库, 读写数据库也算一个耗时的操作, 因此我们也最好放在IO线程里去进行, 这个例子就比较简单, 直接上代码:

public Observable<List<Record>> readAllRecords() {
    return Observable.create(new ObservableOnSubscribe<List<Record>>() {
        @Override
        public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
            Cursor cursor = null;
            try {
                cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
                List<Record> result = new ArrayList<>();
                while (cursor.moveToNext()) {
                    result.add(Db.Record.read(cursor));
                }
                emitter.onNext(result);
                emitter.onComplete();
            } finally {
                if (cursor != null) {
                    cursor.close();
                }
            }
        }
    }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
}

Map:

转换符,通过Map, 可以将上游发来的事件转换为任意的类型, 可以是一个Object, 也可以是一个集合

示例:

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }
}).map(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return "This is result " + integer;
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});

在上游我们发送的是数字类型, 而在下游我们接收的是String类型, 中间起转换作用的就是map操作符;

FlatMap:

FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里.

上游每发送一个事件, flatMap都将创建一个新的水管, 然后发送转换之后的新的事件, 下游接收到的就是这些新的水管发送的数据. 这里需要注意的是, flatMap并不保证事件的顺序, 也就是图中所看到的, 并不是事件1就在事件2的前面. 如果需要保证顺序则需要使用concatMap.

示例:

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        //上游正常发送事件
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }
}).flatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(Integer integer) throws Exception {
        //把事件传输的值存到集合里
        final List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("I am value " + integer);
        }
        //返回事件,当前list里有3个总数,代表该次事件,下游会接收3次
        return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        //接收事件
        Log.d(TAG, s);
    }
});

如代码所示, 我们在flatMap中将上游发来的每个事件转换为一个新的发送三个String事件的水管, 为了看到flatMap结果是无序的,所以加了10毫秒的延时, 来看看运行结果吧:

D/TAG: I am value 1
D/TAG: I am value 1
D/TAG: I am value 1
D/TAG: I am value 3
D/TAG: I am value 3
D/TAG: I am value 3
D/TAG: I am value 2
D/TAG: I am value 2
D/TAG: I am value 2

concatMap:

它和flatMap的作用几乎一模一样, 只是它的结果是严格按照上游发送的顺序来发送的

示例:

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }
}).concatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(Integer integer) throws Exception {
        final List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("I am value " + integer);
        }
        return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});

只是将之前的flatMap改为了concatMap, 其余原封不动, 运行结果如下:

D/TAG: I am value 1
D/TAG: I am value 1
D/TAG: I am value 1
D/TAG: I am value 2
D/TAG: I am value 2
D/TAG: I am value 2
D/TAG: I am value 3
D/TAG: I am value 3
D/TAG: I am value 3

RxJava中内置了许许多多的操作符, 这里通过讲解map和flatMap只是最基本的,后面更多的待添加;

实践:

其中有一个登录的例子, 不知大家有没有想过这么一个问题, 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢

请求接口(结合了Retrofit):

public interface Api {
    @GET
    Observable<LoginResponse> login(@Body LoginRequest request);

    @GET
    Observable<RegisterResponse> register(@Body RegisterRequest request);
}

rxJava代码:

api.register(new RegisterRequest())            //发起注册请求
        .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
        .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求注册结果
        .doOnNext(new Consumer<RegisterResponse>() {
            @Override
            public void accept(RegisterResponse registerResponse) throws Exception {
                //先根据注册的响应结果去做一些操作
            }
        })
        .observeOn(Schedulers.io())                 //回到IO线程去发起登录请求
        .flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
            @Override
            public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse) throws Exception {
                return api.login(new LoginRequest());
            }
        })
        .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求登录的结果
        .subscribe(new Consumer<LoginResponse>() {
            @Override
            public void accept(LoginResponse loginResponse) throws Exception {
                Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Toast.makeText(MainActivity.this, "登录失败", Toast.LENGTH_SHORT).show();
            }
        });

leeyushi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
rxJava

引入版本依赖：implementation 'io.reactivex.rxjava2:rxjava:2.x.y'implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'rxJava2所需要的方法,导入包基本都为:import io.reactivex.XXX如是其它包,会在例子时注明,不注明默认为:import io.reac...
复制链接

扫一扫