Я экспериментировал с RxJava в Android, но пытаюсь понять разницу между 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);
    }
}
1
Jay 25 Сен 2018 в 20:53

2 ответа

Лучший ответ

Observable.fromCallable( аналогичен

Observable.defer {
    try {
        Observable.just(...)
    } catch(e: Throwable) {
        Observable.error(e)
    }
}

Следовательно, just выполняется синхронно, а fromCallable может быть отложено до другого Scheduler с помощью subscribeOn (и выполнено «позже»).

8
EpicPandaForce 25 Сен 2018 в 17:55

В дополнение к @EpicPandaForce:

Observable # просто нетерпелив, Observable # fromCallable ленив.

Пример нетерпеливого: Observable.just (methodCall ()) -> first methodCall будет вычисляться во время сборки. methodCall () - Значение будет захвачено и использовано как входной параметр только для Observable #. Это значение будет сохранено в наблюдаемом. К этому моменту все уже произошло без подписки. При подписке на созданный Observable захваченное значение будет воспроизводиться для каждой подписки.

Пример ленивого: Observable.fromCallable (() -> methodCall ()) -> во время сборки наблюдаемый объект будет создан со ссылкой на лямбда. methodCall () не будет вызываться во время сборки. Выполнение лямбда будет происходить при каждой подписке.

Если вы хотите отложить дорогостоящую работу до первой подписки, вы должны использовать Observable # defer / Observable # fromCallable. При работе с синхронизацией. значения, которые уже присутствуют или создание которых очень дорого, вы должны использовать просто Observable #.

Также ознакомьтесь с https://github.com/ReactiveX/RxJava#assembly-time (время сборки / время подписки / время выполнения)

3
akarnokd 25 Сен 2018 в 20:12