RxJava 使用总结

RxJava

What ? (RxJava)

一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。主要用来解决异步操作。

How ?(RxJava)

• 相关概念
  观察者（Observer、Subscriber）
  被观察者（Observable）
  订阅(subscribe)
    RxJava是一种观察者模式，被观察者和观察者进行订阅之后，如果被观察者发出了动作，那么会触发观察者。
• 创建被观察者的方式
  Observable.create()
  Observable.just()
  Observable.from()
• 创建观察者的方式
  new Observer(){…}
  new Subscriber(){…}
• 订阅方式
  observable.subscribe(observer)
  observable.subscribe(subscriber)
• 使用方式

//普通用法
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
                subscriber.onStart();//执行之前
                subscriber.onNext("");//执行  
                subscriber.onCompleted();//执行结束  
                //方法和onComplete()方法为互斥，只能执行一个    
                //subscriber.onError(new Throwable());

    }
});

//进阶用法
Observable.just("")
    .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程
    .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
    .subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer num) {
            Log.d("TAG", "num------>" + num);
        }
    });

• 操作符（神奇之处）

//---------------map 将一个对象转换为另一个对象---------------

 Observable.just("1")
                .map(new Func1<String, Integer>() {
                    @Override
                    public Integer call(String s) {
                        return Integer.parseInt(s);
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i("TAG","s---->"+integer);
                    }
                });

//---------------flatMap 接收一个Observable的输出作为输入，同时输出另外一个Observable---------------
 ArrayList<List<String>> datas = new ArrayList<>();
        Observable.from(datas)
                .flatMap(new Func1<List<String>, Observable<String>>() {
                    @Override
                    public Observable<String> call(List<String> strings) {
                        return Observable.from(strings);
                    }
                })
                .subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.i("TAG","--onCompleted------->");
                    }

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

                    @Override
                    public void onNext(String str) {
                        Log.i("TAG","--onNext------>"+str);
                    }
                });

//---------------filter 进行过滤满足的条件，否则终止向下执行---------------
Observable.just("")
                .filter(new Func1<String, Boolean>() {
                    @Override
                    public Boolean call(String s) {
                        return null != null;
                    }
                })
                .subscribe(new Subscriber<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);
                    }
                });

//---------------compose 进行某一功能的统一处理---------------
Observable.just("1")
                .compose(new Observable.Transformer<String, Integer>() {
                    @Override
                    public Observable<Integer> call(Observable<String> stringObservable) {
                        return stringObservable.map(new Func1<String, Integer>() {
                            @Override
                            public Integer call(String s) {
                                return Integer.parseInt(s);
                            }
                        }).filter(new Func1<Integer, Boolean>() {
                            @Override
                            public Boolean call(Integer integer) {
                                return integer.compareTo(0) > 0;
                            }
                        });
                    }
                })
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {
                        Log.i("TAG", "onCompleted----->");
                    }

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

                    @Override
                    public void onNext(Integer s) {
                        Log.i("TAG", "onNext----->" + s);
                    }
                });

//---------------skip(跳到某一位置) take(获取多少位数据)---------------
ArrayList<String> datas=new ArrayList<>();
        Observable.just(datas)
                .skip(2)
                .take(2)
                .subscribe(new Subscriber<ArrayList<String>>() {
                    @Override
                    public void onCompleted() {
                        Log.i("TAG", "onCompleted----->");
                    }

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

                    @Override
                    public void onNext(ArrayList<String> s) {
                        Log.i("TAG", "onNext----->" + s.toString());
                    }
                });

• 操作符总结

Observable.map() 
    ------->处理数据操作
    ------->把一个事件转换为另一个事件
    ------->用于变换Observable对象
Observable.flatMap()
    ------->接收一个Observable的输出作为输入，同时输出另外一个Observable
Observable.filter()
    ------->过滤结果
Observable.take()
    ------->输出最多指定数量的结果
Observable.skipe()
    ------->跳到某一个位置开始执行
Observable.doOnNext()
    ------->输出之前做的操作
Observable.subscribeOn(Schedulers.io())
    ------->观察者运行的线程
Observable.observeOn(AndroidSchedulers.mainThread())
    ------->订阅者运行的线程
注意：
1.Observable和Subscriber可以做任何事情
2.Observable和Subscriber是独立于中间的变换过程的
3.RxJava的强大性就来自于它所定义的操作符

Why ？ （RxJava）

• 异步操作
• 逻辑清晰