Practical Reactive Streams with Akka and Java

Practical Reactive Streams with Akka and Java

What you’ll learn

What are reactive streams and when should you use them
How to build asynchronous, non-blocking, reative streams with back-pressure
The Akka Streams API and GraphDSL
How to correctly implement asynchronous boundaries and parallelism
How to integrate Akka Actors into reactive streams

Requirements

Basic Java knowledge
Knowledge of Akka using Java and the Akka Typed API is needed
This is a follow on course to the “Practical Java concurrency with the Akka Actor Model” course

Description

This course builds on the “Practical Java concurrency with the Akka Actor Model” course and will extend your knowledge of using the actor model with Akka and Java to create reactive streams.Reactive Streams are an essential tool in building real-world concurrent applications with the actor model – they allow us to build more complex processing scenarios, deal with varying data loads effectively, and provide the foundation for connecting our applications to external systems (which is covered in the Akka Http course).For developers new to this technology it can be tough to get started, so in this course we cover everything from scratch. We build up the knowlege step by step, meaning you’ll have no problems following along and understanding everything we do. The course is full of practical real-world scenarios – we’ll be taking the blockchain mining application that we built in the Practical Java concurrency with the Akka Actor Model course a few steps further to make it even more realistic.Please note that although Akka is built in Scala, no Scala knowledge is needed for this course – the course covers Akka with Java and we won’t be writing any Scala code.This course covers the newer Akka Typed API only.

Overview

Section 1: Chapter 1 – Introduction

Lecture 1 What are reactive streams?

Lecture 2 Course files

Lecture 3 How to get support for this course

Section 2: Chapter 2 – Creating our first stream

Lecture 4 A note about external sources

Lecture 5 Using the Akka libraries

Lecture 6 Creating a source

Lecture 7 Creating a sink

Lecture 8 Creating a flow

Lecture 9 Building and running a graph

Section 3: Chapter 3 – Simple Sources and Sinks

Lecture 10 Finite Sources

Lecture 11 Infinite Sources

Lecture 12 Basic source operators

Lecture 13 Creating sinks

Lecture 14 Graph convenience methods

Section 4: Chapter 4 – Simple Flows

Lecture 15 Map and Filter

Lecture 16 MapConcat

Lecture 17 Grouped

Lecture 18 Flows of generic data types

Lecture 19 Combining flows with sinks and sources

Section 5: Chapter 5 – Exercise 1 – Big Primes

Lecture 20 Exercise

Lecture 21 Walkthrough

Section 6: Chapter 6 – Materialized values

Lecture 22 What are materialized values?

Lecture 23 The fold method and selecting a materialized value for the graph

Lecture 24 Terminating the actor system

Lecture 25 The reduce method

Section 7: Chapter 7 – Stream lifecycles

Lecture 26 Re-using graph objects

Lecture 27 Converting infinite streams to finite streams with take and limit

Lecture 28 The takeWhile and takeWithin functions

Section 8: Chapter 8 – Logging

Lecture 29 Logging elements in a stream

Section 9: Chapter 9 – Back pressure and graph performance

Lecture 30 Asynchronous boundaries

Lecture 31 Introducing back-pressure

Lecture 32 Adding buffers to the graph

Lecture 33 Other overflow strategies

Lecture 34 Parallelism

Section 10: Chapter 10 – Exercise 2 – monitoring vehicle speed

Lecture 35 Instructions to create an optimised graph with a materalised value

Lecture 36 Walkthrough

Section 11: Chapter 11 – The GraphDSL

Lecture 37 Why do we need the GraphDSL?

Lecture 38 Introducing the GraphDSL Syntax

Lecture 39 Constructing a simple Graph using the GraphDSL

Lecture 40 Understanding the Graph Construction and introducing Asynchronous Boundaries

Section 12: Chapter 12 – Complex flow types

Lecture 41 Introducing fan-in and fan-out shapes

Lecture 42 Broadcast and merge

Lecture 43 Using Balance for parallelilsm

Lecture 44 Exercise 3 – implementing parallelism in GraphDSL

Lecture 45 Uniform fan-in and fan-out shapes

Lecture 46 Non uniform fan-in and fan-out shapes

Section 13: Chapter 13 – Graphs with multiple sources and sinks

Lecture 47 Combining sources with a fan-in shape

Lecture 48 Sending to an interim sink with alsoTo

Lecture 49 Diverting outliers to a different sink with divertTo

Section 14: Chapter 14 – Non-runnable or partial graphs

Lecture 50 Creating and combining open shapes

Lecture 51 Using open shapes outside the graphDSL

Section 15: Chapter 15 – Using actors in graphs

Lecture 52 Adding an actor to our project

Lecture 53 Using actors as flows

Lecture 54 Using actors as sinks

Section 16: Chapter 16 – Advanced backpressure

Lecture 55 Conflate

Lecture 56 Extrapolate and expand

Section 17: Chapter 17 – The java flow package

Lecture 57 Java’s reactive streams interfaces

Section 18: Chapter 18 – Case Study – Blockchain mining

Lecture 58 Introducing the case study

Lecture 59 Exercise 4 – receive transactions with backpressure

Lecture 60 Walkthrough

Lecture 61 Exercise 5 – mine using actors and apply the result

Lecture 62 Walkthrough

Lecture 63 Creating a circular graph

Section 19: Appendix

Lecture 64 A simple introduction to blockchains

Lecture 65 Bonus lecture

Novice and experienced Java developers who need to enhance their concurrent programming skills.,Programmers who need to implement reactive streams

Course Information:

Udemy | English | 8h 35m | 4.77 GB
Created by: Matt Greencroft

You Can See More Courses in the Developer >> Greetings from CourseDown.com