Rxjava简单学习

来源：互联网发布：linux useradd命令编辑：程序博客网时间：2024/05/29 15:16

Rxjava简单学习

1.什么是Rxjava？
2.为什么使用Rxjava？
3.怎么使用Rxjava？
4.Rxjava的延伸

什么是Rxjava

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.
（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）

asynchronous：异步
event-based：事件
observable：观察者
sequences：序列

asynchronous：Schedulers 线程的调度！
event-based ：事件 Observable观察者
observable： RxJava Observable类源自于经典的Gang Of Four的观察者模式。
不同之处：
1. 生产者在没有更多数据可用时能够发出信号通知：onCompleted()事件。
2. 生产者在发生错误时能够发出信号通知：onError()事件。
3. RxJava Observables 能够组合而不是嵌套，从而避免开发者陷入回调地狱。
sequences：流畅，逻辑风格清晰。

Observable.from(folders)    .flatMap(new Func1<File, Observable<File>>() {        @Override        public Observable<File> call(File file) {            return Observable.from(file.listFiles());        }    })    .filter(new Func1<File, Boolean>() {        @Override        public Boolean call(File file) {            return file.getName().endsWith(".png");        }    })    .map(new Func1<File, Bitmap>() {        @Override        public Bitmap call(File file) {            return getBitmapFromFile(file);        }    })    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe(new Action1<Bitmap>() {        @Override        public void call(Bitmap bitmap) {            imageCollectorView.addImage(bitmap);        }    });

为什么要使用Rxjava

举个栗子

public class SampleTask extends AsyncTask<Void,Void,List<Users>> {    private final SampleAdapter mAdapter;    public SampleTask(SampleAdapter sampleAdapter) {        mAdapter = sampleAdapater;    }    @Override    protected List<Users> doInBackground(Void... voids) {        //fetch there results from the database and return them to the onPostExecute        List<Users> users = getUsersFromDatabase();        return users;    }    @Override    protected void onPostExecute(List<Users> users) {        super.onPostExecute(products);        // Checking if there are users on the database        if(users == null) {            //No users, presenting a view saying there are no users            showEmptyUsersMessageView();            return;        }        for(User user : users){            mAdapter.add(user);        }        mAdapter.notifyDataSetChanged();    }}

public Observable<List<User>> fetchUsersFromDatabase() {    return Observable.create(new Observable.OnSubscribe<List<User>(){        @Override        public void call(Subscriber<? super List<User>> subscriber){            // Fetch information from database            subscriber.onNext(getUserList());            subscriber.onCompleted();        }    });}

fetchUsersFromDatabase().subscribeOn(Schedulers.io())//will process everything in a new thread.observeOn(AndroidSchedulers.mainThread())//will listen the results on the main thread.subscribe(new Subscriber<List<User>>() {           @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(List<User> users) {                //Do whatever you want with each user            }        });

fetchUsersFromDatabase()        .filter(new Func1<User, Boolean>() {            @Override            public Boolean call(User user) {                //only return the users which are not guests                return !user.isGuest();            }        })        .subscribeOn(Schedulers.io())        .observeOn(AndroidSchedulers.mainThread())        .subscribe(new Subscriber<User>() {                       @Override                       public void onCompleted() {                       }                       @Override                       public void onError(Throwable e) {                           /*Check if there was any error while retrieving from database*/                       }                       @Override                       public void onNext(User user) {                           //Do whatever you want with each user                       }                   }        );

怎么使用Rxjava

在RxJava的世界里，有四种角色：

Observable ：可观察的
Observer : 观察者
Subscriber ：订阅者
Subjects ：被试者

Observables和Subjects是两个“生产”实体，Observers和Subscribers是两个“消费”实体。

操作符

Creating Observables
Range:操作符根据出入的初始值n和数目m发射一系列大于等于n的m个值

private Observable<Integer> rangeObserver() {        return Observable.range(10, 5);}mRButton.setOnClickListener(e -> rangeObserver().subscribe(i -> log(i)));输出：1011121314

Repeat、Timer：
Repeat会将一个Observable对象重复发射，我们可以指定其发射的次数

private Observable<Integer> repeatObserver() {    return Observable.just(1).repeat(5);}private Observable<Long> timerObserver() {    //timer by default operates on the computation Scheduler    return Observable.timer(1, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread());}mLButton.setOnClickListener(e -> repeatObserver().subscribe(i -> log("repeat:" + i)));mRButton.setOnClickListener(e -> timerObserver().subscribe(i -> log("timer:" + i)));输出：repeat:1repeat:1repeat:1repeat:1repeat:1timer:0

Transforming Observables
Scan:对一个序列的数据应用一个函数，并将这个函数的结果发射出去作为下个数据应用这个函数时候的第一个参数使用，有点类似于递归操作

list存放了5个2private Observable<Integer> scanObserver() {        return Observable.from(list).scan((x, y) -> x * y).observeOn(AndroidSchedulers.mainThread());    }mLButton.setOnClickListener(e -> scanObserver().subscribe(i -> log("scan:" + i)));输出：scan:2scan:4scan:8scan:16scan:32

Filtering
Distinct:Distinct操作符的用处就是用来去重，非常好理解。如下图所示，所有重复的数据都会被过滤掉。还有一个操作符distinctUntilChanged,是用来过滤掉连续的重复数据。

private Observable<Integer> distinctObserver() {    return Observable.just(1, 2, 3, 4, 5, 4, 3, 2, 1).distinct();}private Observable<Integer> distinctUntilChangedObserver() {    return Observable.just(1, 2, 3, 3, 3, 1, 2, 3, 3).distinctUntilChanged();}mLButton.setOnClickListener(e -> distinctObserver().subscribe(i -> log("distinct:" + i)));mRButton.setOnClickListener(e -> distinctUntilChangedObserver().subscribe(i -> log("UntilChanged:" + i)));输出：distinct:1distinct:2distinct:3distinct:4distinct:5UntilChanged:1UntilChanged:2UntilChanged:3UntilChanged:1UntilChanged:2UntilChanged:3

输出：

Combining
Error Handling
Utility
Conditional and Boolean条件和布尔操作符
Aggregate聚合操作符
Connectable Observable Operators
自定义操作符

Rxjava的延伸

RxAndroid

RxBinding

rxbinding是一个开源项目,可以实现数据层与View层的绑定，当数据发生变化，View会自动更新UI。

RxLifecycle

RxJava和RxAndroid越来越被人熟知，简洁的语法，代码的结构清晰，通过线程调度器更容易控制和切换线程。但是使用不好，很容易导致内存泄露。Rxlifecycle 就使被用来严格控制由于发布了一个订阅后，由于没有及时取消，导致Activity/Fragment无法销毁导致的内存泄露。

agera

Agera is a set of classes and interfaces to help write functional, asynchronous, and reactive applications for Android.

Requires Android SDK version 9 or higher.

agera是一个能帮助Android开发者更好的开发函数式，异步和响应式程序的框架，要求Android的SDK版本在9以上。

感谢这几篇博客给我提供的帮助
操作符的介绍：http://mushuichuan.com/2015/12/11/rxjava-operator-1/
Rxjava的入门：http://www.jianshu.com/p/3a4fb0cf6533
http://gank.io/post/560e15be2dca930e00da1083

0 0