Android进阶：RxJava2

看了几次rxJava，感觉太难了，都是看到一半就放弃了，陆陆续续小半年了，最近看到一篇博客，讲的浅显易懂，推荐一下。
Season_zlc的RxJavax系列：给初学者的RxJava2.0教程，非常适合初学者（我这篇就没有看的必要的），总共9篇。
demo:https://git.oschina.net/httpmethod/RxJava-Retrofit

简单使用

配置

RxJava
RxAndroid
rxandroid:在线程切换的时候会用到。

dependencies {
    ...
    compile "io.reactivex.rxjava2:rxjava:2.1.2"
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    ...
}

rxjava一般和retrofit配合使用

compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'

demo

先看一个demo

 Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
        Log.d(TAG, "发送" + Thread.currentThread().getName() + "，Hello");
        e.onNext("Hello");
        e.onNext("World");
        // e.onError(new Throwable("error"));
        e.onComplete();
        e.onNext("1");
    }
});


Observer<String> observer = new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        Log.d(TAG, "onSubscribe");
        com.add(d);

    }

    @Override
    public void onNext(@NonNull String s) {
        Log.d(TAG, s);
    }

    @Override
    public void onError(@NonNull Throwable e) {
        Log.d(TAG, "onError");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "onComplete");
    }
};

observable.subscribe(observer);

Observable Observer

Observable被观察者
Observer：观察者

Observable是上游，Observer、Consumer都是下游。

ObservableEmitter

ObservableEmitter：发送者

方法	说明
onNext(…)	下一步
onComplete()	发送完成
onError(new Throwable(“error”));	发送错误

创建被观察者：

如果onError(...)或者onComplete()后面还有onNext(...),是可以继续发送事件的，但是下游接收不到。

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
        e.onNext("Hello");
        e.onNext("World");
        //e.onError(new Throwable("error"));
        e.onComplete();
    }
});

创建观察者

Observer、Consumer都是观察者。

 Subscriber<String> subscriber = new Subscriber<String>() {
    @Override
    public void onSubscribe(Subscription s) {

    }

    @Override
    public void onNext(String s) {

    }

    @Override
    public void onError(Throwable t) {

    }

    @Override
    public void onComplete() {

    }
};

Consumer<String> consumer = new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {

    }
};

高级使用

设置上下游的线程

observable.subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(consumer);

还有Schedulers.io()一般进行网路请求、数据库处理等。
AndroidSchedulers.mainThread()主线程（更新ui）
subscribeOn(...)：设置上游线程
observeOn(...)：设置下游线程。

map flatMap concatMap

map flatMap concatMap 可以改变上游发送的事件。
flatMap:无法保证顺序。
concatMap:可以保证下游接收到的事件顺序与上游发送事件的顺序的一致性。

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).concatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("String:" + integer);
        }
        return Observable.fromIterable(list).delay(3, TimeUnit.SECONDS);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
}).flatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("String：" + integer);
        }
        /**
         * integer = 1时，被拆成了3个事件
         * integer = 2时，被拆成了3个事件
         * integer = 3时，被拆成了3个事件
         * 总共9个事件，而且是无序的。
         */

        return Observable.fromIterable(list).delay(5000, TimeUnit.MILLISECONDS);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});

注册后立即登录的例子

普通写法：
有2个方法：注册和登录，注册成功后再调用登录方法。

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("http://106.14.39.65:8385/itip/client/")
        .addConverterFactory(ScalarsConverterFactory.create())
        .addConverterFactory(GsonConverterFactory.create())
        .build();
AppUrl appUrl = retrofit.create(AppUrl.class);

register(appUrl);

注册成功后调用登录方法

private void register(final AppUrl appUrl) {
    RegisterRequest request = new RegisterRequest();
    appUrl.register(request)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<RegisterResponse>() {
                @Override
                public void accept(RegisterResponse registerResponse) throws Exception {
                    //注册成功
                    login(appUrl);
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    //注册失败
                }
            });
}

private void login(AppUrl appUrl) {
    LoginRequest request = new LoginRequest();
    appUrl.login(request)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<LoginRequest>() {
                @Override
                public void accept(LoginRequest loginRequest) throws Exception {
                    //登录失败
                }
            }, new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    //登录失败
                }
            });
}

链式调用：

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://106.14.39.65:8385/itip/client/")
    .addConverterFactory(ScalarsConverterFactory.create())
    .addConverterFactory(GsonConverterFactory.create())
    .build();
final AppUrl appUrl = retrofit.create(AppUrl.class);

appUrl.register(new RegisterRequest())
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .doAfterNext(new Consumer<RegisterResponse>() {
        @Override
        public void accept(RegisterResponse registerResponse) throws Exception {
            //注册后的一些操作，比如提示注册成功，可以登录
            Toast.makeText(MainActivity.this, "户厕成功", Toast.LENGTH_SHORT).show();
        }
    })
    .subscribeOn(Schedulers.io())
    .flatMap(new Function<RegisterResponse, ObservableSource<LoginRequest>>() {
        @Override
        public ObservableSource<LoginRequest> apply(@NonNull RegisterResponse registerResponse) throws Exception {
            return appUrl.login(new LoginRequest());
        }
    })
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Consumer<LoginRequest>() {
        @Override
        public void accept(LoginRequest loginRequest) throws Exception {
            Toast.makeText(MainActivity.this, "登录成功", Toast.LENGTH_SHORT).show();
        }
    }, new Consumer<Throwable>() {
        @Override
        public void accept(Throwable throwable) throws Exception {

        }
    });