首页 > 安全资讯 >

RxJava defer操作符实现代码支持链式调用

16-09-22

RxJava defer操作符实现代码支持链式调用

前言

现在越来越多Android开发者使用到RxJava,在Android使用RxJava主要有如下好处:

1,轻松切换线程。以前我们切换线程主要使用Handler等手段来做。

2,轻松解决回调的嵌套问题。现在的app业务逻辑越来越复杂,多的时候3,4层回调嵌套,使得代码可维护性变得很差。RxJava链式调用使得这些调用变得扁平化。

随着RxJava的流行,越来越多的开源项目开始支持RxJava,像Retrofit、GreenDao等。这些开源项目支持RxJava使得我们解决复杂业务变得非常方便。

但是这些还不够,有的时候我们自己的封装的业务也需要支持RxJava,举个例子:查询数据、处理本地文件等操作,总而言之就是一些耗时任务。而且还要处理这些操作的成功、失败、线程切换等操作。

如果还是想以前那样做,那就太low。

下面就来探讨下如何使得代码支持RxJava风格

遇到这种问题,在我脑海里浮现的第一种方式就是通过Observable的create操作符。因为在里面我们可以控制数据的发射。就像上一篇文章那样《RxJava switchIfEmpty操作符实现Android检查本地缓存逻辑判断》

如下代码片段:

Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                try {
                    List
as = articleDao.queryBuilder() .where(ArticleDao.Properties.CategoryId.eq(categoryId)) .orderDesc(ArticleDao.Properties.Id) .offset((pageIndex - 1) * pageSize) .limit(pageSize).list(); if (as == null || as.isEmpty()) { subscriber.onNext(null); }else{ subscriber.onNext(as); } }catch (Exception e){ subscriber.onError(e); } subscriber.onCompleted(); } });

这样确实没有没有问题。但是我们要封装下, 每个方法都这样写维护性和扩展比较差(例如有天我想换种方式来实现而不是create,如果通过方法封装一下,修改就变得容易多了)

如何封装呢?通过分析知道,大部分代码是相同的,只是我们的业务不一样。那么通过模板方法解决吧。业务方法通过接口回调的方式传递进来,因为我们不知道调用者是什么业务。

回调接口如下(T表示我们业务数据):

    public interface MyCallable {
        T call();
    }

下面是模板代码:

    protected  Observable createObservable(final MyCallable callable) {
        return Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                try {
                    R result = callable.call();
                    subscriber.onNext(result);
                } catch (Exception e) {
                    subscriber.onError(e);
                }
                subscriber.onCompleted();
            }
        });
    }

使用就非常简单了调用createObservable方法,实现MyCallable接口即可,然后就是跟使用RxJava一样处理逻辑。

分析greendao是如何支持RxJava风格的

看过Greendao源码的人知道,它也是通过这种方式支持RxJava的(下面看看他是怎么做的):

    /**
     * Rx version of {@link AbstractDao#loadAll()} returning an Observable.
     */
    @Experimental
    public Observable load(final K key) {
        return wrap(new Callable() {
            @Override
            public T call() throws Exception {
                return dao.load(key);
            }
        });
    }

最终的实现也是通过dao.load(key)同步方法来实现的,关键是wrap方法了:

    protected  Observable wrap(Callable callable) {
        return wrap(RxUtils.fromCallable(callable));
    }

    //通过这个方法再包装了一层(就是默认设置执行的线程)
    protected  Observable wrap(Observable observable) {
        if (scheduler != null) {
            return observable.subscribeOn(scheduler);
        } else {
            return observable;
        }
    }

通过代码可以看到默认执行的线程是IO线程:

    /**
     * The returned RxDao is a special DAO that let's you interact with Rx Observables using RX's IO scheduler for
     * subscribeOn.
     *
     * @see #rxPlain()
     */
    @Experimental
    public RxDao rx() {
        if (rxDao == null) {
            rxDao = new RxDao<>(this, Schedulers.io());
        }
        return rxDao;
    }

所以使用greendao不用指定它在IO执行,因为sdk已经帮我们设置了。

然后就是RxUtils.fromCallable(callable)方法了:

class RxUtils {
    /** As of RxJava 1.1.7, Observable.fromCallable is still @Beta, so just in case... */
    @Internal
    static  Observable fromCallable(final Callable callable) {
        return Observable.defer(new Func0>() {

            @Override
            public Observable call() {
                T result;
                try {
                    result = callable.call();
                } catch (Exception e) {
                    return Observable.error(e);
                }
                return Observable.just(result);
            }
        });
    }
}

上面的注释说通过Observable.fromCallable也可以实现这样的逻辑,也就是说代替Observable.defer()方法。

最后greendao是通过defer操作符来实现rx风格的。

defer和create操作符有什么异同点?

通过分析greendao源码得知,他是通过defer来做的,我们是通过create操作符来做的。那两者有什么不同?

我们对defer操作符比较陌生,先看看它的源码:

    public static  Observable defer(Func0> observableFactory) {
        return create(new OnSubscribeDefer(observableFactory));
    }

说白了就是调用了create(OnSubscribe f) 方法:

    public static  Observable create(OnSubscribe f) {
        return new Observable(hook.onCreate(f));
    }

其实我们上面的create操作也是调用过来这个方法。只是defer操作符传递的OnSubscribe是OnSubscribeDefer,那我们来看看这是什么鬼?

public final class OnSubscribeDefer implements OnSubscribe {
    final Func0> observableFactory;

    public OnSubscribeDefer(Func0> observableFactory) {
        this.observableFactory = observableFactory;
    }

    @Override
    public void call(final Subscriber s) {
        Observable o;
        try {
            o = observableFactory.call();
        } catch (Throwable t) {
            Exceptions.throwOrReport(t, s);
            return;
        }
        o.unsafeSubscribe(Subscribers.wrap(s));
    }

}

OnSubscribeDefer也是继承自OnSubscribe,那么他的call方法肯定也是在订阅的时候被调用(就是说订阅的时候才创建这个observable,并且每次订阅都会创建一个新的observable)。

为什么Greendao没有使用create那种方式精确控制数据的发射?现在RxJava2.0对create操作符做出了一些限制,不能随随便便create了,这样出现一些问题。

相关文章
最新文章
热点推荐