Weavey's Blog

我所理解的RxJava——上手其实很简单(三)

前言

最近诸事缠身,有点忙,终于抽出时间&&有兴致写第三了,有一股深深的罪恶感,废话不多说,还是直接接上篇的活了,讲一讲一些比较常用的操作符吧。然后这篇讲RxJava中强大的Scheduler调度器 ,就是因为它,RxJava才能极其简便的在线程中切换,接着再讲一讲一些常用的操作符,比较简单容易理解的操作符都在本篇罗列出来,以后可能不定时更新这篇文章,复杂的操作符后续分篇讲。

Scheduler

在讲常用操作符前,先看看Scheduler这个东西,名之为调度器,正因为有这个东西,让RxJava可以从主线程和子线程之间轻松切换,各个Scheduler的具体使用效果看以下解释:

Schedulers.computation( )

用于计算任务,如事件循环或和回调处理,不要用于IO操作(IO操作请使用Schedulers.io());默认线程数等于处理器的数量;

Schedulers.from(executor)

使用指定的Executor作为调度器;

Schedulers.immediate( )

在当前线程立即开始执行任务;

Schedulers.io( )

用于IO密集型任务,如异步阻塞IO操作,这个调度器的线程池会根据需要增长;对于普通的计算任务,请使用Schedulers.computation();Schedulers.io( )默认是一个CachedThreadScheduler,很像一个有线程缓存的新线程调度器;

Schedulers.newThread( )

为每个任务创建一个新线程;

Schedulers.trampoline( )

当其它排队的任务完成后,在当前线程排队开始执行;

AndroidSchedulers.mainThread()

此调度器为RxAndroid特有,顾名思义,运行在Android UI线程上。

具体如何使用呢,比如从数据库读取数据更新到UI上,假设数据量很大,直接从主线程读取数据,会造成UI卡顿,以前我们常用AnsyTask或者Handler去处理避免出现这类问题,个人认为手写个AnsyTask还是挺麻烦的,但用RxJava就简单多了,例如:

Observable.create(new Observable.OnSubscribe<Data>() {

    @Override
    public void call(Subscriber<? super Data> subscriber) {
        Data data = getData();//从数据库获取
        subscriber.onNext(data);
        subscriber.onCompleted();
    }})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Data>() {
        @Override
        public void call(Data data) {
                //更新ui
        }
    });

简单粗暴的解释一下,subscribeOn( )决定了发射数据在哪个调度器上执行,observeOn(AndroidSchedulers.mainThread())则指定数据接收发生在UI线程,简直不要太方便。

常用操作符

Map

最常用且最实用的操作符之一,将对象转换成另一个对象发射出去,应用范围非常广,如数据的转换,数据的预处理等。

例一:数据类型转换,改变最终的接收的数据类型。假设传入本地图片路径,根据路径获取图片的Bitmap。

Observable.just(filePath).map(new Func1<String, Bitmap>() {
@Override
public Bitmap call(String path) {
    return getBitmapByPath(path);
}}).subscribe(new Action1<Bitmap>() {
@Override
public void call(Bitmap bitmap) {
    //获取到bitmap,显示
}});

例二:对数据进行预处理,最后得到理想型数据。实际开发过程中,从后台接口获取到的数据也许不符合我们想要的,这时候可以在获取过程中对得到的数据进行预处理(结合Retrofit)。

Observable.just("12345678").map(new Func1<String, String>() {
@Override
public String call(String s) {
    return s.substring(0,4);//只要前四位
}})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
    Log.i("mytag",s);
}});

先说明一下,为了方便理解,所以写的例子都比较简单,不要以为明明可以简单用if-else解决的事,没必要用这种方式去写,当你真正将这些操作符使用到数据处理中去的时候,你就会发现有多方便。

FlatMap

和Map很像但又有所区别,Map只是转换发射的数据类型,而FlatMap可以将原始Observable转换成另一个Observable。还是举例说明吧。假设要打印全国所有学校的名称,可以直接用Map,
为了更清晰一点,先贴一下School类:

public class School {

private String name;
private List<Student> studentList;

public List<Student> getStudentList() {
    return studentList;
}    
public void setStudentList(List<Student> studentList) {
    this.studentList = studentList;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

public static class Student{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
        }
      }
}

接着用Map打印学校名称:

List<School> schoolList = new ArrayList<>();
Observable.from(schoolList).map(new Func1<School, String>() {
@Override
public String call(School school) {
      return school.getName();
}}).subscribe(new Action1<String>() {
@Override
public void call(String schoolName) {
      Log.i("mytag",schoolName);
}});

再进一步,打印学校所有学生的姓名,先考虑用Map实现,将所有School对象直接转成Student:

Observable.from(schoolList).map(new Func1<School, School.Student>() {
@Override
public School.Student call(School school) {
    return school.getStudentList();
}}).subscribe(new Action1<School.Student>() {
@Override
public void call(School.Student student) {

        Log.i("mytag",student.getName());
}});

看似可行,但事实上,这是一段错误的代码,细心的人就会发现错误的地方

@Override
public School.Student call(School school) {
    return school.getStudentList();  //错误,Student 是一个对象,返回的却是一个list
}

所以用Map是无法实现直接打印学校的所有学生名字的,因为Map是一对一的关系,无法将单一的School对象转变成多个Student。前面说到,FlatMap可以改变原始Observable变成另外一个Observable,如果我们能利用from()操作符把school.getStudentList()变成另外一个Observable问题不就迎刃而解了吗,这时候就该FlatMap上场了,来看看它是怎么实现的:

Observable.from(schoolList).flatMap(new Func1<School, Observable<School.Student>>() {
@Override
public Observable<School.Student> call(School school) {

    return Observable.from(school.getStudentList()); //关键,将学生列表以另外一个Observable发射出去

}}).subscribe(new Action1<School.Student>() {

@Override
public void call(School.Student student) {
    Log.i("mytag",student.getName());
}});

Map和FlatMap在我看来就像孪生兄弟一样,非常实用,实际开发中也我也经常使用,个人觉得要想上手RxJava,掌握这两个操作符必不可少。

Buffer

缓存,可以设置缓存大小,缓存满后,以list的方式将数据发送出去,例:

Observable.just(1,2,3).buffer(2).subscribe(new Action1<List<Integer>>() {
    @Override
    public void call(List<Integer> list) {
        Log.i("mytag","size:"+list.size());
    }});

运行打印结果如下:

11-02 20:49:58.370 23392-23392/? I/mytag: size:2
11-02 20:49:58.370 23392-23392/? I/mytag: size:1

在开发当中,个人经常将Buffer和Map一起使用,常发生在从后台取完数据,对一个List中的数据进行预处理后,再用Buffer缓存后一起发送,保证最后数据接收还是一个List,如下:

List<School> schoolList = new ArrayList<>();
Observable.from(schoolList).map(new Func1<School, School>() {
@Override
public School call(School school) {
    school.setName("NB大学");  //将所有学校改名
    return school;
}}).buffer(schoolList.size())  //缓存起来,最后一起发送
.subscribe(new Action1<List<School>>() {
    @Override
    public void call(List<School> schools) {
}});

Take

发射前n项数据,还是用上面的例子,假设不要改所有学校的名称了,就改前四个学校的名称:

Observable.from(schoolList).take(4).map(new Func1<School, School>() {
@Override
public School call(School school) {
    school.setName("NB大学");
    return school;
}}).buffer(4).subscribe(new Action1<List<School>>() {

@Override
public void call(List<School> schools) {

}});

Distinct

去掉重复的项,比较好理解:

Observable.just(1, 2, 1, 1, 2, 3)
    .distinct()
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer item) {
            System.out.println("Next: " + item);
        }
    });

输出

Next: 1
Next: 2
Next: 3

Filter

过滤,通过谓词判断的项才会被发射,例如,发射小于4的数据:

Observable.just(1, 2, 3, 4, 5).filter(new Func1<Integer, Boolean>() {
        @Override
        public Boolean call(Integer item) {
            return( item < 4 );
        }
    }).subscribe(new Action1<Integer>() {
      @Override
      public void call(Integer item) {
            System.out.println("Next: " + item);
  }});

输出:

Next: 1
Next: 2
Next: 3

这一篇就先讲这么多吧,重点掌握Map和FlatMap操作符,因为真的很实用、很实用、很实用,重要的事讲三遍。

后语

其实,讲真,到现在RxJava已经非常普遍,用的人很多,网上的干货也很多,写这几篇文章呢,除了帮助想开始学RxJava的新手入门,最重要的还是起到一个笔记的作用吧,好记性不如烂笔头,这是真的。好吧,这篇就写这么多了,欢迎指出问题,互相交流学习。

Weavey wechat
欢迎扫一扫上面的微信公众号,订阅我的博客!
坚持原创技术分享,您的支持将鼓励我继续创作!

热评文章