Rx JAVA在安卓中的使用

安卓的耗时操作不得在主线程进行，包括访问网络等操作，最原始的做法是开个线程访问网络，然后使用handler回调。
Rx JAVA是非常强悍的异步工具，说到根上，这是是一个实现异步操作的库。

看了这篇文章之后深有启发，关于Rx JAVA的原理解释的非常深刻

http://gank.io/post/560e15be2dca930e00da1083

点击打开链接

基于这篇文章，方便使用，这里是我实现的一个Rx工具类

subscribeOn(Schedulers.io())指定线程在io线程执行，observeOn(AndroidSchedulers.mainThread())回调在主线程执行。

在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。

public class RxUtil {
    /**
     * 异步任务
     * @param onSubscribe 被观察者（异步线程）
     * @param subscriber 观察（主线程，可为null，则不定阅结果）
     * @param <T> 通配泛型
     * @return 返回订阅，可以取消
     */
    public static <T> Subscription doAsync(Observable.OnSubscribe<T> onSubscribe,Subscriber<? super T> subscriber ) {

        final Observable<T> tObservable = Observable.create(onSubscribe)
                .subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());

        if (subscriber != null) {
            return tObservable
                    .subscribe(subscriber);
        } else {
            return tObservable
                    .subscribe(new Subscriber<T>() {
                        @Override
                        public void onCompleted() {
                            Log.e("log", "RxUtil onCompleted ");
                        }

                        @Override
                        public void onError(Throwable e) {
                            Log.e("log", "RxUtil onError ", e);
                        }

                        @Override
                        public void onNext(T t) {
                            Log.e("log", "RxUtil onNext ");
                        }
                    });
        }

    }


    /**
     * 异步任务
     * @param onSubscribe 被观察者（异步线程）
     * @param <T> 通配泛型
     * @return 返回订阅，可以取消
     */
    public static <T> Subscription doAsync(Observable.OnSubscribe<T> onSubscribe ) {
        return doAsync(onSubscribe, null);
    }
}

工具类的使用

工具类的使用分两种情况，看是否需要回调。

不需要回调的情况：

RxUtil.doAsync(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        Log.e("log","thread is running");
                    }
                });

监听回调的情况：

RxUtil.doAsync(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        subscriber.onNext("要实现的方法");
                    }
                }, new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.e("log", "RxUtil onCompleted ");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("log", "RxUtil onError ", e);
                    }

                    @Override
                    public void onNext(String s) {
                        Log.e("log", "RxUtil onNext ");
                    }
                });

此方法不用工具类实现就显得非常的麻烦了

Observable.OnSubscribe onSubscribe = new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("要实现的方法");
            }
        };

        Subscriber<String> subscriber =new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.e("log", "RxUtil onCompleted ");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("log", "RxUtil onError ", e);
            }

            @Override
            public void onNext(String s) {
                Log.e("log", "RxUtil onNext ");
            }
        };

        Observable<String> observable = Observable.create(onSubscribe).
                subscribeOn(Schedulers.io()).
                observeOn(AndroidSchedulers.mainThread());

        observable.subscribe(subscriber);