Android 这三个RX观测值都按预期工作…哪种方式最好？

我试图调用contentResolver，它以反应式方式访问我的sql数据库。我知道sqlBrite存在，但我必须使用sqLite。我是rxJava（2）的新手，不知何故，我拼凑了3个调用，所有这些调用都像预期的那样神奇地工作。我不知道该用哪一个。我使用的是rxJava2，我读到的一些文章让我想到了这一点，这些文章似乎已经过时了。实现这一目标的首选方法是什么？我也没有使用retroLambda…我的婴儿步（我承认，它确实让事情看起来很好）

这是开始调用和订阅功能：

Observable<Cursor> dbObserver = mTmdbDatabaseService.getCursor1(123456);

dbObserver.subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(testDBObserver());

private Observer<Cursor> testDBObserver() {
  return new Observer<Cursor>() {
       @Override
       public void onSubscribe(Disposable d) {
           Log.d(TAG, "testDBObserver.onSubscribe");
            //Save the disposable to remove it later onDestroy
            mCompositeDisposable.add(d);
        }

        @Override
        public void onNext(Cursor c) {
            int num = c.getCount();
            Log.d(TAG, "testDBObserver.onNext:  " + c.getCount());
        }

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

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

Observable dbObserver=mTmdbDatabaseService.getCursor1（123456）；
dbObserver.subscribeOn（Schedulers.newThread（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribe（testDBObserver（））；
私有观察者testDBObserver（）{
返回新的观察者（）{
@凌驾
认购的公共无效（一次性d）{
Log.d（标记“testDBObserver.onSubscribe”）；
//保存一次性文件，以便以后在存储区中删除
mCompositeDisposable.add（d）；
}
@凌驾
public void onNext（光标c）{
int num=c.getCount（）；
d（标记“testDBObserver.onNext:+c.getCount（））；
}
@凌驾
公共无效申报人（可丢弃的e）{
Log.d（标签“testDBObserver.onError”）；
}
@凌驾
未完成的公共空间（）{
Log.d（标记“testDBObserver.onComplete”）；
}
};
}

以下是目前查询my DB的三个RxJava函数：

public Observable getCursor1(final int value) {
    Observable<Cursor> cursorObservable = Observable.fromCallable(new Callable<Cursor>() {
        @Override
        public Cursor call() throws Exception {
            int id = value;
            String stringId = Integer.toString(id);
            Uri uri = MovieContract.MovieEntry.CONTENT_URI;
            uri = uri.buildUpon().appendPath(stringId).build();
            Cursor c = mContext.getContentResolver().query(uri,
                    null,
                    null,
                    null,
                    MovieContract.MovieEntry.COLUMN_MOVIE_ID);
            return c;
        }
    });
    return  cursorObservable;
}

public Observable<Cursor> getCursor2(final int value) {
    return Observable.defer(new Callable<ObservableSource<? extends Cursor>>() {
        @Override
        public ObservableSource<? extends Cursor> call() throws Exception {
            int id = value;
            String stringId = Integer.toString(id);
            Uri uri = MovieContract.MovieEntry.CONTENT_URI;
            uri = uri.buildUpon().appendPath(stringId).build();
            Cursor c = mContext.getContentResolver().query(uri,
                    null,
                    null,
                    null,
                    MovieContract.MovieEntry.COLUMN_MOVIE_ID);
            return Observable.just(c);
        }
    });
}


public Observable<Cursor> getCursor3(final int value) {
    Observable<Cursor> observable = Observable.create(new ObservableOnSubscribe<Cursor>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Cursor> subscriber) throws Exception {
            int id = value;
            String stringId = Integer.toString(id);
            Uri uri = MovieContract.MovieEntry.CONTENT_URI;
            uri = uri.buildUpon().appendPath(stringId).build();
            Cursor c = mContext.getContentResolver().query(uri,
                    null,
                    null,
                    null,
                    MovieContract.MovieEntry.COLUMN_MOVIE_ID);
            subscriber.onNext(c);
            subscriber.onComplete();
        }
    });
    return observable;
}

公共可观测getCursor1（最终int值）{
Observable cursorObservable=Observable.fromCallable（newCallable（））{
@凌驾
公共游标调用（）引发异常{
int id=值；
字符串stringId=Integer.toString（id）；
Uri Uri=MovieContract.MovieEntry.CONTENT\u Uri；
uri=uri.buildOn（）.appendPath（stringId.build（）；
游标c=mContext.getContentResolver（）.query（uri，
无效的
无效的
无效的
MovieContract.MovieEntry.COLUMN\u MOVIE\u ID）；
返回c；
}
});
返回游标可观测；
}
公共可观测getCursor2（最终int值）{
return Observable.defer（new Callable
Observable.fromCallable
是这里的最佳选择，因为它正好满足您的需要：执行一些代码并返回一个值。
defer
和
create
适用于更复杂的情况，例如包装回调或操纵流的生命周期

提示：由于您使用的是
光标
，我认为更好的设计解决方案是从您的数据源（而不是光标本身）发出准确的数据，并在现场关闭光标：

Observable<Result> cursorObservable = Observable.fromCallable ... {
    @Override
    public Cursor call() throws Exception {
        ...
        Cursor c = ...
        Result result = ... //get your data from the cursor
        c.close();
        return result;
    }
});

Observable cursorObservable=Observable.fromCallable{
@凌驾
公共游标调用（）引发异常{
...
光标c=。。。
结果=…//从光标获取数据
c、 close（）；
返回结果；
}
});

SQLBrite只是SQLite的一个反应性包装