RxJava初识

最新推荐文章于 2021-02-20 01:33:18 发布

小黄鸡

最新推荐文章于 2021-02-20 01:33:18 发布

阅读量310

点赞数

分类专栏：零散备忘文章标签： RxJava Android

本文链接：https://blog.csdn.net/SImple_a/article/details/78906432

版权

零散备忘专栏收录该内容

53 篇文章 0 订阅

订阅专栏

参考自这个人的博客

添加RxJava的依赖

compile 'io.reactivex:rxjava:1.3.4'

1 基本用法

1.1 创建发送源

Observable<String> sender;

sender = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello World!");
            }
        });

1.2 创建接受者

Observer<String> receiver = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG,"onComplete");
            }

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

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

1.3 发送源和接收者相关联

 sender.subscribe(receiver);

执行这段代码后将会看到打印结果

TAG-MainActivity: onNext:Hello World!

1.4 onComplete需要手动调用才会执行

 subscriber.onNext("Hello World!");
 subscriber.onCompleted();

打印结果

 I/TAG-MainActivity: onNext:Hello World!
 I/TAG-MainActivity: onComplete

2 创建发射源的其他方法

2.1 just 发送多个对象

sender = Observable.just("hello1","hello2");

打印结果

I / TAG - MainActivity:onNext:hello1
I / TAG - MainActivity:onNext:hello2
I / TAG - MainActivity:onComplete

2.2 from 发送一个集合

 List<String> list = new ArrayList<>();
 list.add("from1");
 list.add("from2");
 list.add("from3");
 sender  = Observable.from(list);

打印结果

 I/TAG-MainActivity: onNext:from1
 I/TAG-MainActivity: onNext:from2
 I/TAG-MainActivity: onNext:from3
 I/TAG-MainActivity: onComplete

2.3 defer

 sender = Observable.defer(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                Log.i(TAG, "再发射");
                return Observable.just("deferObserable");
            }
        });

 Log.i(TAG, "先订阅");
 sender.subscribe(receiver);

打印结果

I/TAG-MainActivity: 先订阅
I/TAG-MainActivity: 再发射
I/TAG-MainActivity: onNext:deferObserable
I/TAG-MainActivity: onComplete

可以看到，只有当订阅的时候，才会发送数据。

3 定期执行

3.1 interval

每隔一段时间执行一次onNext();

 Subscriber subscriber = new Subscriber<Long>() {
          @Override
          public void onCompleted() {
              Log.i(TAG, "onComplete");
          }

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

          @Override
          public void onNext(Long aLong) {
              Log.i(TAG, "onNext:" + "aLong = "+aLong);
          }
      };

Observable.interval(1, TimeUnit.SECONDS).subscribe(subscriber);

打印结果

I/TAG-MainActivity: onNext:aLong = 0
I/TAG-MainActivity: onNext:aLong = 1
I/TAG-MainActivity: onNext:aLong = 2
I/TAG-MainActivity: onNext:aLong = 3
I/TAG-MainActivity: onNext:aLong = 4

3.2 range

从20 开始每次累加1 一直到25

Subscriber subscriber = new Subscriber<Integer>() {
          @Override
          public void onCompleted() {
              Log.i(TAG, "onComplete");
          }

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

          @Override
          public void onNext(Integer integer) {
              Log.i(TAG, "onNext:" + "integer = "+integer);
          }
      };

Observable.range(20,5).subscribe(subscriber);

打印结果

I/TAG-MainActivity: onNext:integer = 20
I/TAG-MainActivity: onNext:integer = 21
I/TAG-MainActivity: onNext:integer = 22
I/TAG-MainActivity: onNext:integer = 23
I/TAG-MainActivity: onNext:integer = 24

3.3 timer

Observable.timer(5, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onComplete");
            }

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

            @Override
            public void onNext(Long aLong) {
                Log.i(TAG, "onNext:" + "aLong = " + aLong);
            }
        });

5秒后打印结果

I/TAG-MainActivity: onNext:aLong = 0
I/TAG-MainActivity: onComplete

3.4 repeat

重复调用onNext() 每次以just里面的内容作为onNext()方法的参数

Observable.just(1,5,6).repeat(3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onComplete");
            }

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

            @Override
            public void onNext(Integer str) {
                Log.i(TAG, "onNext:" + "str = " + str);
            }
        });

	I/TAG-MainActivity: onNext:str = 1
    I/TAG-MainActivity: onNext:str = 5
    I/TAG-MainActivity: onNext:str = 6
    I/TAG-MainActivity: onNext:str = 1
    I/TAG-MainActivity: onNext:str = 5
    I/TAG-MainActivity: onNext:str = 6
    I/TAG-MainActivity: onNext:str = 1
    I/TAG-MainActivity: onNext:str = 5
    I/TAG-MainActivity: onNext:str = 6
    I/TAG-MainActivity: onComplete

4 链式调用

初始化数据

public class User {
    String name;
    User father;

    public User getFather() {
        return father;
    }

    public void setFather(User father) {
        this.father = father;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

		userList = new ArrayList<>();
        User user1 = new User();
        User father = new User();
        father.setName("李刚");

        user1.setName("小明");
        user1.setFather(father);

        User user2 = new User();
        user2.setName("小红");

        userList.add(user1);
        userList.add(user2);

4.1 调用subcriber.onNext() 使用数据

Observable.create(new Observable.OnSubscribe<List<User>>() {

            @Override
            public void call(Subscriber<? super List<User>> subscriber) {
                subscriber.onNext(userList); //     1计算出的集合
            }
        }).subscribe(new Action1<List<User>>() { // 2使用这个集合
            @Override
            public void call(List<User> users) {
                Log.i(TAG,users.toString());
            }
        });

打印结果

I/TAG-MainActivity: [User{name='小明'}, User{name='小红'}]

4.2 筛选数据

Observable.create(new Observable.OnSubscribe<List<User>>() {
            @Override
            public void call(Subscriber<? super List<User>> subscriber) { //1 计算出一个集合
                subscriber.onNext(userList);
            }
        }).flatMap(new Func1<List<User>, Observable<User>>() {
            @Override
            public Observable<User> call(List<User> users) {
                return Observable.from(users);
            }
        }).filter(new Func1<User, Boolean>() {                          //3 筛选这个集合
            @Override
            public Boolean call(User user) {
                return user.getName().equals("小明");
            }
        }).subscribe(new Action1<User>() {                              //4 拿到筛选结果
            @Override
            public void call(User user) {
                Log.i(TAG,"user = "+user);
            }
        });

打印结果

I/TAG-MainActivity: user = User{name='小明'}

4.3 多次筛选

Observable.create(new Observable.OnSubscribe<List<User>>() {
            @Override
            public void call(Subscriber<? super List<User>> subscriber) {  //1 计算出的集合
                subscriber.onNext(userList);
            }
        }).flatMap(new Func1<List<User>, Observable<User>>() {             //2
            @Override
            public Observable<User> call(List<User> users) {
                return Observable.from(users);
            }
        }).filter(new Func1<User, Boolean>() {                             //3 删选这个集合
            @Override
            public Boolean call(User user) {
                return user.getName().equals("小明");
            }
        }).map(new Func1<User, User>() {                                   //4 根据筛选结果 再次拿到匹配结果
            @Override
            public User call(User user) {
                if (user.getFather().getName().equals("李刚")) {
                    return user.getFather();
                }
                return null;
            }
        }).subscribe(new Action1<User>() {                                 //5 拿到最终结果
            @Override
            public void call(User user) {
                Log.i(TAG, "father = " + user);
            }
        });

打印结果

I/TAG-MainActivity: father = User{name='李刚'}

5 订阅前与订阅后数据接收问题

5.1 AsyncSubject

需要手动调用onComplete，只接收onComplete调用后的前一个数据。如果不调用onComplete，将不接收任何数据

AsyncSubject<String> asyncSubject = AsyncSubject.create();
        asyncSubject.onNext("asyncSubject1");
        asyncSubject.onNext("asyncSubject2");
        asyncSubject.onNext("asyncSubject3");

        asyncSubject.onCompleted();
        asyncSubject.subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

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

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

打印结果

I/TAG-MainActivity: onNext = asyncSubject3
I/TAG-MainActivity: onCompleted

5.2 BehaviorSubject

只接收订阅之前的最后一个数据，再接收其他的数据。
// 如果订阅之前没有发布任何数据，则收到一个默认的数据。

 private void bahaviorSubject() {
        BehaviorSubject<String> behaviorSubject = BehaviorSubject.create("default");
        behaviorSubject.onNext("behaviorSubject1");
        behaviorSubject.onNext("behaviorSubject2");

        behaviorSubject.subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

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

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

        behaviorSubject.onNext("behaviorSubject3");
        behaviorSubject.onNext("behaviorSubject4");
    }

打印结果

	    I/TAG-MainActivity: onNext = behaviorSubject2
        I/TAG-MainActivity: onNext = behaviorSubject3
        I/TAG-MainActivity: onNext = behaviorSubject4

5.3 PublishSubject

只能接受到发布之后的

 private void publishSubject() {
        PublishSubject publishSubject = PublishSubject.create();
        publishSubject.onNext("publishSubject1");
        publishSubject.onNext("publishSubject2");
        publishSubject.subscribe(new Observer() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

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

            @Override
            public void onNext(Object o) {
                Log.i(TAG, "onNext" + o.toString());
            }
        });

        publishSubject.onNext("publishSubject3");
        publishSubject.onNext("publishSubject4");
    }

打印结果

		I/TAG-MainActivity: onNextpublishSubject3
        I/TAG-MainActivity: onNextpublishSubject4

5.4 ReplaySubject 只能接受到发布之后的

不论ReplaySubject何时被订阅，Obsver都能接收到数据

private void replaySubject() {

        //创建默认初始容量大小为16的ReplaySubject,当数据条目超过16会重新分配内存空间。
        ReplaySubject<String> replaySubject = ReplaySubject.create();

        //创建指定初始容量为为100的ReplaySubject
        //replaySubject = ReplaySubject.create(100);

        只接收订阅前最后发送的两条数据
        //replaySubject = ReplaySubject.createWithSize(2);

        //replaySubject被订阅的前一秒内发送的数据才能被接收
        //replaySubject = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, Schedulers.computation());
        
        replaySubject.onNext("replaySubject: pre subscribe 1");
        replaySubject.onNext("replaySubject: pre subscribe 2");
        replaySubject.onNext("replaySubject: pre subscribe 3");

        replaySubject.subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "replaySubject  " + s);
            }
        });

        replaySubject.onNext("replaySubject: after subscribe 1");
        replaySubject.onNext("replaySubject: after subscribe 2");
    }

打印结果

I/TAG-MainActivity: replaySubject  replaySubject: pre subscribe 1
I/TAG-MainActivity: replaySubject  replaySubject: pre subscribe 2
I/TAG-MainActivity: replaySubject  replaySubject: pre subscribe 3
I/TAG-MainActivity: replaySubject  replaySubject: after subscribe 1
I/TAG-MainActivity: replaySubject  replaySubject: after subscribe 2