Question

我一直在尝试在Android中使用RxJava，但是我试图找出fromCallable和Just之间的区别。两者都只接收一次数据，而Create则可以多次接收数据。这是我用于实验的代码：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        listenCallable();
        listenJust();
    }
    private void listenCallable() {
        CompositeDisposable compositeDisposable = new CompositeDisposable();
        Disposable disposable = Shooter.getCallable().subscribe(i -> {
            Log.d("Tag", "Listen Callable: " + i);
        });
        compositeDisposable.add(disposable);
        compositeDisposable.dispose();
    }

    private void listenJust() {
        CompositeDisposable compositeDisposable = new CompositeDisposable();
        Disposable disposable = Shooter.getJust("Jay").subscribe(i -> {
            Log.d("Tag", "Listen Just " + i);
        });
        compositeDisposable.add(disposable);
        compositeDisposable.dispose();
    }
}

和发出数据的类：

public class Shooter {
    public static Observable<String> getCallable() {
        return Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                try {
                    Thread.sleep(500);
                } catch (Exception e) {}
                return "Callable Results";
            }
        });
    }

    public static Observable<String> getJust(String input) {
        try {
            Thread.sleep(500);
        } catch (Exception e) {}
        return Observable.just("Just Results " + input);
    }
}

Answer 1

J类似于

Observable.fromCallable(

因此，Observable.defer { try { Observable.just(...) } catch(e: Throwable) { Observable.error(e) } }是同步运行的，而just可以通过fromCallable推迟到另一个Scheduler（并在以后执行）。

Answer 2

作为@EpicPandaForce的补充：

Observable＃just渴望，Observable＃fromCallable懒惰。

渴望的例子： Observable.just（methodCall（））->第一个methodCall将在组装时进行评估。 methodCall（）-Value将被捕获，并用作Observable＃just的输入参数。该值将存储在观察值中。到目前为止，所有事情都已经发生，没有任何订阅。订阅创建的Observable时，捕获的值将在每个订阅中重播。

示例懒惰： Observable.fromCallable（（）-> methodCall（））->在组装期间，将通过引用lambda创建observable。在组装期间不会调用methodCall（）。 lambda执行将在每个订阅上发生。

如果您想将昂贵的工作推迟到第一次订阅发生之前，可以使用Observable＃defer / Observable＃fromCallable。处理同步时。值，这些值已经存在或创建起来非常昂贵，您可以使用Observable＃just。

还请查看https://github.com/ReactiveX/RxJava#assembly-time（组装时间/订阅时间/运行时间）

Android RxJava 2：fromCallable和Just有什么区别？

2 个答案: