Rxjava2笔记2

已于 2024-03-17 20:44:01 修改
阅读量262 收藏
点赞数 1
分类专栏： Android Rxjava 文章标签： 笔记 android java
于 2020-08-22 17:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq873044564/article/details/108147165
版权

笔记1操作符的介绍:Rxjava2的笔记1 --操作符_observable.just传入多参数-CSDN博客

参考视频:https://edu.csdn.net/course/play/10037/213573

基本响应类型

Observable:最基本的响应类型,不支持背压

背压是什么

背压就是上游发送数据的速度很快,下游没有来得及处理,就会累积很多数据;在高并发的时候会发生背压

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("123");
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.e(TAG, "onNext: " + s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: " );
                    }
                });

 

Flowable和Observable使用基本类似,Observable不支持背压,Flowable支持背压,使用Flowable的时候,必须调用Subscription的request的方法请求

Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                emitter.onNext("123");
                emitter.onNext("456");
                emitter.onNext("789");
                emitter.onComplete();
            }
            //背压策略
        }, BackpressureStrategy.DROP)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //下游可以接受2个数据
                        s.request(2);
                    }

                    @Override
                    public void onNext(String s) {
                        Log.e(TAG, "onNext: " + s );
                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: " );
                    }
                });

Single:只发射一个元素的相应类型,发射onSuccess或者onError方法

 Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> emitter) throws Exception {
                emitter.onSuccess("success");
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new SingleObserver<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onSuccess(String s) {
                         Log.e(TAG, "onSuccess: " );
                    }

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

Completable:仅仅给下游一个信号的响应类型,回调onComplete或者onError

Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new CompletableObserver() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: " );
                    }

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

Maybe:Single和Completable的结合,信号和数据的结合,但也只能接收到其中的一员

Maybe.create(new MaybeOnSubscribe<String>() {
            @Override
            public void subscribe(MaybeEmitter<String> emitter) throws Exception {
                emitter.onSuccess("success");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new MaybeObserver<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onSuccess(String s) {
                        Log.e(TAG, "onSuccess: ");
                    }

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

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: ");
                    }
                });

Rxjava的背压策略

背压是什么

背压在高并发中较为常见,在异步场景中,由于数据流的发射速度大于数据流的接收速度,导致数据不能及时接收,从而导致数据流的阻塞,背压所要做的就是主动控制数据流发射的速度.

Rxjava2中使用Flowable用来支持背压,Observable对背压不支持

1.在订阅的时候如果使用FlowableSubscriber,需要通过s.request(Long.MAX_VALUE)去主动请求上游的数据项,遇到背压报错的时候,FlowableSubscriber默认已经将错误try-catch,并通过onError回调,程序并不会崩溃;

2.在订阅的时候如果使用Consumer,那么不需要主动去请求上游数据,默认已经调用了s.request(Long.MAX_VALUE),如果遇到背压报错,且对Throwable的Consumer没有new出来,则程序直接崩溃;

3.背压策略上游的缓存池默认为128

MISSING:表示OnNext对事件没有任何的缓存和丢弃,下游要处理任何溢出,其实可以理解为没有背压,所以超出128的就会异常

 Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 129; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.MISSING)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new FlowableSubscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {

                        Log.e(TAG, "onNext: " + integer );
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "onError: " + t.getMessage() );
                    }

                    @Override
                    public void onComplete() {

                    }
                });

可以看到0-128共129个,超出128了,所以异常,但是因为是Flowable,所以会try-catch住,回调到onError

ERROR:下游无法跟上上游的发射速度时,会抛出异常

Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 129; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.ERROR)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new FlowableSubscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {

                        Log.e(TAG, "onNext: " + integer );
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "onError: " + t.getMessage() );
                    }

                    @Override
                    public void onComplete() {

                    }
                });

无法发出第129个数据 

BUFFER:上游不断的发出onNext请求,直到下游处理完,上游发射的数据项的缓存池是无限大的,程序也不会抛错误,但是由于缓存占用内存,所以可能出现OOM-内存溢出现象

 Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 129; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.BUFFER)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new FlowableSubscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {

                        Log.e(TAG, "onNext: " + integer );
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "onError: " + t.getMessage() );
                    }

                    @Override
                    public void onComplete() {

                    }
                });

可以看到129个数据全部发了出来 

DROP:对于多余的数据会丢弃掉

Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 129; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.DROP)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new FlowableSubscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {

                        Log.e(TAG, "onNext: " + integer );
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "onError: " + t.getMessage() );
                    }

                    @Override
                    public void onComplete() {

                    }
                });

latest:除了128个数据之外,还会把最后一个数据也放入缓存池中

 Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 130; i++) {
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.LATEST)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new FlowableSubscriber<Integer>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {

                        Log.e(TAG, "onNext: " + integer );
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.e(TAG, "onError: " + t.getMessage() );
                    }

                    @Override
                    public void onComplete() {

                    }
                });

 为了明显,我把数据发射了130个,所以最后一个也

实战1 - 模拟发送验证码

这里面的操作符有不会的可以去看笔记1

 private void initRxjava1() {
        mButton = findViewById(R.id.button);
        mButton.setText("点击发送验证码");
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                verify();
            }
        });
    }

    @SuppressLint("CheckResult")
    private void verify() {
        final int count = 3; //倒计时3秒
        Observable.interval(0,1, TimeUnit.SECONDS)
                .take(count+1) //0,1,2,3
                .map(new Function<Long, Long>() {
                    @Override
                    public Long apply(Long aLong) throws Exception {
                        return count - aLong; //转换为3,2,1,0
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                //监听生命周期
                .doOnSubscribe(new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        mButton.setEnabled(false);
                    }
                })
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        //在0秒的时候会调用到complete,所以没有显示剩余0秒
                        mButton.setText("剩余" + aLong+"秒");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        //onComplete事件
                        mButton.setEnabled(true);
                        mButton.setText("点击发送验证码");
                    }
                });
    }

运行结果:

实战2.防止用户多次点击

throttleFirst这个属性

private void initView() {
        mButton = findViewById(R.id.button);
        query(mButton);
    }

    public void query(View view) {
        RxUtils.click(view, 2)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.e(TAG, "onNext: ");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: ");
                    }
                });
    }

    static class RxUtils {
        //非静态内部类不能有静态方法
        public static Observable<Object> click(final View view, long seconds) {
            return new ViewClickObservable(view)
                     //2秒内只接受第一次点击
                    .throttleFirst(2, TimeUnit.SECONDS)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .doOnDispose(new Action() {
                        @Override
                        public void run() throws Exception {
                            if (view !=null){
                                view.setOnClickListener(null);
                            }
                        }
                    });
        }
    }

    static class ViewClickObservable extends Observable<Object> {
        private View mView;

        public ViewClickObservable(View view) {
            this.mView = view;
        }

        @Override
        protected void subscribeActual(Observer<? super Object> observer) {
            if (mView != null) {
                mView.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        observer.onNext(mView);
                    }
                });
            }
        }
    }

第二种写法,前面是对Observable的重写,这个是对ObservableOnSubscribe的重写

@SuppressLint("CheckResult")
    private void initView() {
        mButton = findViewById(R.id.button);
        query(mButton);
    }

    public void query(View view) {
        RxUtils.click(view, 2)
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object o) {
                        Log.e(TAG, "onNext: ");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: ");
                    }
                });
    }

    static class ViewClickObservableOnSubscribe implements ObservableOnSubscribe<Object> {
        ObservableEmitter<Object> mEmitter;

        public ObservableEmitter<Object> getEmitter() {
            return mEmitter;
        }

        @Override
        public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
            mEmitter = emitter;
        }
    }

    static class RxUtils {
        //非静态内部类不能有静态方法
        public static Observable<Object> click(final View view, long seconds) {
            ViewClickObservableOnSubscribe viewClickObservableOnSubscribe = new ViewClickObservableOnSubscribe();
            if (view !=null){
                view.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View view) {
                        ObservableEmitter<Object> emitter = viewClickObservableOnSubscribe.getEmitter();
                        emitter.onNext(view);
                    }
                });
            }
            return Observable.create(viewClickObservableOnSubscribe)
                    .throttleFirst(2, TimeUnit.SECONDS)
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .doOnDispose(new Action() {
                        @Override
                        public void run() throws Exception {
                            if (view != null) {
                                view.setOnClickListener(null);
                            }
                        }
                    });
        }
    }

运行效果:在2秒内点击多次,但只接受第一次的点击

实战3 : 模拟会员信息的合并

需求:获取列表中的会员信息,当本地有缓存时,就从本地获取信息,否则就从网络获取

public static class Vip {
}

 //用来本地缓存会员信息的map
private HashMap<Long, Vip> mVipCache = new HashMap<>();
 //获取列表的方法
    public Observable<HashMap<Long, Vip>> getVipList(List<Long> uids) {
        List<Long> vipRequest = new ArrayList<>();
        HashMap<Long, Vip> vipLocal = new HashMap<>();

        for (Long uid : uids) {
            if (mVipCache.containsKey(uid)) {
                Log.e(TAG, "从本地获取数据 " + uid + "用户");
                vipLocal.put(uid, mVipCache.get(uid));
            } else {
                Log.e(TAG, "从网络获取数据 " + uid + "用户");
                vipRequest.add(uid);
            }
        }
        if (vipRequest.isEmpty()) {
            return Observable.just(vipLocal);
        }
        return Observable.merge(Observable.just(vipLocal), getVipFromWeb(vipRequest));
    }
    
    //从网络获取列表的方法
    public Observable<HashMap<Long, Vip>> getVipFromWeb(List<Long> uids) {
        HashMap<Long, Vip> vipList = new HashMap<>();
        for (Long uid : uids) {
            Vip vip1 = new Vip();
            vipList.put(uid, vip1);
        }
        //缓存到本地
        mVipCache.putAll(vipList);

        return Observable.just(vipList);
    }
public void initData() {
        List<Long> uids = new ArrayList<>();
        Log.e(TAG, "第一次查询: ");
        uids.add(1L);
        uids.add(2L);
        getVipList(uids);
        uids.clear();

        Log.e(TAG, "第二次查询: ");
        uids.add(1L);
        uids.add(2L);
        uids.add(3L);
        uids.add(4L);
        getVipList(uids);
        uids.clear();

        Log.e(TAG, "第三次查询 ");
        uids.add(1L);
        uids.add(2L);
        uids.add(3L);
        uids.add(4L);
        mVipCache.clear();
        getVipList(uids);
    }

_火焰猫
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RxJava2基础总结 （一）
帅
08-01 546
发射器 Observable 被观察者，内部存放观察者，用于发射数据。 创建默认发射器 Observable.create 创建一个含有执行过程(得到发射数据)的发射器 Observable.create(new ObservableOnSubscribe&amp;amp;amp;amp;amp;amp;lt;Object&amp;amp;amp;amp;amp;amp;gt;() { @Override publi
RxJava2.0 全异步编程 源码解析
阿凡提的小毛驴专栏
11-20 454
1 常用操作的实例 Single<Model> xm = Single.create((SingleOnSubscribe<Model>) emitter -> { System.out.println("do some future task"); emitter.onSuccess(new Model("小明", 6)); }); Single<Model> xh = S
Rxjava2-Single
相公
09-06 1532
Rxjava2-Single Single .create(new SingleOnSubscribe<Integer>() { @Override public void subscribe(SingleEmitter<Integer> emitter) thr...
Single、Completable、Maybe——简化版的 Observable
luckykuku
07-24 795
  在Rxjava2中，Observale和Flowable都是用来发射数据流的，但是，我们在实际应用中，很多时候，需要发射的数据并不是数据流的形式，而只是一条单一的数据，或者一条完成通知，或者一条错误通知。在这种情况下，我们再使用Observable或者Flowable就显得有点大材小用，于是，为了满足这种单一数据或通知的使用场景，便出现了Observable的简化版——Single、Comp...
RxJava2｜Single, Maybe 和 Completable
aijuanlie5852的博客
10-31 290
RxJava2 Single, Maybe 和 Completable 原文: https://www.jianshu.com/p/66a55abbadef 参考而做的二次实现. 并重排版一下他的总结, 在此做个记录好回顾. 本文没有原文那么详尽, 建议阅读原文. 前述 java-1.8 maven-3 rxjava-2.2.3 io.reactivex.Single: a f...
Rxjava2中Single的just操作符源码学习
zhaonhui的博客
07-23 1252
//注释1 Single<Integer> integerSingle = Single.just(1); //注释2 integerSingle.subscribe(new SingleObserver<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onSuccess(Integer s) {
RxJava实战读书笔记
10-11
RxJava实战的读书笔记 按照章节整理的核心知识点，便于自己理解和记忆
读书笔记：RxJava 2.x 实战.zip
最新发布
07-22
读书笔记：RxJava 2.x 实战
RxJavaNotes:RxJava2 应用场景总结及源码学习笔记
04-30
RxJava2 Learning Notes 原理 一系列的事件序列，通过上下游链接，使得上游没产生一个事件，下游就能接收到该事件。 上游和下游就分别对应着RxJava中的Observable和Observer;两者之间的连接就对应着subscribe() 只有...
RxJava&RxAndroid;笔记
12-04
RxJava&RxAndroid;笔记。RxJava&RxAndroid;笔记 RxJava&RxAndroid;笔记
Dagger2 Android依赖注入学习笔记
01-04
最近在用 MVP + RxJava + Retrofit 写项目，觉得相对于其他的开发框架，这的确是给我们带来了很多方便，但是在网上搜寻相关资料的时候，总是能看到 MVP + RxJava + Retrofit + Dagger 这样的搭配组合，那 Dagger 又...
RxJava2系列(一) 简单使用
hhxsp的博客
11-25 876
1、定义 2、基本用法 3、操作符 4、使用场景 5、浅析源码
RxJava2 使用详解一之基础教程
0729Liang
08-30 1356
目录 一、配置 二、原理 第一步：创建被观察者 第二步：创建观察者 第三步：建立订阅关系 链式操作 ObservableEmitter： Disposable： subscribe()重载方法 下篇：RxJava2 使用详解二之线程调度 一、配置 要在Android中使用RxJava2, 在app的build.gradle中添加依赖： /*导入Rxjava RxAndr...
Android~RxJava实现newSingleThreadExecutor()同等效果
Hynson的学习笔记
10-30 816
Rxjava使用起来还是蛮方便的，不用担心调用Observable create、subscribeOn后会创建新的线程，它会复用同一线程的。也不用像java自带的线程池那样去复用提交任务，大大简化编码方式。RxJava浅析试手 RxJava 2.x 及对线程的初步理解RxJava第三篇，调度器Scheduler。
RxJava中DISPOSED状态的被观察者任务执行onError/onSuccess导致的崩溃问题
TechMix的博客
04-21 591
居然直接获取了当前的UncaughtExceptionHandler然后转调uncaughtException，要知道这样会走应用的崩溃上报逻辑，即使是逻辑上书写的错误，也会导致崩溃上报（一般应用自定义的UncaughtExceptionHandler会弹出崩溃页面，并让用户确认是否上报崩溃日志，最后将进程kill掉）。尝试把异步任务mApi.loadData()延迟2000ms后，频繁切换Activity的onResume和onPuase状态，崩溃复现。
史上超详细的RxJava2使用和RxLifecycle生命周期管理，解决RxJava内存泄漏
chuyouyinghe的专栏
02-07 1477
这篇文章基于RxJava2.0 RxJava是什么？ 官网说RxJava是一个可观测的序列来组成异步的额，基于事件的库，简单来说，它就是一个实现异步的库，可以代替Android的API如AsyncTask ，Handler等等。 RxJava为什么好？ RxJava其实就是提供一套异步编程的API，这套API是基于观察者模式的，而且是链式调用的，所以使用RxJava编写的代码逻辑会非常简洁。 观察者模式： 定义：对象间一种一对多的关系，使得每当一个对象改变，则所有依赖于它的对象都会得到通知并被自动更新
在Android中运用RxJava
紫雾凌寒
04-16 2803
1、RxJava 2.01.1、什么是RxJava和响应式编程（reactive programming）        在响应编程中，消费者对数据进行反应，这就是为什么异步编程也被称为响应式编程的原因。 响应式编程允许将事件更改传播到已注册的观察者。        RxJava是从Netflix的反向扩展（Rx）到Java的端口。 RxJava是2014年开源的，托管于http://reacti...
RxJava2极速入门——Rxjava理念与基础知识
易庞宙的博客
03-16 1432
目录 RxJava入门理念 函数响应式编程的概念及特点 函数编程概念 函数编程特性 响应式编程概念 响应式编程的特性 RxJava的基础知识 RxJava的创建 RxJava的生命周期回调 RxJava的五种观察者模式 Observable与Observer Flowable Single与SingleObserver Completable Maybe 总结心得 ...
使用 RxJava 的正确姿势
weixin_30412577的博客
03-24 270
最近在使用 RxJava 时遇到了一些比较诡异的问题，排查的过程中做了点研究，发现平时大家的用法多多少少都有些问题。有些地方存在隐患，有些用法不够简练，我把这些问题简单做一下分类和总结，供大家参考。 数据源类型选择 RxJava2 中的数据源类型有5种，分别是 Observable，Flowable，Single，Maybe 和 Completable，它们的区别如下，看到有些同学只用 ...
RxJava2 + Retrofit2 + OKHttp post请求
06-12
使用RxJava2 + Retrofit2 + OKHttp进行POST请求，可以按照以下步骤进行： 1. 添加依赖 在项目的build.gradle文件中添加以下依赖： ``` dependencies { implementation 'io.reactivex.rxjava2:rxjava:2.2.19' ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值