RXJAVA的使用

作者: XINHAO_HAN | 来源:发表于2017-10-30 15:17 被阅读0次

Rxjava的引入:
compile 'io.reactivex.rxjava2:rxjava:2.0.5'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

作者:XINHAO_HAN

RxJava的简单使用:<原理就是一个发射器,和一个接收器,类似回调>
1.先创建发射器:(Observable<T>)

  Observable<String> observable = Observable.create(new   Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("XINHAO_HAN");
                subscriber.onStart();

            }
        });

2.创建接收器<Observer<T>>

 Observer<String> o = new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.e("数据接收", "onNext: " + s);

            }
        };

3.绑定发射器与接收器(发射器. subscribe(接收器);)//通俗一点

 observable.subscribe(o);

这就是RXJAVA简单地使用,看到这你会说一句waht?这个能干毛?,0.0 别急,重要的是在后边哟~~~~

但是你会觉得别人和我自己写的不一样呀,别人的都是比较高大上,为啥这个功能这么简单,还那么多代码,额....

那个是链式编程,我们改动一下,这样就会自动绑定


        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("XINHAO_HAN");
                subscriber.onStart();

            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.e("数据接收", "onNext: " +s );

            }
        });

如果你不需要这两个方法

@Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

可重写<在不考虑失败,和接收到数据之前的情况下>

new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("数据接收", "call: " +s );
            }
        }

好啦~这就是RXJAVA的使用,what?你在逗我?这个是个毛线,你拿这个出来搪塞我啊.
哈哈~~~当然不是啦
先给你介绍几个东西在我自己理解的情况下,它是这样的,然后你先加什么东西,就随便啦~~~

创建发射器( Observable<T>)
                    .功能1(other)
                    .功能2(other)
                    .功能3(other)
                     ... (other...)
                    .接收器(Observer<T>)//数据会被每个功能统统揍一遍,然后会回到接收器

介绍一个东东..<filter>方法

.filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return null;
            }
        })

filter(过滤器,拦截器,把不需要的拦截掉)--方法它有1个参数看见方法名应该就会知道吧,它是一个返回Boolean的值,如果是false数据就会在这一个节点死去,不会再往下一个节点传递,
比如

 Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("XINHAO_HAN");
                subscriber.onStart();

            }
        }).filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return s.equals("123");
            }
        })
                .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("数据接收", "call: " +s );
            }

这段的用意就是如果"XINHAO_HAN"与"123"相等就继续往下传直到接收器,如果不相等,就在这块被过滤器大哥BB了~~最终运行结果,就是------->毛都没有,啊啊哈哈哈哈哈哈,233333333333 0.0
好啦好啦~来继续下一个

flatMap(平面地图,什么鬼?在我理解它是一个机枪,把一个个子弹发射出去,what?什么鬼?ArrayList相当于一个弹夹,它会逐个往下传递ArrayList的中每一个数据)
比如:

//我创建一个ArrayList的字符创为 "1","2","3","4"....."100"
  ArrayList<String> arr = new ArrayList<>();

        for (int i = 0; i < 100; i++) {

            arr.add(i + "");
        }

//然后这样<切记>

注意注意注意
WARNING!!!!!WARNING!!!!WARNING
//你创建这个时候下一个节点会报错,因为它没识别你的数据类型把 "?" 改为你想要的数据类型

flatMap(new Func1<String, Observable<?>>() {
            @Override
            public Observable<?> call(String s) {
                return null;
            }
        })

比如我是String类型的

.flatMap(new Func1<String, Observable<String>>() {
            @Override
            public Observable<String> call(String s) {
                return null;
            }

//这样下一级的节点才能正确识别你的数据类型

OK来看看这个节点有什么用吧~~~~

  final ArrayList<String> arr = new ArrayList<>();

        for (int i = 0; i < 100; i++) {

            arr.add(i + "");
        }

        Observable.create(new Observable.OnSubscribe<ArrayList<String>>() {
            @Override
            public void call(Subscriber<? super ArrayList<String>> subscriber) {
                subscriber.onNext(arr);
                subscriber.onStart();

            }
        }).flatMap(new Func1<ArrayList<String>, Observable<String>>() {
            @Override
            public Observable<String> call(final ArrayList<String> strings) {
                return Observable.create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {

                        for (int i = 0; i < strings.size(); i++) {
                            subscriber.onNext(strings.get(i));

                        }

                    }
                });

            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {

                Log.e("数据接收", "call: " + s);
            }
        });

LOG:

10-30 14:55:06.560 2520-2520/com.example.administrator.xinhao_han_utils E/数据接收: call: 0
10-30 14:56:35.255 4161-4161/com.example.administrator.xinhao_han_utils E/数据接收: call: 0
10-30 14:56:35.255 4161-4161/com.example.administrator.xinhao_han_utils E/数据接收: call: 1
.....
.....
10-30 14:56:35.258 4161-4161/com.example.administrator.xinhao_han_utils E/数据接收: call: 99

直接懵逼了,我曹这都是啥啥啥?????这是什么操作?别急嘛,flatMap上边解释像机关枪一样把弹夹(集合)一个个打出去,这个观念就差不多,
flatMap是重复创建一个发射器,然后onNext就是一个一个往出打,嗯,明白了木???T.T
你看见那个for循环就知道干嘛了嘛.这个要慢慢理,实在不理解就想成机关枪0.0
↑
仅仅在便利集合当中当做机关枪,然而,它就只是单纯的又创建了一个发车器_老司机滴滴滴
↓
好啦,接下来我们做一个输出所有能 | 被2整除 | 的数据

被2整除

 final ArrayList<String> arr = new ArrayList<>();

        for (int i = 0; i < 100; i++) {

            arr.add(i + "");
        }

        Observable.create(new Observable.OnSubscribe<ArrayList<String>>() {
            @Override
            public void call(Subscriber<? super ArrayList<String>> subscriber) {
                subscriber.onNext(arr);
                subscriber.onStart();

            }
        }).flatMap(new Func1<ArrayList<String>, Observable<String>>() {
            @Override
            public Observable<String> call(final ArrayList<String> strings) {
                return Observable.create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {

                        for (int i = 0; i < strings.size(); i++) {
                            subscriber.onNext(strings.get(i));

                        }

                    }
                });

            }
        }).filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                int i = Integer.parseInt(s);
                if (i % 2 == 0) {
                    return true;
                } else {
                    return false;
                }


            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {

                Log.e("数据接收", "call: " + s);
            }
        });

LOG

10-30 15:05:32.318 12765-12765/? E/数据接收: call: 0
10-30 15:05:32.318 12765-12765/? E/数据接收: call: 2
10-30 15:05:32.318 12765-12765/? E/数据接收: call: 4
....
....
10-30 15:05:32.320 12765-12765/? E/数据接收: call: 94
10-30 15:05:32.320 12765-12765/? E/数据接收: call: 96
10-30 15:05:32.320 12765-12765/? E/数据接收: call: 98

来来来,现在是map节点:

map(地图)节点:what 地图节点??什么意思?不明白这个玩意有何用?别急小帅哥西路,来_进来玩呀~~~

我们看一下就明白了,这个玩意是干嘛的,啥?你说啥?你不明白? T.T,无语了啊......
他就是给你暴露出你当前的String值

.map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return null;
            }
        })

比如你在发射器当中写的是"XINHAO_HAN"好吧..还是我名字的全拼,啦啦啦啦~

.map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return "小帅哥进来玩呀";// <- 我在这改成了这个值
            }
        })

你猜接收器会有什么东西,对!你的直觉对了!没错!就是这个东东!----> "小帅哥进来玩呀"
它吧"XINHAO_HAN" 该成了 "小帅哥进来玩呀",但你又说了这个又有什么用,我的哥,T.T
好吧我给你解释

这个就像你去数据库查询一个东西,我拿ID去查NAME,String就是返回的UUID,我查询到名字<NAME>字段,return 数据库查询到的名字,这个是根据业务需求来更改的.

来下一个节点 doOnNext

.doOnNext(new Action1<String>() {
                  @Override
                  public void call(String string) {
                    //在这里处理
                  }
              })

这个节点就是暂时把数据暴露给你,让你存储,或者其它操作0.0

//Schedulers.newThread()是相当于new 了一个子线程
//Schedulers.io()在IO线程运行

.subscribeOn(Schedulers.newThread())//请求在新的线程中执行
                      .observeOn(Schedulers.io())  
//切回主线程
                     .observeOn(AndroidSchedulers.mainThread())

RXJAVA入门到此结束,0.0,结束啦,来来来挤一挤挤一挤,下一个讲retrofit,

作者XINHAO_HAN,谢谢大家支持~~~

RXJAVA的使用

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读