Реактивное программирование с применением RxJava : разработка асинхронных событийно-ориентированных приложений

Содержание книги "Реактивное программирование с применением RxJava : разработка асинхронных событийно-ориентированных приложений"

Предисловие
Вступление
Для кого написана эта книга
Несколько слов от Бена Кристенсена
Несколько слов от Томаша Нуркевича
О содержании книги
Ресурсы в Сети
Графические выделения
Как с нами связаться
Благодарности
От Бена
От Томаша
Глава 1. Реактивное программирование с применением RxJava
Реактивное программирование и RxJava
Когда возникает нужда в реактивном программировании
Как работает RxJava
Проталкивание и вытягивание
Синхронный и асинхронный режим
Конкурентность и параллелизм
Ленивые и энергичные типы
Двойственность
Одно или несколько?
Учет особенностей оборудования: блокирующий и неблокирующий ввод-вывод
Абстракция реактивности
Глава 2. Реактивные расширения
Анатомия rx.Observable
Подписка на уведомления от объекта Observable
Получение всех уведомлений с помощью типа Observer
Управление прослушивателями с помощью типов Subscription и Subscriber
Создание объектов Observable
Подробнее о методе Observable.create()
Бесконечные потоки
Хронометраж: операторы timer() и interval()
Горячие и холодные объекты Observable
Практический пример: от API обратных вызовов к потоку Observable
Управление подписчиками вручную
Класс rx.subjects.Subject
Тип ConnectableObservable
Реализация единственной подписки с помощью publish().refCount()
Жизненный цикл ConnectableObservable
Резюме
Глава 3. Операторы и преобразования
Базовые операторы: отображение и фильтрация
Взаимно однозначные преобразования с помощью map()
Обертывание с помощью flatMap()
Откладывание событий с помощью оператора delay()
Порядок событий после flatMap()
Сохранение порядка с помощью concatMap()
Более одного объекта Observable
Обращение с несколькими объектами Observable, как с одним, с помощью merge()
Попарная композиция с помощью zip() и zipWith()
Когда потоки не синхронизированы: combineLatest(), withLatestFrom() и amb()
Более сложные операторы: collect(), reduce(), scan(), distinct() и groupBy()
Просмотр последовательности с помощью Scan и Reduce
Редукция с помощью изменяемого аккумулятора: collect()
Проверка того, что Observable содержит ровно один элемент, с помощью single()
Устранение дубликатов с помощью distinct() и distinctUntilChanged()
Выборка с помощью операторов skip(), takeWhile() и прочих
Способы комбинирования потоков: concat(), merge() и switchOnNext()
Расщепление потока по условию с помощью groupBy()
Написание пользовательских операторов
Повторное использование операторов с помощью compose()
Реализация более сложных операторов с помощью lift()
Резюме
Глава 4. Применение реактивного программирования в существующих приложениях
От коллекций к Observable
BlockingObservable: выход из реактивного мира
О пользе лени
Композиция объектов Observable
Ленивое разбиение на страницы и конкатенация
Императивная конкурентность
flatMap() как оператор асинхронного сцепления
Замена обратных вызовов потоками
Периодический опрос изменений
Многопоточность в RxJava
Что такое диспетчер?
Декларативная подписка с помощью subscribeOn()
Конкурентность и поведение subscribeOn()
Создание пакета запросов с помощью groupBy()
Декларативная конкурентность с помощью observeOn()
Другие применения диспетчеров
Резюме
Глава 5. Реактивность сверху донизу
Решение проблемы C10k
Традиционные HTTP-серверы на основе потоков
Неблокирующий HTTP-сервер на основе Netty и RxNetty
Сравнение производительности блокирующего и реактивного сервера
Обзор реактивных HTTP-серверов
Код HTTP-клиента
Доступ к реляционной базе данных
NOTIFY и LISTEN на примере PostgreSQL
CompletableFuture и потоки
Краткое введение в CompletableFuture
Сравнение типов Observable и Single
Создание и потребление объектов типа Single
Объединение ответов с помощью zip, merge и concat
Интероперабельность с Observable и CompletableFuture
Когда использовать тип Single?
Резюме
Глава 6. Управление потоком и противодавление
Управление потоком
Периодическая выборка и отбрасывание событий
Скользящее окно
Пропуск устаревших событий с помощью debounce()
Противодавление
Противодавление в RxJava
Встроенное противодавление
Производители и исключение MissingBackpressureException
Учет запрошенного объема данных
Резюме
Глава 7. Тестирование и отладка
Обработка ошибок
А где же мои исключения?
Декларативная замена try-catch
Таймаут в случае отсутствия событий
Повтор после ошибки
Тестирование и отладка
Виртуальное время
Диспетчеры и автономное тестирование
Автономное тестирование
Мониторинг и отладка
Обратные вызовы doOn...()
Измерение и мониторинг
Резюме
Глава 8. Практические примеры
Применение RxJava в разработке программ для Android
Предотвращение утечек памяти в компонентах Activity
Библиотека Retrofit со встроенной поддержкой RxJava
Диспетчеры в Android
События пользовательского интерфейса как потоки
Управление отказами с помощью Hystrix
Hystrix: первые шаги
Неблокирующие команды и HystrixObservableCommand
Паттерн Переборка и быстрое прекращение
Пакетирование и объединение команд
Мониторинг и инструментальные панели
Опрос баз данных NoSQL
Клиенстский API Couchbase
Клиентский API MongoDB
Интеграция с Camel
Потребление файлов с помощью Camel
Получение сообщений от Kafka
Потоки Java 8 и CompletableFuture
Полезность параллельных потоков
Выбор подходящей абстракции конкурентности
Когда выбирать Observable?
Потребление памяти и утечки
Операторы, потребляющие неконтролируемый объем памяти
Резюме
Глава 9. Направления будущего развития
Реактивные потоки
Типы Observable и Flowable
Производительность
Миграция
Приложение А. Дополнительные примеры HTTP-серверов
Системный вызов fork() в программе на C
Один поток – одно подключение
Пул потоков для обслуживания подключений
Приложение B. Решающее дерево для выбора операторов Observable
Об авторах
Об изображении на обложке
Предметный указатель