RxJava：使用另一个线程上的可观察结果

我需要在后台线程上执行一些工作，然后在主线程上交付结果。我做了以下工作：

Observable.just(new Object()).subscribeOn(Schedulers.newThread()).subscribeWith(new DisposableObserver<Object>() {
            @Override
            public void onNext(Object s) {

                try {
                    doSomething()
                    Observable.just(new Object())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(new Observer<Object>() {
                                @Override
                                public void onSubscribe(Disposable d) {

                                }

                                @Override
                                public void onNext(Object o) {
                                    completion.deliverResult()
                                    onComplete();
                                }

                                @Override
                                public void onError(Throwable e) {

                                }

                                @Override
                                public void onComplete() {

                                }
                            });
                } catch (DriverException e) {
                    badThingsHappened()
                    onError(e);
                }
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {

            }
        });

Observable.just（new Object（））.subscribeOn（Schedulers.newThread（））.subscribeWith（new DisposableObserver（））{
@凌驾
public void onNext（对象s）{
试一试{
doSomething（）
可观察的。只是（新对象（））
.observeOn（AndroidSchedulers.mainThread（））
.订阅（新观察员）{
@凌驾
认购的公共无效（一次性d）{
}
@凌驾
公共void onNext（对象o）{
完成。交付结果（）
onComplete（）；
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});
}捕捉（驱动力）{
baddhingshappened（）
onError（e）；
}
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});

但是我不喜欢这个代码，它看起来很复杂，很多东西都没有使用

---

有没有更优雅的方法？

您的代码可以转换为类似于以下内容：

    Observable
            .create(emitter -> {
                Result result;
                try {
                    result = doSomething();
                } catch (Exception error) {
                    emitter.onError(error);
                    return;
                } finally {
                    if (result == null) {
                        emitter.onError(new IllegalStateException("Result cannot be null"));
                        return;
                    }
                }
                emitter.onNext(result);
                emitter.onComplete();
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(result -> completion.deliverResult(result),
                    throwable -> badThingsHappened(throwable));

---

但使用这种方法，您将传统回调与反应式编程混合在一起：

completion.deliverResult（）

是一种标准回调。不要这样做，而是返回可观察的流本身，让感兴趣的客户机观察流本身。

您的代码可以转换为类似于以下内容：

    Observable
            .create(emitter -> {
                Result result;
                try {
                    result = doSomething();
                } catch (Exception error) {
                    emitter.onError(error);
                    return;
                } finally {
                    if (result == null) {
                        emitter.onError(new IllegalStateException("Result cannot be null"));
                        return;
                    }
                }
                emitter.onNext(result);
                emitter.onComplete();
            })
            .subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(result -> completion.deliverResult(result),
                    throwable -> badThingsHappened(throwable));

---

但使用这种方法，您将传统回调与反应式编程混合在一起：

completion.deliverResult（）

是一种标准回调。与其这样做，不如返回可观察的流本身，让感兴趣的客户机观察流本身。

只需几行代码就可以完成您想要的操作

在这段代码中，我从一个可调用对象创建了一个可观察对象。计算将在IO线程上完成，但结果（或最终错误）将在Android主线程上观察

void execute() {
    // here you get your observable (api, db, other repositories). I'll create a simple String observable
    Observable<String> observable = Observable.fromCallable(
            () -> "This method will be executed on IO Thread"
    );

    // here you create your observer. I'll observe a string, so I need a Observer<String> obj
    Observer<String> stringObserver = new StringObserver();

    //now the observable will do his job on IO thread, but the result is emitted on mainThread
    observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(stringObserver);
}

class StringObserver extends DisposableObserver<String> {
    @Override
    public void onNext(String s) {
        //will be executed on main thread
    }

    @Override
    public void onError(Throwable e) {

        //will be executed on main thread
    }

    @Override
    public void onComplete() {

        //will be executed on main thread
    }
}

void execute（）{
//在这里，您可以看到您的可观察内容（api、db、其他存储库）。我将创建一个简单的可观察字符串
可观察的，可观察的(
（）->“此方法将在IO线程上执行”
);
//在这里您创建了一个观察者。我将观察一个字符串，所以我需要一个观察者obj
观察者stringObserver=新的stringObserver（）；
//现在，可观察对象将在IO线程上执行其工作，但结果将在主线程上发出
可观察
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.认购（观察员）；
}
类StringObserver扩展了DisposableObserver{
@凌驾
public void onNext（字符串s）{
//将在主线程上执行
}
@凌驾
公共无效申报人（可丢弃的e）{
//将在主线程上执行
}
@凌驾
未完成的公共空间（）{
//将在主线程上执行
}
}

只需几行代码，您就可以随心所欲

在这段代码中，我从一个可调用对象创建了一个可观察对象。计算将在IO线程上完成，但结果（或最终错误）将在Android主线程上观察

void execute() {
    // here you get your observable (api, db, other repositories). I'll create a simple String observable
    Observable<String> observable = Observable.fromCallable(
            () -> "This method will be executed on IO Thread"
    );

    // here you create your observer. I'll observe a string, so I need a Observer<String> obj
    Observer<String> stringObserver = new StringObserver();

    //now the observable will do his job on IO thread, but the result is emitted on mainThread
    observable
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(stringObserver);
}

class StringObserver extends DisposableObserver<String> {
    @Override
    public void onNext(String s) {
        //will be executed on main thread
    }

    @Override
    public void onError(Throwable e) {

        //will be executed on main thread
    }

    @Override
    public void onComplete() {

        //will be executed on main thread
    }
}

void execute（）{
//在这里，您可以看到您的可观察内容（api、db、其他存储库）。我将创建一个简单的可观察字符串
可观察的，可观察的(
（）->“此方法将在IO线程上执行”
);
//在这里您创建了一个观察者。我将观察一个字符串，所以我需要一个观察者obj
观察者stringObserver=新的stringObserver（）；
//现在，可观察对象将在IO线程上执行其工作，但结果将在主线程上发出
可观察
.subscribeOn（Schedulers.io（））
.observeOn（AndroidSchedulers.mainThread（））
.认购（观察员）；
}
类StringObserver扩展了DisposableObserver{
@凌驾
public void onNext（字符串s）{
//将在主线程上执行
}
@凌驾
公共无效申报人（可丢弃的e）{
//将在主线程上执行
}
@凌驾
未完成的公共空间（）{
//将在主线程上执行
}
}

emmiter内部创建的对象类型是什么？我看到了ObservableMitter可用的构造函数，但它需要实现8个方法。它是

ObservableOnSubscribe

。请参阅文档。emmiter内部创建的对象类型是什么？我看到了ObservableMitter可用的构造函数，但它需要实现8个方法。它是

ObservableOnSubscribe

。见文件。