Понимание наблюдаемого HOT vs COLD кажется сложной темой, о которой кто-то захочет поговорить только после того, как хорошо поймет, что такое RxJava.

Однако, когда я посмотрел на just и fromCallable, я обнаружил, что их сходство хорошо сочетается, что делает ГОРЯЧИЕ и ХОЛОДНЫЕ гораздо более понятными.

Из моего предыдущего блога…

Я показываю очень простой пример использования just, используемого в RxJava, для предоставления значения моему объекту производителя Single.

Single.just(1).subscribe{ it -> print(it) } // result 1

Но есть еще одна функция… fromCallable, которая выглядит очень похожей и дает тот же результат.

Single.fromCallable{ 1 }.subscribe{ it -> print(it) } // result 1

Давайте посмотрим на другой пример

println("From Just")
Single.just(Random(1).nextInt()).subscribe{ it -> println(it) }
Single.just(Random(1).nextInt()).subscribe{ it -> println(it) }
println("\nFrom Callable")
Single.fromCallable { Random(1).nextInt() }
    .subscribe{ it -> println(it) }
Single.fromCallable { Random(1).nextInt() }
    .subscribe{ it -> println(it) }

Результат выглядит как just, чувствую себя как just….

From Just
600123930
600123930
From Callable
600123930
600123930

НО Это НЕ то же самое, что just.

Понимание различий очень важно, так как упоминание поможет также в некоторой степени понять разницу между наблюдаемыми HOT и COLD.

Давайте посмотрим на различия ...

1. Данные извне и созданные внутри

just просто возьмите заданное значение из любого источника, который ему был отправлен. Хотя fromCallable фактически генерирует значение из Single.

Так в чем разница? Чтобы было понятно, давайте посмотрим на код. На этот раз мы используем генератор случайных значений, который генерирует разные значения при каждом вызове.

println("From Just")
val justSingle = Single.just(Random.nextInt())
justSingle.subscribe{ it -> println(it) }
justSingle.subscribe{ it -> println(it) }
println("\nFrom Callable")
val callableSingle = Single.fromCallable { Random.nextInt() }
callableSingle.subscribe{ it -> println(it) }
callableSingle.subscribe{ it -> println(it) }

Мы могли бы сохранить Single и использовать два Потребителя (subscribe дважды). Результат ниже.

From Just
801570614
801570614
From Callable
1251601849
2033593269

Вы заметите, что значение just остается неизменным независимо от количества subscribe. Значение было сгенерировано извне из Observable, а наблюдаемое просто сохраняет его для дальнейшего использования.

Однако для fromCallable он генерируется внутренне из Observable. Новое случайное число генерируется каждый раз, когда к нему подключается subscribe.

2. Немедленно казнен против ленивого казни

Помимо вышеперечисленного, есть еще одно отличие: just имеет значение даже раньше, чем кто-либо subscribe к нему. Однако fromCallable генерирует значение только тогда, когда кто-то subscribe к нему.

Другими словами, отложенное выполнение также известно как ленивая инициализация. Это что-то очень полезное в программировании, чтобы сэкономить некоторые ресурсы обработки до тех пор, пока они не понадобятся позже.

Давайте посмотрим на приведенный ниже код.

fun main() {
    println("From Just")
    val justSingle = Single.just(getRandomMessage())
    println("start subscribing")
    justSingle.subscribe{ it -> println(it) }
   
    println("\nFrom Callable")
    val callableSingle = Single.fromCallable { getRandomMessage() }
    println("start subscribing")
    callableSingle.subscribe{ it -> println(it) }
}

fun getRandomMessage(): Int {
    println("-Generating-")
    return Random.nextInt()
}

Результат как ниже

From Just
-Generating-
start subscribing
1778320787
From Callable
start subscribing
-Generating-
1729786515

Вы заметите, что -Generating- для just происходит до start subscribing. Это потому, что это делается в первую очередь.

Однако для fromCallable -Generating- происходит только после start subscribing.

Важное сравнение: горячие и холодные наблюдаемые

Из различий just и fromCallable у нас есть таблица, как показано ниже.

Если мы также сделаем таблицу для HOT vs COLD Observable, она будет выглядеть так же, как указано выше.

Следовательно, сравнивая разные just и fromCallable, можно было понять их сходство со сравнением Hot и Cold Observable.

Примечание. just и fromCallable на самом деле являются генератором одного значения. Следовательно, для just из одного и того же наблюдаемого всегда генерируется только одно значение. Я просто хочу уточнить, Hot Observable не означает, что всегда генерируется одно и то же значение; вместо этого значение генерируется извне и не контролируется Observable. Таким образом, он может генерировать разные значения, если Hot Observables способен генерировать последовательность значений перед завершением.

Еще одна хорошая статья, описывающая горячее и холодное, приведена ниже.



Понимание горячих и холодных наблюдаемых
Когда я начал разбираться в наблюдаемых, мне потребовалось некоторое время, чтобы понять, что имеется в виду под горячим или холодным… medium.com



Надеюсь, этот пост будет вам полезен. Вы можете ознакомиться с другими моими интересными темами здесь.

Следуйте за мной в medium, Twitter, Facebook или Reddit за небольшими советами и изучение Android, Kotlin и т. д., связанные темы. ~ Эли ~