Android-学习笔记-RxJava基础

最新推荐文章于 2024-08-09 07:11:04 发布

zuochunsheng

最新推荐文章于 2024-08-09 07:11:04 发布

阅读量437

点赞数

分类专栏： kotlin gradle 文章标签： rxJava rxAndroid

本文链接：https://blog.csdn.net/zuochunsheng/article/details/103013469

版权

gradle 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

kotlin

15 篇文章 0 订阅

订阅专栏

1 优势

1 链式调用，逻辑简洁
2 线程切换方便

2 使用场景

网络请求，定时，轮询，json字符串转换对象或者一个对象转换另一个对象，按钮防抖等

3 查看最新版

查看RxJava最新版
https://search.maven.org/search?q=a:rxjava
查看RxAndroid最新版
https://search.maven.org/search?q=rxandroid

4 gradle配置，lambda区别

/* RxJava or RxAndroid */
api 'io.reactivex.rxjava2:rxandroid:2.1.1'
//api 'io.reactivex.rxjava2:rxjava:2.2.12' //最新 2.2.14 此处可换成如下
api 'io.reactivex.rxjava2:rxkotlin:2.4.0'
//rxjava 3.0
//api "io.reactivex.rxjava3:rxjava:3.0.0-RC4"

rxkotlin:2.4.0 ,里面会自动导入 rxjava:2.2.12 ，是对RxJava的扩展，支持lambda
rxjava:2.2.12,目前最新版是 rxjava:2.2.14，不支持lambda
rxjava2 如果需要使用lambda 需要 gradle 中添加
(Java 8 支持 lambda)

  compileOptions {
        sourceCompatibility 1.8
        targetCompatibility 1.8
  }

lambda区别
( (args) -> { expression } )
{ (args) -> { expression } }
java:

        Flowable.range(1, 10)
                .observeOn(Schedulers.computation())
                .map(v -> v * v)
                .filter(v -> v % 3 == 0)
                .blockingSubscribe(System.out::println);

        Observable.just(1, 4.0, 3, 2.71, 2f, 7)
                   // .cast(Integer.class) //发射前转换为该类型
                   .ofType(Integer.class) //只发射该类型
                   .subscribe((Integer x) -> System.out.print(x+" "));

kotlin:

     Flowable.range(1, 10)
            .observeOn(Schedulers.computation())
            .map { v -> v * v }
            .filter{v -> v % 3 == 0}
            .blockingSubscribe(::println)


    Observable.just<Number>(1, 4.0, 3, 2.71, 2f, 7)
            .ofType(Int::class.java)
            .subscribe { x: Int -> print(x.toString() + " ") }

5 Fragment和Activity生命周期，泄漏问题

通常来讲，当你在Activity中订阅一个Observable时，你必须在 onDestroy 里取消订阅。
可以配合使用RxLifecycle，这样就不用手动取消订阅了。

6 项目地址:

官网 http://reactivex.io/
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid

RxJava 1.0
ReactiveX/RxJava文档中文版-项目地址
 ReactiveX/RxJava文档中文版
 可能是东半球最全的RxJava使用场景小结

7 线程控制

1 线程调度器 Scheduler
Rxjava2入门教程四：Scheduler线程调度器

Schedulers.computation() ： CPU密集型计算所使用的 Scheduler。具有固定的线程池，大小为CPU核数，不可以用于IO操作，因为IO操作的等待时间会浪费CPU。
Schedulers.newThread() ：执行任务总是启用新的线程。不具有线程缓存机制。
Schedulers.io() ：I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。具有线程缓存机制。
行为模式和 newThread() 差不多，区别在于 io()的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。也不要把计算工作放在 io() 中，可以避免创建不必要的线程。
Schedulers.single() ：拥有一个线程单例，所有的任务都在这一个线程中执行，当此线程中有任务在执行的时候，其他任务将按照队列先进先出的顺序依次执行。（是依次执行并不是依次执行完成）
Schedulers.trampoline() ：将当前线程的任务按添加顺序排队，线程一次只执行一个任务，其余任务排队等待，一个任务都执行完成后再开始执行下一个任务。

2 AndroidSchedulers
AndroidSchedulers.mainThread() ：操作将在 Android 主线程运行。属于Android的专属定制。

3 线程切换
Rxjava默认运行在当前线程中。如果当前线程是子线程，则rxjava运行在子线程；同样，当前线程是主线程，则rxjava运行在主线程。

subscribeOn( ) — 指定被观察者Observable执行任务的调度器
observeOn( ) — 指定观察者 Observer的调度器

      Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
                .subscribeOn(Schedulers.io())

                .observeOn(Schedulers.newThread())
                .map(mapOperator1) // 新线程，由 observeOn() 指定

                .observeOn(Schedulers.io())
                .map(mapOperator2) // IO 线程，由 observeOn() 指定

                .observeOn(AndroidSchedulers.mainThread)
                .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

Java

   public static <T> ObservableTransformer<T, T> compose() {

//        return (ObservableTransformer<T, T>) (new  ObservableTransformer() {
//            @Override public Observable apply(Observable observable) {
//                return observable.subscribeOn(Schedulers.newThread())
//                        .observeOn(AndroidSchedulers.mainThread());
//            }
//        });
        return (observable ->
                observable.subscribeOn(Schedulers.io())
                          .observeOn(AndroidSchedulers.mainThread())
        );
    }

Kotlin

fun <T> compose(): ObservableTransformer<T, T> {
    return ObservableTransformer { observable ->
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
    }
}