Reactive Programming in Java using RXJava 3.x - ReactiveX

Explore the fundamentals of reactive programming with RxJava, including the reactive manifesto's properties - responsive, elastic, resilient, and message driven - plus push and pull, callbacks, and the observer pattern.

Explore the reactive programming paradigm and the reactive manifesto's core properties, responsive, resilient, elastic, and message driven, using RxJava 3.x to build asynchronous systems.

Expose the contrast between sync and async execution, explain asynchrony via concurrency, and show how callbacks become hard with many events, while RxJava simplifies concurrency and completion signals.

Explore callbacks in asynchronous programming with a simple thread example, highlighting callback hell and how rx java and the observer pattern simplify callback management.

Explain push versus pull in RxJava, contrasting the pull-based request-response model with RxJava's push-based design using the observer pattern and push data and errors.

Explore how the observer design pattern in RxJava builds one-to-many dependencies where a subject notifies registered observers of state changes, with subscribe, unsubscribe, and update actions in a library example.

Explore the differences between concurrency and parallelism, learn how threads and fork-join pool enable multi-threading, and see how RxJava schedulers simplify concurrent and parallel programming.

Discover how RxJava uses the observer pattern with push-based asynchronous streams, handling data, error, and complete signals as separate channels, and apply operators and backpressure for scalable parallel processing.

Explore how the rx java api is composed with reactive streams, including observable, observer, and flowable, and how Java 9 and TCK enable interoperable backpressure ready streams.

Discover the fundamentals of reactive programming and the reactive manifesto, including the properties of responsive, elastic, resilient, and message driven systems, plus rx java's push based model.

Begin the RxJava section by setting up RxJava and exploring reactive programming with RxJava, starting with writing a small hello RxJava program to get started.

Set up RxJava 3.x in Eclipse IDE with Maven, adding reactive streams dependencies in the pom file. Prepare a hello RxJava program for the next lecture.

Explores RxJava basics by creating a simple observable, emitting strings, and subscribing observers to demonstrate reactive streams and the observer pattern.

Set up rxjava 3.x and write a simple hello rx rxjava program to preview observable and observer concepts, with a promise to cover them in the next section.

Explore the fundamentals of observable and observer patterns in RxJava 3.x, including cold and hot observables, connectable variants, and unsubscribing mechanics.

Compare observable and observer concepts in RxJava 3.x, showing push-based data flow and the subscribe lifecycle with onNext, onComplete, and onError events.

Learn how to create observables in RxJava 3.x using create, just, from iterable, range, interval, empty, never, defer, from callable, and from future, with their emission and completion behavior.

Explore creating observers in RxJava 3 by using anonymous inner classes or lambda-based signatures for onNext, onError, and onComplete, including one-, two-, and three-argument forms with practical print outputs.

Explore how cold and hot observables differ in RxJava 3.x, and see how cold observables replay data for each subscription while hot observables emit once and share data across observers.

Learn how connectable observables convert a cold observable into a hot multi-cast stream, so multiple subscribers receive emissions simultaneously, with late subscribers starting from current emission, illustrated using interval.

Explore single, maybe, and completable in RxJava 3, learning how each handles emission, on success, on error, and on complete.

Learn how to unsubscribe from observables using dispose and composite disposable in RxJava 3.x, safely disposing resources and stopping emissions for unbounded streams.

Explore how to create observables and observers, how observables interact with observers, including hot and cold, connectable observables, and the types single, may be completable, and disposing an observable.

Explore basic operators in RxJava that manipulate and transform data emitted by observables, learn why they are used, classify them, and see a practical example.

Explore how operators transform data emitted by the source observable, acting as both observer and observable, using filter and sorted to produce a downstream observable with sorted results.

Explore rx java operator categories: suppressing, transforming, reducing, collection, error recovery, and action operators such as filter, map, reduce, toList, and do on next.

Filter by rating, sort by rating, and map to names in rxjava for a top four list. Use scan to compute cumulative expenses and reduce for the final 2019 total.

Learn how RxJava operators transform data, suppress emissions, and reduce emissions, and explore combining observables, concurrency, and multicasting for reactive programming.

Learn to combine multiple observables into one using RxJava 3.x operators such as concat, merge, zip, and amb to aggregate microservice responses for UI display.

Explore rxjava's merge and concat for combining emissions from multiple observables; merge interleaves outputs while concat preserves order, with overloads for two to four sources and interval-based demos.

Compare flat map and concat map in reactive programming, where flat map merges inner observables producing interleaved emissions, while concat map concatenates them for sequential emissions.

Use the amb operator to pick the faster among multiple observables and emit its events, leveraging parallel processing to speed up data emission.

Compare zip and combine latest in rxjava, showing how zip pairs emissions from two observables using a zipper function, while combine latest merges on the latest emissions from each source.

Group by groups employees by a rating key into grouped observables, then convert each group to a map of rating to names using flatMap and a multi-map collector.

Explore how to combine observable emissions in RxJava 3.x using merge, concat, flatMap, concatMap, amb, zip, combineLatest, and groupBy.

Explore replaying, caching, and subjects to reduce duplicated work in RxJava by multicasting a single result to all observers, avoiding repeated network requests.

Leverage replay and cache in RxJava 3.x to replay prior emissions for late observers via a connectable observable and a single subscription.

Subjects act as both observer and observable, bridging multiple sources to emit to multiple observers, multicast, hot, and merge emissions from those sources.

Explore how subjects add emissions to the final stream with onNext, onError, and onComplete, broadcasting to multiple observers, highlighting hot behavior and the need for multicast via publish or replay.

Explore the five RxJava subject implementations - publish, replay, behavior, async, and unicast - showing how each emits data at subscription, caches items, or releases the last value after completion.

Explore RxJava 3.x reactive concepts: replay and cache operators, connectable vs observable, and subjects including publish, behavior, replay, async, and unicast, with multicast and emission management, ahead of concurrency topics.

Explore how to add concurrency to synchronized observable chains using RxJava, learn about schedulers for parallelization, and master subscribeOn, observeOn, and flatMap to run emissions in parallel.

Explore how to inject concurrency into RxJava programs by using threads and runnables, while preserving the observable contract and learning how schedulers enable asynchronous task execution.

Explore how rx java schedulers allocate threads for computation, io, new thread, single, trampoline, and custom schedulers from executor services.

Learn how subscribeOn schedules upstream emissions in RxJava using a chosen scheduler. When multiple subscribeOn calls exist, the one closest to the source wins, enabling asynchronous behavior.

ObserveOn switches to a different scheduler in the chain, affecting downstream while upstream remains unchanged. It can cause a producer-consumer gap, prompting the use of flowable and back pressure.

Learn how to use flatMap in rxjava 3 to process emissions concurrently by converting each emission into an observable and subscribing on the computation scheduler, balancing parallelism with overhead.

Cover concurrency and parallelization in RxJava 3.x using schedulers, subscribeOn, observeOn, and flatMap to run emissions in parallel. Next section will address handling emissions faster than a consumer can process.

Explore buffer, window, throttle, and switch map operators to batch emissions into data chunks or emit in a specific time slice.

Explore rx java buffer and window operators to batch emissions, handle back pressure, and perform time-based or boundary-based buffering to feed observers efficiently.

Explore throttle operators in RxJava 3, including throttle first, throttle last (sample), and throttle with time out (debounce) to filter rapid or redundant emissions, such as repeated button clicks.

SwitchMap in RxJava 3.x subscribes to the latest emitted observable and disposes previous ones, preventing redundant processing by canceling active tasks.

Explore buffering, windowing, throttling, and switching to cope with faster emitting observables, and apply flowable and back pressure for source emission control in timer events and user inputs.

Explore back pressure and why we need it. Learn to implement it with flowable and subscriber, and compare flowable with observables to decide when to use each.

Explore why backpressure is essential when concurrency speeds up production and can outrun the consumer. Discover how backpressure prevents unbounded backlog and out-of-memory errors in reactive streams.

Learn how Flowable replaces observable to implement backpressure, with a subscriber and subscription controlling demand via request, batching 20 items and addressing the producer-consumer problem.

Learn how to create a flowable with a back pressure strategy in RxJava 3.x, exploring buffer, drop, latest, error, and missing, and why backpressure matters.

Differentiate observable and flowable, using flowable for large, asynchronous emissions and io operations, and observable for smaller, synchronous streams; convert between them with toFlowable and back to observable.

Learn how to handle producers emitting data faster than consumers with a flowable subscriber, and decide when to use flowable vs observable; explore creating flowables and backpressure strategies.