RXJAVA2引用理解

来源：互联网发布：手机淘宝体检中心登录编辑：程序博客网时间：2024/06/01 07:45

Rxjava2 完全不同的方式
引用链接

http://reactivex.io/RxJava/2.x/javadoc/

http://www.jianshu.com/p/464fa025229e
http://www.jianshu.com/p/d149043d103a

1、上下游调用关系

//创建一个上游 Observable：

      Observable<Integer> observable = 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();            }        });

    //创建一个下游 Observer

  Observer<Integer> observer = 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(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");            }        });

ObservableEmitter： Emitter是发射器的意思，那就很好猜了，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
1、不可以发送多个onError，否则收到第二个onError，程序会崩溃

2、下游的disposable用法，可以截断下游接收消息，但是上游还是会继续发送

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");            }        });

3、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) {}

Rxjava2相对于 RXjava1多出的变化点

1、observable被观察者的其他创建方式

Just方式传入数组内容进行遍历
Observable observable = Observable.fromIterable(Iterable list)
方式，可以进行遍历所有collection将诶口的实现类

defer方式,观察者订阅时候才创建observable，且针对每个观察者，创建的都是新的Observable

Observable<String> observable = Observable.defer(new Callable<ObservableSource <? extends String>>(){  @overridePublic ObservableSource<? extends String> call()throw Exception{    Return Observable.just(‘hello’)}})

interval()方式,按照固定时间间隔进行发射 onNext方法
Observable observable = Observable.interval(2,TimeUnit.SECONDS);

range方式，第一个参数为起始值，第二个参数为发送个数，注意只能够指定整数

Observable observable = Observable.range(1,20);

time()方式，进行延时一定时间后，发射一个特殊值
Observable observable = Observable.time(2,TimeUnit.SECONDS);

repeat方式，observable可以重复使用进行发送
Observable observable = Observable.just(123).repeat();

函数式回调接口用于接收 observable的回调

Observable.just("hello").subscribe(new Consumer<String>() {            @Override            public void accept(String s) throws Exception {                System.out.println(s);            }        });

map()操作符

Observable<Integer> observable = Observable.just("hello").map(new Function<String, Integer>() {            @Override            public Integer apply(String s) throws Exception {                return s.length();            }        });

flatMap()操作符，重新生成observable对象和之前的Rxjava1类似

 Observable<Object> observable = Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {            @Override            public ObservableSource<?> apply(List<String> strings) throws Exception {                return Observable.fromIterable(strings);            }        });

filter()操作符，根据自己想过滤的数据，加入相应的逻辑判断，true表示满足条件，false表示不满足，过滤后数据加入新的 observable中

Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {            @Override            public ObservableSource<?> apply(List<String> strings) throws Exception {                return Observable.fromIterable(strings);            }        }).filter(new Predicate<Object>() {            @Override            public boolean test(Object s) throws Exception {                String newStr = (String) s;                if (newStr.charAt(5) - '0' > 5) {                    return true;                }                return false;            }        }).subscribe(new Consumer<Object>() {            @Override            public void accept(Object o) throws Exception {                System.out.println((String)o);            }        });

take()操作符，输出最多指定数量的结果

Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {            @Override            public ObservableSource<?> apply(List<String> strings) throws Exception {                return Observable.fromIterable(strings);            }        }).take(5).subscribe(new Consumer<Object>() {            @Override            public void accept(Object s) throws Exception {                System.out.println((String)s);            }        });

doOnNext()，允许每次输出一个元素，去做额外的事情

Observable.just(list).flatMap(new Function<List<String>, ObservableSource<?>>() {            @Override            public ObservableSource<?> apply(List<String> strings) throws Exception {                return Observable.fromIterable(strings);            }        }).take(5).doOnNext(new Consumer<Object>() {            @Override            public void accept(Object o) throws Exception {                System.out.println("准备工作");            }        }).subscribe(new Consumer<Object>() {            @Override            public void accept(Object s) throws Exception {                System.out.println((String)s);            }        });

参考链接中，实际项目用 retrofit和 rxjava结合例子

要使用Retrofit,先在Gradle中添加配置:

//Retrofit
compile ‘com.squareup.retrofit2:retrofit:2.1.0’
//Gson converter
compile ‘com.squareup.retrofit2:converter-gson:2.1.0’
//Okhttp
compile ‘com.squareup.okhttp3:okhttp:3.5.0’
//RxJava　adapter
compile ‘com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0’
定义Api接口:

public interface Api {
@GET(“citys”)
Observable getAllCity(@Query(“key”) String key);
}
创建一个Retrofit客户端:

private static Retrofit create() {        OkHttpClient.Builder builder = new OkHttpClient().newBuilder();        builder.readTimeout(10, TimeUnit.SECONDS);        builder.connectTimeout(9, TimeUnit.SECONDS);        return new Retrofit.Builder().baseUrl(baseUrl)                .client(builder.build())                .addConverterFactory(GsonConverterFactory.create())                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())                .build();    }Retrofit retrofit = create();        Api api = retrofit.create(Api.class);        Observable<AllCity> observable = api.getAllCity(appkey);        observable.subscribeOn(Schedulers.io())                .flatMap(new Function<AllCity, ObservableSource<City>>() {                    @Override                    public ObservableSource<City> apply(AllCity city) throws Exception {                        ArrayList<City> result = city.getResult();                        return Observable.fromIterable(result);                    }                })                .filter(new Predicate<City>() {                    @Override                    public boolean test(City city) throws Exception {                        String id = city.getId();                        if(Integer.parseInt(id)<5){                            return true;                        }                        return false;                    }                })                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Consumer<City>() {                    @Override                    public void accept(City city) throws Exception {                        System.out.println(city);                    }                });

Flowable新类新方法
在RxJava中会经常遇到一种情况就是被观察者发送消息十分迅速以至于观察者不能及时的响应这些消

背压产生方式，即生产者产生速度，远大于消费者消费速度，造成事件无限堆积，最终oom

Observable.create(new ObservableOnSubscribe<Integer>() {            @Override            public void subscribe(ObservableEmitter<Integer> e) throws Exception {                while (true){                    e.onNext(1);                }            }        })                .subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Consumer<Integer>() {            @Override            public void accept(Integer integer) throws Exception {                Thread.sleep(2000);                System.out.println(integer);            }        });

异步调用ERROR模式
指定模式BackpressureStrategy.ERROR

消费者申请可以处理的请求个数 s.request(Long.MAX_VALUE);
并且默认缓存池大小 128，在ERROR策略下，缓存池溢出，则会抛出MissionBackPressureException异常

BUFFER模式
所谓BUFFER就是把RxJava中默认的只能存128个事件的缓存池换成一个大的缓存池，支持存很多很多的数据。
这样，消费者通过request()即使传入一个很大的数字，生产者也会生产事件，并将处理不了的事件缓存。
但是这种方式任然比较消耗内存，除非是我们比较了解消费者的消费能力，能够把握具体情况，不会产生OOM。
总之BUFFER要慎用。

DROP模式
当消费者处理不了事件，就丢弃。
消费者通过request()传入其需求n，然后生产者把n个事件传递给消费者供其消费。其他消费不掉的事件就丢掉

LATEST模式
LATEST与DROP功能基本一致。
消费者通过request()传入其需求n，然后生产者把n个事件传递给消费者供其消费。其他消费不掉的事件就丢掉。
唯一的区别就是LATEST总能使消费者能够接收到生产者产生的最后一个事件。
还是以上述例子展示，唯一的区别就是Flowable不再无限发事件，只发送1000000个。
结果如下：

Flowable<Integer> flowable = Flowable.create(new FlowableOnSubscribe<Integer>() {            @Override            public void subscribe(FlowableEmitter<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();            }        }, BackpressureStrategy.ERROR); //增加了一个参数        Subscriber<Integer> subscriber = new Subscriber<Integer>() {            @Override            public void onSubscribe(Subscription s) {                Log.d(TAG, "onSubscribe");                s.request(Long.MAX_VALUE);              }            @Override            public void onNext(Integer integer) {                Log.d(TAG, "onNext: " + integer);            }            @Override            public void onError(Throwable t) {                Log.w(TAG, "onError: ", t);            }            @Override            public void onComplete() {                Log.d(TAG, "onComplete");            }        };        flowable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(subscriber);

我们让Flowable发送129个事件，而Subscriber一个也不处理，就产生了异常。
因此，ERROR即保证在异步操作中，事件累积不能超过128，超过即出现异常。消费者不能再接收事件了，但生产者并不会停止

Drop模式

mFlowable = Flowable.create(new FlowableOnSubscribe<Integer>() {            @Override            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {                for (int i = 0; ; i++) {                    emitter.onNext(i);                }            }        }, BackpressureStrategy.DROP);        mSubscriber = new Subscriber<Integer>() {            @Override            public void onSubscribe(Subscription s) {                mSubscription = s;                s.request(50);            }            @Override            public void onNext(Integer integer) {                Log.d(TAG, "onNext: " + integer);            }            @Override            public void onError(Throwable t) {                Log.w(TAG, "onError: ", t);            }            @Override            public void onComplete() {            }        };    }    public void start(View view){        mFlowable.subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .subscribe(mSubscriber);    }    public void consume(View view){        mSubscription.request(50);    }

上述例子Flowable对象的获取都是通过create()获取的，自然可以通过BackpressureStrategy.LATEST之类的方式指定处理背压的策略。如果Flowable对象不是自己创建的，可以采用onBackpressureBuffer()、

`onBackpressureDrop()、onBackpressureLatest()的方式指定。 Flowable.just(1).onBackpressureBuffer()                .observeOn(AndroidSchedulers.mainThread())                .subscribeOn(Schedulers.io())                .subscribe(new Consumer<Integer>() {                    @Override                    public void accept(Integer integer) throws Exception {                    }                });`

阅读全文

0 0