Reactive Programming in Java Using RxJava 3.x: ReactiveX

Video description

In this course, you'll learn about Reactive programming and libraries such as RxJava and Reactor that are designed to keep the application responsive and make the system more resilient.

The course starts by helping you understand the fundamentals of RxJava to make it easy for you to learn advanced topics such as the Reactive Manifesto, callbacks, callback hell, sync vs async, concurrent vs parallel, and the observer design pattern. As you advance, you'll also dive into the concepts of observable and observers, operators, combining observables, and replaying caching and subjects. You'll then explore concurrency and parallelism and get to grips with buffering, throttling, and switching.

By the end of the course, you'll have developed a solid understanding of Reactive programming concepts and RxJAVA.

What You Will Learn

  • Get to grips with Reactive programming fundamentals
  • Explore RxJava 3 and its features
  • Understand the implementation of Java Reactive Streams
  • Learn about the observer design pattern
  • Explore the different Streams in Java with the help of coding examples

Audience

If you want to learn RxJava and Reactive programming and use them to create amazing applications, this course is for you.

About The Author

Basics Strong: Basics Strong is a team of technocrats from IITs who focus on solving problems using technology. They work on mission-critical projects in AI, machine learning, and BlockChain as a domain and use Java, Python, JavaScript, and a lot of tools and technologies. They love to code and program.

The team believes that a strong foundation in the basics of programming concepts can help you solve any technical problem and excel in your career. Therefore, they create courses that help you build your basics and come up with ways to make complicated concepts easy to learn. All their courses are carefully crafted to include hands-on examples and comprehensive working files for practical learning.

Publisher resources

Download Example Code

Table of contents

  1. Chapter 1 : Introduction
    1. Introduction
  2. Chapter 2 : Reactive Programming Introduction
    1. Introduction
    2. Reactive Manifesto
    3. Fundamentals 1 - Sync Vs Async
    4. Fundamentals 2 - CallBack Hell
    5. Fundamentals 3 - Push vs Pull
    6. Fundamentals 4 - Observer Design Pattern
    7. Fundamentals 5 -Concurrency and Parallel programming
    8. RxJava BIG Picture : How It Solves The Problems And Achieve Reactive Manifesto
    9. RxJava, Reactive Streams
    10. Summary
  3. Chapter 3 : Hello RxJava!
    1. Introduction
    2. Setting Up RxJava 3.x
    3. Hello RxJava!
    4. Summary
  4. Chapter 4 : The Observable And Observers
    1. Introduction
    2. Observable - Observer
    3. Creating Observable
    4. Creating Observer
    5. Hot And Cold Observables
    6. Connectable Observables : Multi-Casting
    7. Variants
    8. Disposing Resources
    9. Summary
  5. Chapter 5 : Operators
    1. Introduction
    2. What Are Operators?
    3. Types Of Operators
    4. Operators In Action
    5. Summary
  6. Chapter 6 : Combining Observables
    1. Introduction
    2. Merging V/s Concatenating
    3. FlatMap V/s ConcatMap
    4. Disposing Of Duplicate Emitting Sources : amb()
    5. Zipping V/s CombineLatest
    6. Grouping And Grouped Observable
    7. Summary
  7. Chapter 7 : Subjects, Replaying and Caching : Ways to Multicast
    1. Introduction
    2. Replaying And Caching
    3. Subjects?
    4. Adding Emissions Using Subject
    5. Subject - Various Implementations
    6. Summary
  8. Chapter 8 : Concurrency and Parallelization
    1. Introduction
    2. How To?
    3. Schedulers
    4. subscribeOn()
    5. observeOn()
    6. The flatMap() To Achieve Concurrency
    7. Summary
  9. Chapter 9 : Buffering, Throttling, Switching
    1. Introduction
    2. Buffer() And Window()
    3. Throttle Operators
    4. switchMap()
    5. Summary
  10. Chapter 10 : Flowable and Backpressure
    1. Introduction
    2. Need of Backpressure
    3. Backpressuring with Flowable - Subscriber
    4. Creation and Backpressure Strategies
    5. Flowable vs Observable
    6. Summary

Product information

  • Title: Reactive Programming in Java Using RxJava 3.x: ReactiveX
  • Author(s): Basics Strong
  • Release date: May 2020
  • Publisher(s): Packt Publishing
  • ISBN: 9781800565685