Rxjava android что это
Реактивное программирование с RxJava и RxKotlin
Russian (Pусский) translation by Liliya (you can also view the original English article)
С тех пор, как стал официально поддерживаемым языком для разработки Android, Kotlin быстро завоевал популярность среди разработчиковAndroid, и Google сообщает о 6-кратном увеличении приложений, созданных с помощью Kotlin.
Использование RxJava с Kotlin может помочь вам создавать высокореактивные приложения в меньшем количестве кодов, но язык программирования не идеален, поэтому я также буду обмениваться обходным решением проблемы конверсии SAM, с которой сталкиваются многие разработчики, когда они впервые начинают использовать RxJava 2.0 с Kotlin.
Чтобы обернуть все, мы создадим приложение, демонстрирующее, как вы можете использовать RxJava для решения некоторых проблем, с которыми вы сталкиваетесь в реальных проектах Android.
Если вы первый раз пробуете RxJava, то по пути я также буду предоставлять всю справочную информацию, необходимую для понимания основных концепций RxJava. Даже если вы никогда не экспериментировали с RxJava раньше, в конце этой статьи вы будете иметь четкое представление о том, как использовать эту библиотеку в своих проектах, и вы создали несколько рабочих приложений,используя RxJava, RxKotlin, RxAndroid и RxBinding.
Что такое RxJava, во всех случаях?
За небольшим опытом использования приложений RxJava для Android вы можете ознакомиться с некоторыми другими моими сообщениями здесь, на Envato Tuts +.
Итак, как работает RxJava?
RxJava расширяет шаблон разработки программного обеспечения Observer, основанный на концепции наблюдателей и наблюдаемых. Чтобы создать базовый конвейер данных RxJava, вам необходимо:
RxJava позволяет преобразовывать эти события onClick в поток данных, который затем можно манипулировать с помощью различных операторовRxJava. В этом конкретном примере вы можете использовать оператор debounce() для фильтрации данных, которые происходят в быстрой последовательности,поэтому, даже если пользователь нажимает на кнопку «Оплатить сейчас», ваше приложение будет регистрировать только на один платеж.
Каковы преимущества использования RxJava?
Мы видели, как RxJava может помочь вам решить определенную проблему в конкретном приложении, но что он должен предлагать проектам Android в целом?
RxJava может упростить ваш код, предоставив вам способ написать то, что вы хотите достичь, вместо того, чтобы писать список инструкций, которые должны выполнять ваше приложение. Например, если вы хотите игнорировать все данные, которые происходят в течение одного и того же 500-миллисекундного периода, тогда вы должны написать:
Кроме того, поскольку RxJava обрабатывает почти все как данные, он предоставляет шаблон, который вы можете применить к широкому спектру событий: создать Observable, создать Observer, подписать Observer к наблюдаемому, проверить и повторить. Этот формульный подход дает гораздо более простой, удобочитаемый код.
Другим важным преимуществом для разработчиков Android является то, что RxJava может сильно пострадать от много поточности на Android.Сегодняшние мобильные пользователи ожидают, что их приложения смогут бытьмногозадачными, даже если это так просто, как загрузка данных в фоновом режиме,оставаясь при этом зависящей от пользовательского ввода.
Android имеет несколько встроенных решений для создания и управления несколькими потоками, но ни один из них не прост в реализации, и они могут быстро привести к сложному коду, который трудно читать и который подвержен ошибкам.
В RxJava вы создаете и управляете дополнительными потоками, используя комбинацию операторов и планировщиков. Вы можете легко изменить поток, в котором выполняется работа, используя оператор subscribeOn плюс планировщик. Например, здесь мы планируем работу над новым потоком:
По сравнению с встроенными многопоточными решениями 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, поэтому давайте начнем с создания:
Создайте новый проект с настройками по вашему выбору, но при появлении запроса установите флажок Включить поддержку Kotlin. Затем откройте файл build.gradle вашего проекта и добавьте библиотеку RxJava в зависимости от проекта:
Затем откройте файл activity_main.xml вашего проекта и добавьте кнопку, которая начнет поток данных:
Существует несколько способов создания Observable, но одним из самых простых является использование оператора just() для преобразования объекта или списка объектов в Observable.
Теперь вы можете проверить это приложение:
На этом этапе Observable начнет выдавать свои данные, и Observer будет печатать свои сообщения в Logcat. Вывод Logcat должен выглядеть примерно так:
Вы можете загрузить этот проект из GitHub, если хотите попробовать его сами.
Kotlin Extensions для RxJava
Теперь, когда мы увидели, как настроить простой RxJava-конвейер в Kotlin, давайте посмотрим, как вы можете добиться этого в меньшем коде, используя функции расширения RxKotlin.
Чтобы использовать библиотеку RxKotlin, вам нужно добавить ее как зависимость от проекта:
Вот результат, который вы должны увидеть:
Решение проблемы неоднозначности SAM RxJava
RxKotlin также обеспечивает важное обходное решение для проблемы с преобразованием SAM, которое может возникать при наличии нескольких перегрузок параметров SAM для данного метода Java. Эта двусмысленность SAM смущает компилятор Kotlin, поскольку он не может решить, какой интерфейс он должен преобразовать, и ваш проект не сможет получить результат.
Эта двусмысленность SAM является особой проблемой при использовании RxJava 2.0 с Kotlin, так как многие операторы RxJava принимают несколько SAM-совместимых типов.
Давайте рассмотрим проблему преобразования SAM в действии. В следующем коде мы используем оператор zip() для объединения вывода двух наблюдаемых:
Вот результат этого кода:
Заключение
В этом уроке я показал вам, как начать использовать библиотеку RxJava в проектах Kotlin, в том числе с использованием ряда дополнительных поддерживающих библиотек, таких как RxKotlin и RxBinding. Мы рассмотрели, как вы можете создавать простые наблюдатели и наблюдаемых в RxKotlin, чтобы оптимизировать RxJava для платформы Kotlin, используя функции расширения.
До сих пор мы использовали RxJava для создания простых Observables, которые излучают данные, и наблюдателей, которые печатают эти данные в Logcat Android Studio, но это не то, как вы будете использовать RxJava в реальном мире!
В следующем посте мы рассмотрим, как RxJava может помочь решить реальные проблемы, с которыми вы столкнетесь при разработке приложений для Android. Мы будем использовать RxJava с Kotlin для создания классического экрана регистрации.
Лекция 3 по архитектуре андроид приложения. Знакомство с RxJava
Третья лекция Курса по архитектуре клиент-серверных android-приложений, в которой мы познакомимся с RxJava и основными операторами, а также узнаем, как создавать Observable, преобразовывать потоки данных, работать с RxJava в Android и решать проблему Backpressure.
Ссылки на исходный код ваших решений вы можете оставлять в комментариях. Делитесь вашими решениями с сообществом, получайте обратную связь и конструктивную критику. Лучшие решения будут опубликованы на нашем канале и сайте fandroid.info с указанием авторства победителей!
Введение
Сейчас мы знаем немало способов выполнять какую-то работу в фоновых потоках. Под работой здесь чаще всего понимаются серверные запросы. Но насколько все хорошо с этими способами? Нужно признать, что у них немало недостатков.
Во-первых, эти способы не гибкие. Допустим, нужно выполнить два запроса параллельно, а потом, дождавшись, когда оба завершат работу, выполнить третий запрос с использованием результатов предыдущих запросов. Если вы попробуете реализовать такую задачу с использованием лоадеров, то скорее всего у вас получится большое количество булевских флагов, полей для сохранения результата и много кода. К проблемам гибкости можно также отнести и то, что сложно хорошо реализовать периодическое обновление данных.
Во-вторых, неудобно обрабатывать ошибки. Опять же, в случае лоадеров мы можем вернуть только один результат. Конечно, можно использовать специальные классы, которые будут служить как для передачи данных, так и для передачи ошибок, но это неудобно.[wpanchor >
Именно поэтому нам нужно рассмотреть другие возможности для выполнения сетевых запросов и для работы с данными. И в первую очередь такой возможностью является популярный фреймворк RxJava.
RxJava
Фреймворк RxJava позволяет использовать парадигму функционального реактивного программирования (FRP) в Android. Понять, что это значит, весьма непросто, поэтому требуется немало пояснений. Во-первых, слово функциональное означает то, что в FRP основным понятием являются функции и в этом эта парадигма схожа с обычным функциональным программированием. Конечно, в Android весьма затруднительно использовать полноценное функциональное программирование, но все же с помощью RxJava мы смещаем приоритет от объектов к функциям. Во-вторых, реактивное программирование означает программирование с асинхронными потоками данных. Проще всего это пояснить на практике: поток данных – это любой ваш запрос на сервер, данные из базы, да и обычный ввод данных от пользователя (если говорить совсем уж откровенно, то создать поток данных можно абсолютно из чего угодно), который чаще всего выполняется в фоновом потоке, то есть асинхронно. Если объединить два объяснения, то получим, что функциональное реактивное программирование – это программирование с асинхронными потоками данных, которыми можно манипулировать с помощью различных функций.
Определение звучит красиво, но только совсем непонятно, зачем это может понадобиться. Оказывается, еще как может. RxJava позволяет решить почти все проблемы, которые были озвучены во введении. В качестве основных преимуществ RxJava выделяются следующие:
И самое приятное, что все преимущества выше достигаются буквально за пару строчек кода!
Использовать RxJava непросто, а использовать ее правильно еще сложнее, и это требует достаточно долгого изучения. RxJava – это очень большой фреймворк, чтобы правильно работать с ним (и в частности с парадигмой функционального реактивного программирования), нужно очень много изучать и практиковаться. RxJava достойна отдельного курса, по ней существует огромное количество статей, и их число увеличивается с каждым днем. По RxJava написана уже не одна книга, поэтому нельзя надеяться, что можно хорошо изучить этот фреймворк в рамках одной лекции. Но мы постараемся рассмотреть основные возможности RxJava и то, как ее можно применить для Android.
Мы немного рассмотрели суть RxJava и функционального реактивного программирования, но чтобы продвинуться дальше, нам нужно знать основные элементы этого фреймворка, к примеру, что подразумевается под потоком данных и как его создать, что такое подписчик и как его использовать и так далее.
RxJava в качестве своей основы использует паттерн Observer. Как выглядит этот паттерн в классическом виде? Основными сущностями в нем являются объект, значение которого может изменяться, и подписчик, который может подписаться на эти изменения (каждый раз при изменении значения объекта у подписчика будет вызван определенный метод). Схематично это можно представить следующим образом: 
Суть RxJava почти такая же, только вместо одного объекта подписчики используют целый поток данных. Подписчик может подписаться на поток данных, и тогда он будет получать информацию о каждом новом элементе в потоке, о произошедших ошибках, а также о завершении потока.
Тогда схема для RxJava будет такой:
С подписчиком все более менее понятно, а что же такое поток данных? Поток данных – это всего лишь набор каких-то элементов (необязательно конечный), которые передаются подписчику. В качестве потока данных могут выступать как простые объекты и последовательности, так и бесконечные, последовательности и различные события, к примеру, ввод данных.
Рассмотрим один из примеров, который поможет понять, где именно встречаются потоки данных и как в работе с ними может помочь RxJava. Допустим, стоит задача искать людей с определенным именем, когда пользователь вводит текст в поле поиска. Ее можно решить следующими простыми строчками кода:
Начните с RxJava 2 для Android
Если вы разработчик для Android, то, возможно, вы слышали много хорошего о RxJava, популярной реализации библиотеки ReactiveX с открытым исходным кодом, которая переносит реактивное программирование на виртуальную машину Java (JVM).
RxJava разработан для того, чтобы избавиться от боли при работе с асинхронными потоками данных, хотя, как вы увидите, определение «данных» в RxJava довольно широкое. Поскольку RxJava является JVM-совместимой библиотекой, вы можете использовать ее на самых разных платформах, но в этой серии я покажу вам, как использовать RxJava 2 для разработки под Android.
К концу этой серии вы освоите все основы RxJava 2, так что вы сможете приступить к созданию высокореактивных приложений, которые могут обрабатывать широкий спектр синхронных и асинхронных данных — и все это с использованием кода, который будет более кратким и управляемым, чем обычно в состоянии достичь только с помощью Java.
В дополнение к введению для новичков в RxJava, если вы ветеран RxJava 1, который хочет совершить прыжок в RxJava 2, то эта серия поможет сделать этот переход максимально плавным. Хотя обновление до последней версии библиотеки может показаться не таким уж большим делом, RxJava 2 не является вашим типичным обновлением — это полное переписывание RxJava. С таким большим количеством изменений легко запутаться, поэтому, потратив некоторое время на ознакомление с RxJava 2 с точки зрения новичка, вы сможете сэкономить много времени и разочароваться в долгосрочной перспективе.
Другими основными строительными блоками RxJava являются операторы, поэтому во второй части я расскажу о различных способах использования операторов для преобразования, объединения, фильтрации и манипулирования данными вашего приложения.
В последней части мы выйдем за пределы базовой библиотеки RxJava и рассмотрим RxAndroid — целую библиотеку, которая содержит все специфичные для Android расширения, которые вам понадобятся, чтобы раскрыть весь потенциал реактивного программирования для Android.
Нам есть что рассказать, поэтому давайте начнем с основ:
Что такое RxJava?
RxJava — это библиотека, которая позволяет создавать приложения в стиле реактивного программирования. По своей сути реактивное программирование обеспечивает чистый и эффективный способ обработки и реагирования на потоки данных в реальном времени, включая данные с динамическими значениями.
Эти потоки данных не обязательно должны принимать форму традиционных типов данных, поскольку RxJava в значительной степени рассматривает все как поток данных — все, начиная от переменных и заканчивая свойствами, кэшами и даже событиями пользовательского ввода, такими как щелчки и пролистывания.
Чтобы создать этот рабочий поток потоков данных и объектов, которые на них реагируют, RxJava расширяет шаблон проектирования программного обеспечения Observer. По сути, в RxJava у вас есть объекты Observable которые генерируют поток данных, а затем завершаются, и объекты Observer которые подписываются на Observable s. Observer получает уведомление каждый раз, когда назначенный ему объект Observable испускает значение, ошибку или завершенный сигнал.
Итак, на очень высоком уровне RxJava — это все о:
Почему RxJava?
Изучение любой новой технологии требует времени и усилий, и как библиотека, ориентированная на данные, RxJava не всегда является самым простым API, с которым можно справиться.
Чтобы помочь вам решить, стоит ли изучение RxJava начальных инвестиций, давайте рассмотрим некоторые ключевые преимущества добавления библиотеки RxJava в ваши проекты Android.
Более краткий, читаемый код
Сложный, многословный и сложный для чтения код — это всегда плохие новости. Грязный код более подвержен ошибкам и другим недостаткам, и если какие-либо ошибки все же произойдут, вам придется гораздо сложнее отследить источник этих ошибок, если ваш код содержит ошибки.
Даже если ваш проект собирается без каких-либо ошибок, сложный код все еще может преследовать вас — обычно, когда вы решаете выпустить обновление для вашего приложения через несколько месяцев, загрузите свой проект и сразу столкнетесь со стеной запутанного, запутанного кода!
Многопоточность Made Easy
Современные приложения Android должны быть в состоянии многозадачности. По крайней мере, ваши пользователи будут ожидать продолжения взаимодействия с пользовательским интерфейсом вашего приложения, пока ваше приложение выполняет некоторую работу в фоновом режиме, например, управление сетевым подключением, загрузка файла или воспроизведение музыки. Проблема в том, что Android по умолчанию является однопоточным, поэтому, если ваше приложение когда-либо успешно справляется с несколькими задачами, вам нужно создать дополнительные потоки.
Еще раз, RxJava имеет гораздо более простое решение. Вы можете использовать оператор observeOn чтобы указать, что Observable должен отправлять свои уведомления, используя другой планировщик, который, по сути, позволяет отправлять данные Observable потоку по вашему выбору, включая основной поток пользовательского интерфейса.
Это означает, что с помощью всего двух строк кода вы можете создать новый поток и отправить результаты работы, выполненной в этом потоке, в основной поток пользовательского интерфейса Android:
Почему следует использовать RxJava в Android – краткое введение в RxJava
Мы продолжаем знакомить вас с нашим издательским поиском, и хотели прозондировать общественное мнение на тему RxJava.
В ближайшее время собираемся опубликовать более общий материал по реактивному программированию, которое нас также интересует не первый год, а сегодня предлагаем почитать о применении RxJava в Android, так как именно на этой платформе особенно важна динамичность и быстрота реагирования. Добро пожаловать под кат
В большинстве приложений Android мы реагируем на действия пользователя (щелчки, смахивание, т.д.), а тем временем в фоновом режиме идет какая-то другая работа (сетевая).
Оркестровка всех этих процессов – сложная задача, любой код рискует быстро превратиться в бесформенную кашу.
Например, не так просто послать по сети запрос к базе данных, а после его выполнения сразу начать одновременно выбирать и пользовательские сообщения, и настройки, а после завершения всей этой работы вывести приветственное сообщение.
Именно в таких случаях как нельзя кстати будет RxJava (ReactiveX) – библиотека, позволяющая соорганизовать множество действий, обусловленных определенными событиями в системе.
Работая с RxJava, можно будет забыть об обратных вызовах и адском управлении глобальным состоянием.
Вернемся к нашему примеру:
послать по сети запрос к базе данных, а после его выполнения сразу начать одновременно выбирать и пользовательские сообщения, и настройки, а после завершения всей этой работы вывести приветственное сообщение.
Если разобрать эту ситуацию подробнее, найдем в ней три основных этапа, причем все три происходят в фоновом режиме:
Чтобы сделать то же самое в Java SE и Android, нам бы потребовалось:
Уже понятно, что для этого требуется управлять состоянием, а также задействовать некоторые механизмы блокировки, существующие в Java.
Всего этого можно избежать, работая с RxJava (см. примеры ниже) – весь код выглядит как поток, расположенный в одном месте и строится на базе функциональной парадигмы (см. здесь).
Быстрый запуск в Android
Чтобы получить библиотеки, которые, скорее всего, понадобятся вам для проекта, вставьте в ваш файл build.gradle следующие строки:
Таким образом будут включены:
Здесь мы создали Observable, который сгенерирует два элемента — 1 и 2.
Мы подписались на observable, и теперь, как только элемент будет получен, мы выведем его на экран.
Объект Observable – такая сущность, на которую можно подписаться, а затем принимать генерируемые Observable элементы. Они могут создаваться самыми разными способами. Однако Observable обычно не начинает генерировать элементы, пока вы на них не подпишетесь.
После того, как вы подпишетесь на observable, вы получите Subscription (подписку). Подписка будет принимать объекты, поступающие от observable, пока он сам не просигнализирует, что завершил работу (не поставит такую отметку), либо (в очень редких случаях) прием будет продолжаться бесконечно.
Более того, все эти действия будут выполняться в главном потоке.
Управление сложным потоком
Помните сложный поток, описанный нами в самом начале?
Вот как он будет выглядеть с RxJava:
В таком случае будет создан новый пользователь (createNewUser()), и на этапе его создания и возвращения результата в то же самое время продолжится выбор пользовательских сообщений (fetchUserMessages()) и пользовательских настроек (fetchUserSettings). Мы дождемся завершения обоих действий и возвратим скомбинированный результат (Pair.create()).
Не забывайте – все это происходит в отдельном потоке (в фоновом режиме).
Затем программа выведет на экран полученные результаты. Наконец, список сообщений будет приспособлен еще в один observable, который будет выводить сообщения поодиночке, а не целым списком, причем каждое сообщение будет появляться в окне терминала.
Работать с RxJava будет гораздо проще, если вы знакомы с функциональным программированием, в частности, с концепциями map и zip. Кроме того, в RxJava и ФП очень похоже выстраивается обобщенная логика.
Как создать собственный observable?
Если код становится в значительной степени завязан на RxJava (например, здесь ), то зачастую вам придется писать собственные observable, так, чтобы они укладывались в логику вашей программы.
А вот похожий вариант, не требующий выполнять действие строго в конкретном потоке:
Здесь важно отметить три метода:
Кроме того, вероятно, будет удобно пользоваться RxJavaAsyncUtil.
Интеграция с другими библиотеками
По мере того, как RxJava становится все популярнее и де-факто превращается в стандарт асинхронного программирования в Android, все больше библиотек все в большей мере интегрируются с ней.
Всего несколько примеров:
Retrofit — «Типобезопасный HTTP-клиент для Android и Java»
SqlBrite — «Легкая обертка для SQLiteOpenHelper, обогащающая SQL-операции семантикой реактивных потоков.»
StorIO — «Красивый API для SQLiteDatabase и ContentResolver»
Все эти библиотеки значительно упрощают работу с HTTP-запросами и базами данных.
Интерактивность с Android UI
Это введение было бы неполным, если бы мы не рассмотрели, как использовать нативные UI-элементы в Android.
Очевидно, можно просто положиться на setOnClickListener, но в долгосрочной перспективе RxBinding может подойти вам лучше, поскольку позволяет подключить UI к общему потоку RxJava.
Практика показывает, что при работе с RxJava следует придерживаться некоторых правил.
Всегда использовать обработчик ошибок
Пропускать обработчик ошибок таким образом
обычно не следует. Исключение, выбрасываемое в наблюдателе или в одном из действий будет выброшено исключение, которое, скорее всего, убьет вам все приложение.
Еще лучше было бы сделать обобщенный обработчик:
Извлекать методы действий
Если у вас будет много внутренних классов, то через некоторое время удобочитаемость кода может испортиться (особенно если вы не работаете с RetroLambda).
выглядел бы лучше после такого рефакторинга:
Использовать собственные классы или кортежи
Бывают случаи, в которых некое значение определяется другим значением (например, пользователь и пользовательские настройки), и вы хотели бы получить оба этих значения при помощи двух асинхронных запросов.
В таких случаях рекомендую использовать JavaTuples.
Управление жизненным циклом
Зачастую бывает так, что фоновый процесс (подписка) должен просуществовать дольше, чем активность или фрагмент, в котором (которой) он содержится. Но что если результат вас уже не интересует, как только пользователь покинет активность?
В таких случаях вам поможет проект RxLifecycle.
Оберните ваш observable вот так (взято из документации) и сразу после его разрушения выполнится отписка:
Конечно, это далеко не полное руководство об использовании RxJava в Android, но, надеюсь, смог вас убедить, что в некоторых отношениях RxJava лучше обычных AsyncTask.