RxJava的入门和基本使用

导包

在module的gradle中:
    compile "io.reactivex.rxjava2:rxjava:2.0.1"
    compile "io.reactivex.rxjava2:rxandroid:2.0.1"

基本概念

        //使用Observable.create()方法构造一个被观察对象
        Observable<Integer> objectObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                //e.onNext(T)发起事件
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                //结束事件
                e.onComplete();
            }
        });
        //观察者对象,在被观察者发起事件时接收事件
        Observer observer=new Observer<Integer>(){
            //在订阅时调用
            @Override
            public void onSubscribe(Disposable d) {
                Log.v("meee",getClass()+":\n"+"onSubscribe");
            }
            //在接收事件时调用
            @Override
            public void onNext(Integer value) {
                Log.v("meee",getClass()+":\n"+"onNext"+value);
            }
            //在出现错误时调用
            @Override
            public void onError(Throwable e) {
                Log.v("meee",getClass()+":\n"+"onError");
            }
            //在事件结束时调用
            @Override
            public void onComplete() {
                Log.v("meee",getClass()+":\n"+"onComplete");
            }
        };
        //绑定观察者和被观察者
        objectObservable.subscribe(observer);

运行结果:
09-29 17:26:07.939 28098-28098/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onSubscribe
09-29 17:26:07.939 28098-28098/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onNext1
09-29 17:26:07.939 28098-28098/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onNext2
09-29 17:26:07.939 28098-28098/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onNext3
09-29 17:26:07.939 28098-28098/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onComplete

ObservableEmitter:事件的发起者,通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

1.可以发送无限个onNext, 观察者可以接收无限个onNext.
2.发送了一个onComplete后, 事件将会继续发送, 但观察者收到onComplete事件之后将不再继续接收事件.
3.发送了一个onError后, 事件将会继续发送, 但观察者收到onComplete事件之后将不再继续接收事件.
4.可以不发送onComplete或onError.
5.onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然
6.发送多个onComplete,在接收到第一个onComplete后不再接收;但发送多个error会崩溃

切断联系

Disposable,废弃
dispose()方法时, 观察者不能在接收事件,但被观察者会继续发送事件

        Observable<Integer> objectObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.v("meee",getClass()+":\n"+"emit1");
                e.onNext(1);
                Log.v("meee",getClass()+":\n"+"emit2");
                e.onNext(2);
                Log.v("meee",getClass()+":\n"+"emit3");
                e.onNext(3);
                e.onComplete();
            }
        });
        Observer observer=new Observer<Integer>(){
        //将Disposable 作为成员变量
            Disposable mDisposable;
            @Override
            public void onSubscribe(Disposable d) {
                mDisposable=d;
                Log.v("meee",getClass()+":\n"+"onSubscribe");
            }
            @Override
            public void onNext(Integer value) {
                if (value==2){
                    //切断观察者和被观察者间的联系
                    mDisposable.dispose();
                }
                Log.v("meee",getClass()+":\n"+"onNext"+value);
            }
            @Override
            public void onError(Throwable e) {
                Log.v("meee",getClass()+":\n"+"onError");
            }
            @Override
            public void onComplete() {
                Log.v("meee",getClass()+":\n"+"onComplete");
            }
        };

        objectObservable.subscribe(observer);

09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onSubscribe
09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$1:
                                                       emit1
09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onNext1
09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$1:
                                                       emit2
09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$2:
                                                       onNext2
//观察者无法再接收事件                                                       
09-29 17:38:35.403 28319-28319/com.junx.rxjava V/meee: class com.junx.rxjava.MainActivity$1:
                                                       emit3

subscribe()方法

//绑定观察者和被观察者
subscribe(observer);
//事件没有人处理
subscribe();
//消费者:只关心onNext事件的观察者
subscribe(consumer);
        objectObservable.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
            //发出的事件被尽数接收
                Log.v("meee",getClass()+":\n"+"accept"+integer);
            }
        });

和Retrofit联合使用

retrofit入门:
http://blog.csdn.net/skylakexun/article/details/78140480

public interface API {
    @FormUrlEncoded
    @POST("login")
    //返回Observable对象,LoginModel为接口返回的json的实例化class
    Observable<LoginModel> login2(@Field("username") String username, @Field("pwd") String pwd);
}

    //Retrofit
    private static Retrofit create() {
        OkHttpClient.Builder builder = new OkHttpClient().newBuilder();
        builder.readTimeout(10, TimeUnit.SECONDS);
        builder.connectTimeout(9, TimeUnit.SECONDS);

        return new Retrofit.Builder().baseUrl("url/")
                .client(builder.build())
                .addConverterFactory(GsonConverterFactory.create())
                //设置calladapter,将retrofit返回的Call对象转换为Observale对象
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
    }
            Retrofit retrofit = create();
        API api = retrofit.create(API.class);
        api.login2("123","123456")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<LoginModel>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        //获取mDisposable对象,用于防止act退出后rxjava的进程没有结束而导致的崩溃
                        mDisposable=d;
                    }

                    @Override
                    public void onNext(LoginModel value) {
                    //进行相关的操作
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

读取数据库

        public Observable<List<Record>> readAllRecords() {
            return Observable.create(new ObservableOnSubscribe<List<Record>>() {
                @Override
                public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
                    Cursor cursor = null;
                    try {
                        cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
                        List<Record> result = new ArrayList<>();
                        while (cursor.moveToNext()) {
                            result.add(Db.Record.read(cursor));
                        }
                        emitter.onNext(result);
                        emitter.onComplete();
                    } finally {
                        if (cursor != null) {
                            cursor.close();
                        }
                    }
                }
            }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
        }