RxJava 简单使用

最新推荐文章于 2023-10-07 14:07:42 发布

鱼塘的鱼

最新推荐文章于 2023-10-07 14:07:42 发布

阅读量235

点赞数 2

分类专栏：安卓文章标签： android java http

本文链接：https://blog.csdn.net/qq_35924482/article/details/110552435

版权

安卓专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Rxjava简单使用

一,调用示意图

在这里插入图片描述

二,使用方法

1,基本使用

observer = new Observer<Object>() {
    @Override
    public void onCompleted() {

    }
    @Override
    public void onError(Throwable e) {

    }
    @Override
    public void onNext(Object o) {

    }
};

subscriber = new Subscriber<Object>() {
    @Override
    public void onStart() {
        super.onStart();
        //事件发布前的准备工作,运行在subscribe相同的线程
    }
    @Override
    public void onCompleted() {

    }
    @Override
    public void onError(Throwable e) {

    }
    @Override
    public void onNext(Object o) {
        //订阅回调结果
    }
};

//方式一
Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("a");
        subscriber.onNext("b");
        subscriber.onNext("c");
        subscriber.onCompleted();
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        //订阅回调结果
        Log.d(TAG,s);
    }
});
//只使用基本功能,使用observer subscriber效果一样,subscriber提供更丰富的API调用
Observable.create(new Observable.OnSubscribe<Object>() {
    @Override
    public void call(Subscriber<? super Object> subscriber) {
        subscriber.onNext("a");
        subscriber.onNext("b");
        subscriber.onNext("c");
        subscriber.onCompleted();
    }
}).subscribe(observer);

//create  just  from,传递的参数类型不同,
Observable.just("a","b","c")
        .subscribe(observer);

String[] strings = new String[]{"a","b","c"};
Observable.from(strings)
        .subscribe(observer);

2,自定义不完整回调,自动生成subscriber

//不完整回调定义,根据不完整定义自动生成subscriber
Observable observable = Observable.just("");
Action1<String> nextAction1 = new Action1<String>() {
    @Override
    public void call(String s) {

    }
};

Action1<Throwable> errorAction1 = new Action1<Throwable>() {
    @Override
    public void call(Throwable throwable) {

    }
};

Action0 completeAction0 = new Action0() {
    @Override
    public void call() {

    }
};

observable.subscribe(nextAction1);
observable.subscribe(nextAction1,errorAction1);
observable.subscribe(nextAction1,errorAction1,completeAction0);

3,线程控制scheduler 一

subscribeOn()指定subscribe所在的线程,即observerable被激活时所在的线程
observeOn(),指定observer和subscriber所在线程

String[] data = new String[]{"a","b","c","d"};
Observable.from(data)
        .subscribeOn(Schedulers.io())               //指定observable运行在IO线
        .observeOn(AndroidSchedulers.mainThread())  //指定observer回调在主线程
        .subscribe(observer);

4,变换

将发布的序列转换成其它类型的序列,map() flatmap()

map() 事件对像直接变换,

String url = "";
Observable.just(url)
        .map(new Func1<String, Bitmap>() {
            @Override
            public Bitmap call(String s) {
                return null;
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Bitmap>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(Bitmap bitmap) {
            }
        });

flatmap()

与map()变换不同的是: flatmap()返回的是observerable对象,并且observerable对象不会主动被发送到subscriber的回调方法中,
原理:
1,使用传入的对象创建一个observable对象,
2,flatmap()不发送observable对象,而是将其激活,使其开始发送事件
3,每个observable发送的事件都被汇入同一个observable,而这个observable负责将这些事件统一发送给subscriber的回调方法

Observable.from(students)
        .throttleFirst(1000,TimeUnit.MILLISECONDS)  //防抖,防止多次重复请求
        .flatMap(new Func1<Student, Observable<Cursor>>() {
            @Override
            public Observable<Cursor> call(Student student) {
                return Observable.from(student.getCursor());
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber<Cursor>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Cursor cursor) {
                cursor.getName();
            }
        });

lif()变换,string转int

public void liftExam(Observable observable){
    observable.lift(new Observable.Operator<Integer,String>() {
        @Override
        public Subscriber<? super String> call(final Subscriber<? super Integer> subscriber) {
            return new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    subscriber.onCompleted();
                }

                @Override
                public void onError(Throwable e) {
                    subscriber.onError(e);
                }

                @Override
                public void onNext(String s) {
                    subscriber.onNext(Integer.valueOf(s));
                }
            };
        }
    });
}

compose: 对 Observable 整体的变换

多个observable的应用场景

observable1
    .lift1()
    .lift2()
    .lift3()
    .lift4()
    .subscribe(subscriber1);
observable2
    .lift1()
    .lift2()
    .lift3()
    .lift4()
    .subscribe(subscriber2);

简化可写成

private Observable liftAll(Observable observable) {
    return observable
        .lift1()
        .lift2()
        .lift3()
        .lift4();
}

liftAll(observable1).subscribe(subscriber1);
liftAll(observable2).subscribe(subscriber2);

使用 compose() 方法，Observable 可以利用传入的 Transformer 对象的 call 方法直接对自身进行处理

public class LiftAllTransformer implements Observable.Transformer<Integer, String> {
    @Override
    public Observable<String> call(Observable<Integer> observable) {
        return observable
            .lift1()
            .lift2()
            .lift3()
            .lift4();
    }
}
Transformer liftAll = new LiftAllTransformer();
observable1.compose(liftAll).subscribe(subscriber1);
observable2.compose(liftAll).subscribe(subscriber2);
observable3.compose(liftAll).subscribe(subscriber3);
observable4.compose(liftAll).subscribe(subscriber4);

三,线程控制 scheduler 二

observeOn()指定线程,指定的是其之后的操作所在的线程,即与observeOn()对应的subscriber所在的线程,若有多次切换线程的需求,可在需要切换线程的地方调用observeOn()即可,但是不同于observOn(), subscribeOn()只能调用一次,且只在第一次调用时有效,调用位置随意

Observable.Operator operator = new Observable.Operator<Integer,String>(){
    @Override
    public Subscriber<? super String> call(Subscriber<? super Integer> subscriber) {
        return null;
    }
};

Observable.just(1,2,3)
        .subscribeOn(Schedulers.io())
        .observeOn(Schedulers.newThread())
        .map(operator)
        .observeOn(Schedulers.io())
        .map(operator)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(subscriber);

subscribeOn()发生在上一级onSubscribe中,即在通知上一级onSubscribe时,事件还没有发送,可以从开始就影响到事件的线程控制,
而observOn()的线程切换发生在subscriber中,即发生在他即将给下一级发送事件时,所以observOn()控制的是它后面的线程

doOnsubscribe()

subscribe()有onStart(),但是onStart()只能在subscribe所在线程执行,并且是在subscribe()被调用时就执行,所以不能在onStart()中指定线程,否则会报线程异常错误

observable.doOnsubscribe(),在subscribe调用后,事件发送前执行,可指定线程, 默认情况下doOnsubscribe()执行在subscribe发生的线程,而如果doOnsubscribe()之后有subscribeOn(),它将执行在下一个距离最近的subscribeOn()所指定的线程

//指定准备工作的线程
String[] aa = new String[]{"1"};
Observable.from(aa)
        .subscribeOn(Schedulers.io())
        .doOnSubscribe(new Action0() {
            @Override
            public void call() {
                //需要在主线程运行
            }
        })
        .subscribeOn(AndroidSchedulers.mainThread())    //指定主线程
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(observer);