RxJava快速入门

时间 2019-11-17

标签 rxjava 快速入门栏目 Java 繁體版

原文原文链接

前言

相信各位看官对RxJava早有耳闻，那么关于什么是RxJava我就再也不赘述了，不知道的可自行百度。若是你已经大体了解过什么是RxJava，想开始学习，那么本文不失为你良好的选择，为何这么说呢，由于我也是刚学几天，正所谓“知己知彼，百战不殆”。网上流传，RxJava的入门门槛高，而通过我这几天的学习，我反而不那么认为，精通我不敢说，但入门确实也不难，不信？我先来个简单的例子预热一下。数据库

先建立个数据发射源,很好理解，就是发射数据用的：异步

Observable<String> sender = Observable.create(new Observable.OnSubscribe<String>() {

           @Override
            public void call(Subscriber<? super String> subscriber) {

                subscriber.onNext("Hi，Weavey！");  //发送数据"Hi，Weavey！"
            }
        });

再建立个数据接收源，同理，接收数据用的：ide

Observer<String> receiver = new Observer<String>() {

            @Override
            public void onCompleted() {

                //数据接收完成时调用
            }

            @Override
            public void onError(Throwable e) {

                //发生错误调用
            }

            @Override
            public void onNext(String s) {

               //正常接收数据调用
                System.out.print(s);  //将接收到来自sender的问候"Hi，Weavey！"
            }
        };

好了，将发射源和接收源关联起来：post

sender.subscribe(receiver);

这样就造成RxJava一个简单的用法，sender发射"Hi，Weavey！"，将会被receiver的onNext的接收，经过这个例子，也许你会想到“异步”、“观察者模式”，没错，这些都是RxJava所作的事情，而且让他们变得更简单和简洁，而RxJava全部的一切都将围绕这两个点展开，一个是发射数据，一个是接收数据，是否是很通俗易懂？若是你理解了这点或者你已经知道RxJava就是这么一回事，那么恭喜你，你已经一只脚跨进RxJava的大门了，若是不是！！！！那也无所谓，请继续往下看...学习

论概念的重要性

网上关于RxJava的博文也有不少，我也看过许多，其中不乏有优秀的文章，但绝大部分文章都有一个共同点，就是侧重于讲RxJava中各类强大的操做符，而忽略了最基本的东西——概念，因此一开始我也看的一脸懵逼，看到后面又忘了前面的，脑子里全是问号，这个是什么，那个又是什么，这两个长得怎么那么像。举个不太恰当的例子，概念之于初学者，就像食物之于人，当你饿了，你会想吃面包、牛奶，那你为何不去吃土呢，由于你知道面包牛奶是用来干吗的，土是用来干吗的。同理，前面已经说过，RxJava无非是发送数据与接收数据，那么什么是发射源，什么是接收源，这就是你应该明确的事，也是RxJava的入门条件之一，下面就依我我的理解，对发射源和接收源作个归类，以及RxJava中频繁出现的几个“单词”解释一通，说的很差还请海涵，欢迎补充。spa

基本概念

Observable：发射源，英文释义“可观察的”，在观察者模式中称为“被观察者”或“可观察对象”；code

Observer：接收源，英文释义“观察者”，没错！就是观察者模式中的“观察者”，可接收Observable、Subject发射的数据；orm

Subject：Subject是一个比较特殊的对象，既可充当发射源，也可充当接收源，为避免初学者被混淆，本章将不对Subject作过多的解释和使用，重点放在Observable和Observer上，先把最基本方法的使用学会，后面再学其余的都不是什么问题；server

Subscriber：“订阅者”，也是接收源，那它跟Observer有什么区别呢？Subscriber实现了Observer接口，比Observer多了一个最重要的方法unsubscribe( )，用来取消订阅，当你再也不想接收数据了，能够调用unsubscribe( )方法中止接收，Observer 在 subscribe() 过程当中,最终也会被转换成 Subscriber 对象，通常状况下，建议使用Subscriber做为接收源；对象

Subscription ：Observable调用subscribe( )方法返回的对象，一样有unsubscribe( )方法，能够用来取消订阅事件；

Action0：RxJava中的一个接口，它只有一个无参call（）方法，且无返回值，一样还有Action1，Action2...Action9等，Action1封装了含有 1 个参的call（）方法，即call（T t），Action2封装了含有 2 个参数的call方法，即call（T1 t1，T2 t2），以此类推；

Func0：与Action0很是类似，也有call（）方法，可是它是有返回值的，一样也有Func0、Func1...Func9;

基本用法

Observable的建立
1.使用create( ),最基本的建立方式：

normalObservable = Observable.create(new Observable.OnSubscribe<String>() {
  @Override
  public void call(Subscriber<? super String> subscriber) {
      subscriber.onNext("create1"); //发射一个"create1"的String
      subscriber.onNext("create2"); //发射一个"create2"的String
      subscriber.onCompleted();//发射完成,这种方法须要手动调用onCompleted，才会回调Observer的onCompleted方法
  }});

2.使用just( )，将为你建立一个Observable并自动为你调用onNext( )发射数据：

justObservable = Observable.just("just1","just2");//依次发送"just1"和"just2"

3.使用from( )，遍历集合，发送每一个item：

List<String> list = new ArrayList<>();
list.add("from1");
list.add("from2");
list.add("from3");
fromObservable = Observable.from(list);  //遍历list 每次发送一个
/** 注意，just()方法也能够传list，可是发送的是整个list对象，而from（）发送的是list的一个item** /

4.使用defer( )，有观察者订阅时才建立Observable，而且为每一个观察者建立一个新的Observable：

deferObservable = Observable.defer(new Func0<Observable<String>>() {
  @Override
  //注意此处的call方法没有Subscriber参数
  public Observable<String> call() {
      return Observable.just("deferObservable");
  }});

5.使用interval( ),建立一个按固定时间间隔发射整数序列的Observable，可用做定时器：

intervalObservable = Observable.interval(1, TimeUnit.SECONDS);//每隔一秒发送一次

6.使用range( ),建立一个发射特定整数序列的Observable，第一个参数为起始值，第二个为发送的个数，若是为0则不发送，负数则抛异常：

rangeObservable = Observable.range(10, 5);//将发送整数10，11，12，13，14

7.使用timer( ),建立一个Observable，它在一个给定的延迟后发射一个特殊的值，等同于Android中Handler的postDelay( )方法：

timeObservable = Observable.timer(3, TimeUnit.SECONDS);  //3秒后发射一个值

8.使用repeat( ),建立一个重复发射特定数据的Observable:

repeatObservable = Observable.just("repeatObservable").repeat(3);//重复发射3次

Observer的建立

mObserver = new Observer<String>() {
  @Override
  public void onCompleted() {
      LogUtil.log("onCompleted");
  }
  @Override
  public void onError(Throwable e) {
  }
  @Override
  public void onNext(String s) {
      LogUtil.log(s);
  }};

ok，有了Observable和Obsever，咱们就能够随便玩了，任取一个已建立的Observable和Observer关联上，即造成一个RxJava的例子，如：

justObservable.subscribe(mObserver);

mObserver的onNext方法将会依次收到来自justObservable的数据"just1"、"just2"，另外，若是你不在乎数据是否接收完或者是否出现错误，即不须要Observer的onCompleted()和onError()方法，可以使用Action1，subscribe()支持将Action1做为参数传入,RxJava将会调用它的call方法来接收数据，代码以下：

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

          LogUtil.log(s);
     }});

以上就是RxJava最简单的用法。看到这里，我也不知道我写的是否简单明了，也许你会想，“哎呀，写个异步的东西，怎么这么麻烦，为何不用Thread+Handler呢”,那你就错了，RxJava也以代码的简洁深受广大用户喜好，简洁不能理解为代码量少，而是随着逻辑的复杂，需求的更改，代码可依然能保持极强的阅读性，举个简单的例子（前方高能预警~~~），领导要我从数据库的用户表查找出全部用户数据，我二话不说拿出心仪的RxJava就写：

Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //从数据库获取用户表数据并赋给userList
              ···
              subscriber.onNext(userList);
          }
      }).subscribe(new Action1<List<User>>() {
          @Override
          public void call(List<User> users) {

              //获取到用户信息列表
          }
      });

可是，领导忽然又不想要全部用户了，只要名字叫“小明”的用户，行吧，领导最大，我改（假设名字惟一）：

Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //从数据库获取用户表数据并赋给userList
              ···
              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>() {
          @Override
          public Boolean call(User user) {
              return user.getName().equals("小明");
          }
      }).subscribe(new Action1<User>() {
          @Override
          public void call(User user) {
              //拿到谜之小明的数据
          }
      });

搞定，这时候领导又说，我不要小明了，我要小明的爸爸的数据，（坑爹啊~~），我继续改：

Observable.create(new Observable.OnSubscribe<List<User>>() {
          @Override
          public void call(Subscriber<? super List<User>> subscriber) {
              List<User> userList = null;
              ···
              //从数据库获取用户表数据并赋给userList
              ···
              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>() {
          @Override
          public Boolean call(User user) {
              return user.getName().equals("小明");
          }
      }).map(new Func1<User, User>() {
          @Override
          public User call(User user) { 
              //根据小明的数据user从数据库查找出小明的父亲user2
              return user2;
          }
      }).subscribe(new Action1<User>() {
          @Override
          public void call(User user2) {
            //拿到谜之小明的爸爸的数据
          }
      });

搞定，“还想怎么改？领导请说···”。
以上例子，涉及到几个操做符，初学者可能没法理解，可是无所谓，这不是重点，个人目的只是为了向你展现RxJava在需求不断变动、逻辑越发复杂的状况下，依旧能够保持代码简洁、可阅读性强的一面，没有各类回调，也没有谜之缩进！

参考博客：
我所理解的RxJava——上手其实很简单（一）
http://www.jianshu.com/p/5e93c9101dc5
我所理解的RxJava——上手其实很简单（二）
http://www.jianshu.com/p/240f1c8ebf9d
我所理解的RxJava——上手其实很简单（三）
http://www.jianshu.com/p/5c221c58e141

1. ES6快速入门 ES6 快速入门
2. 快速入门
3. RxJava入门
4. RxJava 入门
5. Rxjava入门
6. Hadoop快速入门
7. Sqoop 快速入门
8. Shell快速入门
9. vim快速入门
10. jQuery快速入门
更多相关文章...
• SQL 快速参考 - SQL 教程
• Eclipse 快速修复 - Eclipse 教程
• YAML 入门教程
• Java Agent入门实战（一）-Instrumentation介绍与使用

RxJava快速入门

前言

论概念的重要性

基本概念

基本用法

参考博客：