Reactive Programming in Kotlin电子书

Title Page

Copyright

Reactive Programming in Kotlin

Credits

About the Author

About the Reviewers

www.PacktPub.com

Why subscribe?

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

A Short Introduction to Reactive Programming

What is reactive programming?

Reasons to adapt functional reactive programming

Reactive Manifesto

Reactive Streams standard specifications

Reactive Frameworks for Kotlin

Getting started with RxKotlin

Downloading and setting up RxKotlin

Comparing the pull mechanism with the RxJava push mechanism

The ReactiveEvenOdd program

The ReactiveCalculator project

Summary

Functional Programming with Kotlin and RxKotlin

Introducing functional programming

Fundamentals of functional programming

Lambda expressions

Pure function

High-order functions

Inline functions

Applying functional programming to the ReactiveCalculator class

Coroutines

Getting started with coroutines

Building sequences

The ReactiveCalculator class with coroutines

Functional programming – monads

Single monad

Summary

Observables, Observers, and Subjects

Observables

How Observable works

Understanding the Observable.create method

Understanding the Observable.from methods

Understanding the toObservable extension function

Understanding the Observable.just method

Other Observable factory methods

Subscribers - the Observer interface

Subscribing and disposing

Hot and Cold Observables

Cold Observables

Hot Observables

Introducing the ConnectableObservable object

Subjects

Varieties of Subject

Understanding AsyncSubject

Understanding PublishSubject

Understanding BehaviorSubject

Understanding ReplaySubject

Summary

Introduction to Backpressure and Flowables

Understanding backpressure

Flowable

When to use Flowables and Observables

When to use Flowables?

When to use Observables?

Flowable and Subscriber

Creating Flowable from scratch

Creating Flowable from Observable

BackpressureStrategy.MISSING and onBackpressureXXX()

Operator onBackpressureBuffer()

Operator onBackpressureDrop()

Operator onBackpressureLatest()

Generating Flowable with backpressure at source

ConnectableFlowable

Processor

Learning Buffer, Throttle, and Window operators

The buffer() operator

The window() operator

The throttle() operators

Summary

Asynchronous Data Operators and Transformations

Operator

The filtering/suppressing operators

The debounce operator

The distinct operators – distinct, distinctUntilChanged

The elementAt operator

Filtering emissions - filter operator

The first and last operator

The ignoreElements operator

The transforming operators

The map operator

Casting emissions (cast operator)

The flatMap operator

The defaultIfEmpty operator

The switchIfEmpty operator

The startWith operator

Sorting emissions (sorted operator)

Accumulating data – scan operator

Reducing operators

Counting emissions (count operator)

Accumulating emissions – reduce operator

The collection operators

The error handling operators

The utility operators

Summary

More on Operators and Error Handling

Combining producers (Observable/Flowable)

The startWith operator

Zipping emissions – zip operator

The zipWith operator

The combineLatest operator

Merging Observables/Flowables – merge operator

Concatenating producers (Observable/Flowable)

Ambiguously combining producers

Grouping

flatMap, concatMap – In details

When to use flatMap operator

When to use concatMap operator

Understanding switchMap operator

Skipping and taking emissions

Skipping emissions (skip, skipLast, skipUntil, and skipWhile)

Take operators (take, takeLast, takeWhile, and takeUntil)

The error handling operators

onErrorReturn – return a default value on error

The onErrorResumeNext operator

Retrying on error

An HTTP example

Summary

Concurrency and Parallel Processing in RxKotlin with Schedulers

Introduction to concurrency

Parallel execution versus concurrency

What is a scheduler?

Types of scheduler

Schedulers.io() - I/O bound scheduler

Schedulers.computation() - CPU bound schedulers

Schedulers.newThread()

Schedulers.single()

Schedulers.trampoline()

Schedulers.from

How to use schedulers – subscribeOn and observeOn operators

Changing thread on subscription – subscribeOn operator

Observing on a different thread – observeOn operator

Summary

Testing RxKotlin Applications

Introduction to unit testing and its importance

Why is unit testing so important?

Writing JUnit tests in Kotlin

Testing your code

Testing in RxKotlin

Blocking subscribers

Blocking operators

Getting the first emitted item – blockingFirst()

Getting the only item from single or maybe - blockingGet

Getting the last Item - blockingLast

Getting all emissions as iterable - blockingIterable operator

Looping through all emissions - blockingForEach

Introducing TestObserver and TestSubscriber

Understanding TestScheduler

Summary

Resource Management and Extending RxKotlin

Resource management

Creating your own operators

Composing operators with transformer

Summary

Introduction to Web Programming with Spring for Kotlin Developers

Spring, history, and origin of Spring

The origin and history of Spring

Dependency injection and IoC

Spring Annotation configuration

Spring – AOP

Introduction to Spring Boot

Creating a Rest API with Spring Boot

Summary

REST APIs with Spring JPA and Hibernate

REST API with Spring Boot, Hibernate, and JPA

Reactive programming with Reactor

Add Reactor to your project

Understanding Flux and Mono

Summary

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

Introducing RxBinding in Android

Kotlin extensions

Summary