Rxjava android что это

RxJava

Совсем недавно RxJava была на пике популярности, очень многие восторгались новым способом написания приложений, которое называют реактивным программированием. С появлением корутин в Kotlin популярность стала угасать. Тем не менее остались сторонники реактивного программирования, которые продолжают использовать RxJava в своих проектах, в том числе и на языке Kotlin.

Общая страница по реактивному программированию — http://reactivex.io/. Документация по классам здесь.

Переход на RxJava 2/RxJava 3

С некоторых пор произошло разделение версии на две ветки: 1.x и 2.x.

Ветка 1.x была заморожена 1 июня 2017 (только исправления багов). 31 марта 2018 года ветку закрыли. Я начинал изучать тему на основе 1.x-ветки, поэтому не удивляйтесь, если будут попадаться старые примеры для первой версии. Постараюсь явно предупреждать о подобных случаях, так как различия довольны значительны.

Ветку 2.x заморозили в феврале 2021 года. Теперь следует использовать новую ветку 3.х.

Большинство примеров писалось под версию 2.0, поэтому в статьях возможны ошибки. Решил заново пройтись по статьям и поправить косяки.

Разница между двумя ветками 1 и 2 описана на сайте документации. Общие фундаментальные понятия остались прежними. Разница между 2 и 3 описана в другом документе.

Были переименованы или удалены некоторые виды классов Action и Function.

• Action0 -> Action
• Action1 -> Consumer
• Action2 -> BiConsumer
• ActionN -> Consumer
• Action3 — Action9 -> удалены
• Func0 -> Callable
• Func1 -> Function
• Func2 -> BiFunction
• Func3 — Func9 -> Function3 — Function9

Subscriber переименован в Disposable. А также CompositeSubscription в CompositeDisposable.

Классы

В RxJava огромное количество страшных слов, которые следует выучить.

• Observable
• Observer
• Subject, а также PublishSubject, AsyncSubject, BehaviorSubject, ReplaySubject
• Processor — подвид Subject с поддержкой BackPressure. AsyncProcessor, BehaviorProcessor, PublishProcessor, ReplayProcessor, UnicastProcessor.
• Future
• Single — ленивый эквивалент Future.
• Maybe
• Completable
• Consumer
• Disposable — бывший Subscription из RxJava 1.x
• Scheduler
• Flowable

Observable и Observer

Существуют две сущности: производители и потребители (Observables и Observers). Общая идея состоит в реализации трёх задач — создать поток данных, привести данные в нужный вид, получить исправленные данные.

Операторы

В RxJava есть специальные операторы, с помощью которых можно создавать новые Observable или менять уже существующие. В Java операторы реализованы в виде методов. Как правило, названия оператора совпадает с именем метода или незначительно отличается наличием дополнительных префиксов или суффиксов.

Полная страница операторов в алфавитном порядке представлена в документации. Желательно самостоятельно пройтись по всем операторам, чтобы знать их возможности. Вдруг вам пригодится какой-то конкретный оператор для ваших задач. Мы рассмотрим только часть популярных операторов.

Также имеется интерактивная схема RxMarbles всех операторов, позволяющая двигать данные, чтобы увидеть работу оператора в действии. Схему ещё называет камешковыми диаграммами. Камешковые диаграммы иллюстрируют работу операторов. Как правило, диаграмма содержит две горизонтальные временные оси, направленные слева направо. Фигурки на диаграммах («камешки») служат для визуализации событий. Есть три типа камушек — круг, пятиугольник и треугольник.

Если поток обработан успешно, то справа рисуется вертикальная чёрточка. В случае ошибки рисуется крестик. Если поток никогда не завершается, то ничего не рисуется на временной шкале.

Между осями располагается оператор, который изменяет последовательность событий, поступающих от исходного Observable и передаваемых в результирующий.

В большинстве случаев операторы выполняются синхронно. Вы создаёте цепочку из операторов и они последовательно выполняются.

В этом и заключается их мощь, когда мы начинаем их комбинировать. Сцепление нескольких операторов, разветвление потока на несколько подпотоков и последующее их слияние – вам нужно выучить некоторых из популярных операторов, чтобы их правильно использовать.

Источник

Реактивное программирование с RxJava и RxKotlin

Russian (Pусский) translation by Liliya (you can also view the original English article)

С тех пор, как стал официально поддерживаемым языком для разработки Android, Kotlin быстро завоевал популярность среди разработчиковAndroid, и Google сообщает о 6-кратном увеличении приложений, созданных с помощью Kotlin.

Если вы ранее использовали RxJava или RxAndroid и хотите переключиться на Kotlin или хотите начать реактивное программирование с Kotlin,этот учебник для вас. Мы рассмотрим основные вопросы создания RxJava 2.0 Observers , Observables и потоков данных в Kotlin, прежде чем смотреть на то, как вы можете обрезать тонны кода шаблона из своих проектов, путем объединенияRxJava с функциями Kotlin.

Использование RxJava с Kotlin может помочь вам создавать высокореактивные приложения в меньшем количестве кодов, но язык программирования не идеален, поэтому я также буду обмениваться обходным решением проблемы конверсии SAM, с которой сталкиваются многие разработчики, когда они впервые начинают использовать RxJava 2.0 с Kotlin.

Чтобы обернуть все, мы создадим приложение, демонстрирующее, как вы можете использовать RxJava для решения некоторых проблем, с которыми вы сталкиваетесь в реальных проектах Android.

Если вы первый раз пробуете RxJava, то по пути я также буду предоставлять всю справочную информацию, необходимую для понимания основных концепций RxJava. Даже если вы никогда не экспериментировали с RxJava раньше, в конце этой статьи вы будете иметь четкое представление о том, как использовать эту библиотеку в своих проектах, и вы создали несколько рабочих приложений,используя RxJava, RxKotlin, RxAndroid и RxBinding.

Что такое RxJava, во всех случаях?

RxJava — это реализация библиотеки ReactiveX с открытым исходным кодом, которая помогает создавать приложения в стиле реактивного программирования. Хотя RxJava предназначен для обработки синхронных и асинхронных потоков данных, он не ограничивается «традиционными» типами данных. Определение «данных» RxJava довольно широко и включает такие вещи, как кеши, переменные, свойства и даже пользовательские события ввода, такие как щелчки и нажатия. Просто потому, что ваше приложение не имеет дело с огромными числами или выполняет сложные преобразования данных, это не значит, что он не может извлечь выгоду из RxJava!

За небольшим опытом использования приложений RxJava для Android вы можете ознакомиться с некоторыми другими моими сообщениями здесь, на Envato Tuts +.

Итак, как работает RxJava?

RxJava расширяет шаблон разработки программного обеспечения Observer, основанный на концепции наблюдателей и наблюдаемых. Чтобы создать базовый конвейер данных RxJava, вам необходимо:

• Создать наблюдаемый.
• Дайте наблюдаемым некоторые данные для выделения.
• Создайте наблюдателя.
• Подписывайте Наблюдателя в Наблюдаемого.

Как только Observable имеет хотя бы одного наблюдаемого, он начнет выпускать данные. Каждый раз, когда Observable испускает часть данных, он уведомляет об этом назначенного Observer, вызывая метод onNext() , и Observerзатем обычно выполняет некоторые действия в ответ на эту эмиссию данных. Как только Observable закончит выдавать данные, он уведомит Observer, вызвав onComplete() . После этого Observable завершит работу, и поток данных завершится.

Если возникает исключение, тогда вызывается onError() , и Observable будет немедленно завершен без каких-либо дополнительных данных или вызова onComplete() .

Но RxJava — это не просто передача данных из Observable в Observer! RxJava имеет огромную коллекцию операторов, которую вы можете использовать для фильтрации, слияния и преобразования этих данных. Например, представьте себе, что в вашем приложении есть кнопка «Оплатить сейчас», которая определяет события onClick , и вы опасаетесь,что нетерпеливый пользователь может нажать кнопку несколько раз, в результате чего ваше приложение обработает несколько платежей.

RxJava позволяет преобразовывать эти события onClick в поток данных, который затем можно манипулировать с помощью различных операторовRxJava. В этом конкретном примере вы можете использовать оператор debounce() для фильтрации данных, которые происходят в быстрой последовательности,поэтому, даже если пользователь нажимает на кнопку «Оплатить сейчас», ваше приложение будет регистрировать только на один платеж.

Каковы преимущества использования RxJava?

Мы видели, как RxJava может помочь вам решить определенную проблему в конкретном приложении, но что он должен предлагать проектам Android в целом?

RxJava может упростить ваш код, предоставив вам способ написать то, что вы хотите достичь, вместо того, чтобы писать список инструкций, которые должны выполнять ваше приложение. Например, если вы хотите игнорировать все данные, которые происходят в течение одного и того же 500-миллисекундного периода, тогда вы должны написать:

Кроме того, поскольку RxJava обрабатывает почти все как данные, он предоставляет шаблон, который вы можете применить к широкому спектру событий: создать Observable, создать Observer, подписать Observer к наблюдаемому, проверить и повторить. Этот формульный подход дает гораздо более простой, удобочитаемый код.

Другим важным преимуществом для разработчиков Android является то, что RxJava может сильно пострадать от много поточности на Android.Сегодняшние мобильные пользователи ожидают, что их приложения смогут бытьмногозадачными, даже если это так просто, как загрузка данных в фоновом режиме,оставаясь при этом зависящей от пользовательского ввода.

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

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

Вы можете указать, где результаты этой работы должны быть опубликованы, используя оператор observOn . Здесь мы публикуем результаты для всего важного основного потока пользовательского интерфейса Android, используя планировщик AndroidSchedulers.mainThread , который доступен как часть библиотекиRxAndroid:

По сравнению с встроенными многопоточными решениями Android, подход RxJava гораздо более краток и понятен.

Опять же, вы можете узнать больше о том, как работает RxJava, и о преимуществах добавления этой библиотеки в ваш проект в статье«Начало работы с RxJava 2 для Android».

Должен ли я использовать RxJava или RxKotlin?

Поскольку Kotlin на 100% совместим с Java, вы можете использовать большинство библиотек Java в своих проектах Kotlin без каких-либо трудностей, а библиотека RxJava не является исключением.

Существует специальная библиотека RxKotlin, которая представляет собой обертку Kotlin вокруг обычной библиотеки RxJava. Эта оболочка предоставляет расширения, которые оптимизируют RxJava для среды Kotlinи могут дополнительно уменьшить количество кода шаблона, который вам нужно написать.

Поскольку вы можете использовать RxJava в Kotlin, не требуя RxKotlin, мы будем использовать RxJava в этой статье, если не указано иное.

Создание простых наблюдателей и наблюдаемых в Kotlin

Наблюдатели и наблюдаемые являются строительными блоками RxJava, поэтому давайте начнем с создания:

• Простой Observable, который испускает короткий поток данных в ответ на событие нажатия кнопки.
• Наблюдаемый, который реагирует на эти данные, печатая различные сообщения в Logcat Android Studio.

Создайте новый проект с настройками по вашему выбору, но при появлении запроса установите флажок Включить поддержку Kotlin. Затем откройте файл build.gradle вашего проекта и добавьте библиотеку RxJava в зависимости от проекта:

Затем откройте файл activity_main.xml вашего проекта и добавьте кнопку, которая начнет поток данных:

Существует несколько способов создания Observable, но одним из самых простых является использование оператора just() для преобразования объекта или списка объектов в Observable.

В следующем коде мы создаем Observable ( myObservable ) и даем ему элементы 1, 2, 3, 4 и 5 для выдиления. Мы также создаем Observer( myObserver ), подписываемся на myObservable , а затем сообщаем ему печатать сообщение Logcat каждый раз, когда он получает новую эмиссию.

Теперь вы можете проверить это приложение:

• Установите свой проект на физическом Android-смартфоне или планшете или виртуальном устройстве Android (AVD).
• Нажмите на Start RxJava stream
• Откройте монитор Logcat для Android Studio, выбрав вкладку «Монитор Android» (где курсор расположен на следующем снимке экрана), а затем выберите вкладку «Logcat».

На этом этапе Observable начнет выдавать свои данные, и Observer будет печатать свои сообщения в Logcat. Вывод Logcat должен выглядеть примерно так:

Вы можете загрузить этот проект из GitHub, если хотите попробовать его сами.

Kotlin Extensions для RxJava

Теперь, когда мы увидели, как настроить простой RxJava-конвейер в Kotlin, давайте посмотрим, как вы можете добиться этого в меньшем коде, используя функции расширения RxKotlin.

Чтобы использовать библиотеку RxKotlin, вам нужно добавить ее как зависимость от проекта:

В следующем примере мы используем функцию расширения RxKotlin toObservable() для преобразования List в наблюдаемый. Мы также используем функцию расширения subscribeBy() , поскольку она позволяет нам построить Observer с использованием именованных аргументов, что приводит к более четкому коду.

Вот результат, который вы должны увидеть:

Решение проблемы неоднозначности SAM RxJava

RxKotlin также обеспечивает важное обходное решение для проблемы с преобразованием SAM, которое может возникать при наличии нескольких перегрузок параметров SAM для данного метода Java. Эта двусмысленность SAM смущает компилятор Kotlin, поскольку он не может решить, какой интерфейс он должен преобразовать, и ваш проект не сможет получить результат.

Эта двусмысленность SAM является особой проблемой при использовании RxJava 2.0 с Kotlin, так как многие операторы RxJava принимают несколько SAM-совместимых типов.

Давайте рассмотрим проблему преобразования SAM в действии. В следующем коде мы используем оператор zip() для объединения вывода двух наблюдаемых:

Это заставит компилятор Kotlin сбросить ошибку вывода типа. Однако RxKotlin предоставляет вспомогательные методы и функции расширения для затронутых операторов, включая Observables.zip() , которые мы используем в следующем коде:

Вот результат этого кода:

Заключение

В этом уроке я показал вам, как начать использовать библиотеку RxJava в проектах Kotlin, в том числе с использованием ряда дополнительных поддерживающих библиотек, таких как RxKotlin и RxBinding. Мы рассмотрели, как вы можете создавать простые наблюдатели и наблюдаемых в RxKotlin, чтобы оптимизировать RxJava для платформы Kotlin, используя функции расширения.

До сих пор мы использовали RxJava для создания простых Observables, которые излучают данные, и наблюдателей, которые печатают эти данные в Logcat Android Studio, но это не то, как вы будете использовать RxJava в реальном мире!

В следующем посте мы рассмотрим, как RxJava может помочь решить реальные проблемы, с которыми вы столкнетесь при разработке приложений для Android. Мы будем использовать RxJava с Kotlin для создания классического экрана регистрации.

Источник