Reactive Programming in Java 8 With RxJava

This course covers a wide range of topics related to Reactive Programming using Java 8.
Course info
Rating
(208)
Level
Intermediate
Updated
Jun 23, 2014
Duration
2h 30m
Table of contents
Description
Course info
Rating
(208)
Level
Intermediate
Updated
Jun 23, 2014
Duration
2h 30m
Description

Cloud Computing has changed the landscape for software developers over the last several years. With the expansion in scale of our systems, the expectations of our users has grown in proportion. The level of responsiveness and resiliency required by modern cloud-based applications has strained our standard "one logical thread" approach to software. This approach provides a simplification for the software developer, but it can fall short in the face of a cloud based environment and often doesn't fully utilize the underlying hardware. This course will cover Reactive Programming and the tenants of the Reactive Manifesto using Java 8, with supplementary material for Java 7. We will examine the use of the RxJava Reactive Extension's asynchronous model, and learn to apply it in order to create scalable, responsive, and resilient applications that are well behaved, even while in failure modes.

About the author
About the author

Russell has been a lover of all things software development since the age of 13. By day Russell is a mild mannered Manager of Enterprise Architecture for a prominent healthcare software vendor. By night a student of new technologies, languages, and all things that are, well, just flat out cool.

Section Introduction Transcripts
Section Introduction Transcripts

Observable Creation, Composition, and Filtering
Hello, welcome to Module 2 of Reactive Programming in Java 8 with RxJava. In this module we will look at three topics. "Observable" Creation: we'll cover how to create Observables, the life cycle of an Observable, and the basics on how RxJava handles asynchronously execution. Composition: we will illustrate how different Observables are composited together. This is the heart of RxJava's event driven model and supports lazy execution of our event handlers. And then Filtering: we will cover how to include filter operations in our composite Observables in order to remove unwanted data, as well as several time-based operations that can be extremely useful to a busy system.

Observables Transformations and Conditional Operations
Hello, I'm Russell Elledge and welcome to Module 3 of Reactive Programming in Java 8 with RxJava. In this module we'll be talking about two primary concepts. Transformations: taking events from the event stream and transforming them based on the logic of your choice into a different event or multiple events. Conditional Operations: conditional operations allow you to control one event stream using another event stream as a trigger. And we'll look at quite a few code examples around how to use conditional operations.

Connectable Observables and Resource Management
Hello, welcome to Module 4 of Reactive Programming in Java 8 with RxJava. In this module we will extend our knowledge of RxJava by examining three topics. First, connectable observables: this is a new type of observable that allows us to set up multiple event listeners and control when an observable begins to emit events to subscribers. Next, we'll look at resource management. We will go over some examples that will illustrate how to manage resources like database connections in a way that works cooperatively with RxJava. And finally, subjects. Subjects are the mechanism in RxJava that allows us to structure our code in a more event driven publish/subscribe style.

Implementation Patterns
Hello, welcome to Module 5 of Reactive Programming in Java 8 with RxJava. For this final module we will look at two useful patterns that can be implemented using RxJava. First we will examine an event driven programming example. I will illustrate how the usual imperative style of programming can be decomposed into an event driven model that yields better separation of your components or services. And then we will look at using RxJava to aggregate information from several simulated microservices. We will use the Derby database engine again in order to illustrate several key ideas that will help you use RxJava in your own applications.