Book Image

Reactive Programming in Kotlin

By : Rivu Chakraborty
Book Image

Reactive Programming in Kotlin

By: Rivu Chakraborty

Overview of this book

In today's app-driven era, when programs are asynchronous, and responsiveness is so vital, reactive programming can help you write code that's more reliable, easier to scale, and better-performing. Reactive programming is revolutionary. With this practical book, Kotlin developers will first learn how to view problems in the reactive way, and then build programs that leverage the best features of this exciting new programming paradigm. You will begin with the general concepts of Reactive programming and then gradually move on to working with asynchronous data streams. You will dive into advanced techniques such as manipulating time in data-flow, customizing operators and provider and how to use the concurrency model to control asynchronicity of code and process event handlers effectively. You will then be introduced to functional reactive programming and will learn to apply FRP in practical use cases in Kotlin. This book will also take you one step forward by introducing you to Spring 5 and Spring Boot 2 using Kotlin. By the end of the book, you will be able to build real-world applications with reactive user interfaces as well as you'll learn to implement reactive programming paradigms in Android.

Related Content you might be interested in

Current Title:

Small book image
Reactive Programming in Kotlin
Rivu Chakraborty
Dec, 2017 | 322 pages
Small book image
Functional Kotlin
Rivu Chakraborty | Mario Arias
Feb, 2018 | 350 pages
Small book image
Learning RxJava
Thomas Nield | Nick Samoylov
Feb, 2020 | 412 pages
Small book image
Learning RxJava
Thomas Nield
Jun, 2017 | 400 pages
Table of Contents (20 chapters)
Title Page
Title Page
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Dedication
Dedication
Preface
Preface
Free Chapter
1
A Short Introduction to Reactive Programming
A Short Introduction to Reactive Programming
What is reactive programming?
Reasons to adapt functional reactive programming
Reactive Manifesto
Getting started with RxKotlin
The ReactiveCalculator project
Summary
2
Functional Programming with Kotlin and RxKotlin
Functional Programming with Kotlin and RxKotlin
Introducing functional programming
Fundamentals of functional programming
Applying functional programming to the ReactiveCalculator class
Coroutines
Functional programming – monads
Summary
3
Observables, Observers, and Subjects
Observables, Observers, and Subjects
Observables
Other Observable factory methods
Hot and Cold Observables
Varieties of Subject
Summary
4
Introduction to Backpressure and Flowables
Introduction to Backpressure and Flowables
Understanding backpressure
Flowable
When to use Flowables and Observables
Flowable and Subscriber
Creating Flowable from scratch
Creating Flowable from Observable
BackpressureStrategy.MISSING and onBackpressureXXX()
Generating Flowable with backpressure at source
ConnectableFlowable
Processor
Learning Buffer, Throttle, and Window operators
Summary
5
Asynchronous Data Operators and Transformations
Asynchronous Data Operators and Transformations
Operator
The filtering/suppressing operators
The transforming operators
Reducing operators
The error handling operators
The utility operators
Summary
6
More on Operators and Error Handling
More on Operators and Error Handling
Combining producers (Observable/Flowable)
Grouping
flatMap, concatMap – In details
Understanding switchMap operator
Skipping and taking emissions
The error handling operators
onErrorReturn – return a default value on error
The onErrorResumeNext operator
An HTTP example
Summary
7
Concurrency and Parallel Processing in RxKotlin with Schedulers
Concurrency and Parallel Processing in RxKotlin with Schedulers
Introduction to concurrency
Parallel execution versus concurrency
What is a scheduler?
How to use schedulers – subscribeOn and observeOn operators
Summary
8
Testing RxKotlin Applications
Testing RxKotlin Applications
Introduction to unit testing and its importance
Writing JUnit tests in Kotlin
Testing in RxKotlin
Blocking subscribers
Blocking operators
Introducing TestObserver and TestSubscriber
Understanding TestScheduler
Summary
9
Resource Management and Extending RxKotlin
Resource Management and Extending RxKotlin
Resource management
Creating your own operators
Composing operators with transformer
Summary
10
Introduction to Web Programming with Spring for Kotlin Developers
Introduction to Web Programming with Spring for Kotlin Developers
Spring, history, and origin of Spring
Dependency injection and IoC
Spring – AOP
Introduction to Spring Boot
Creating a Rest API with Spring Boot
Summary
11
REST APIs with Spring JPA and Hibernate
REST APIs with Spring JPA and Hibernate
REST API with Spring Boot, Hibernate, and JPA
Reactive programming with Reactor
Summary
12
Reactive Kotlin and Android
Reactive Kotlin and Android
Setting up Kotlin in Android Studio
Getting started with ToDoApp on Android
Retrofit 2 for API calls
RxKotlin with Retrofit
Making Android events reactive
Kotlin extensions
Summary

Chapter 3. Observables, Observers, and Subjects

Observables and subscribers are at the base of reactive programming. We can say that they are the building blocks of reactive programming. In the previous two chapters, you already got a glimpse of Observables and subject. We observed on data with observable/subject instances; but that's not all we want; instead, we want to get all the actions and data changes reactively into the observable instances, making the application completely reactive. Also, while reading the previous chapters, you may have wondered how exactly does it operate? In this chapter, let's have a foundation of the pillars of reactive programming—Observables, Observers, and subjects:

  • We will look into details of transforming various data sources to observable instances
  • You will learn about various types of Observables
  • How to use Observer instances and subscriptions, and, lastly, subjects and their various implementations

We will also learn about various factory methods of Observable...

Previous Section
End of Section 1
Next Section