Practical Reactive Streams with Akka and Java

Learn to build reactive streams with Akka and Java by simulating external data sources within projects, while postponing real external connections to a future course on Akka HTTP.

Learn Akka streams basics by building a simple finite source of integers, a flow to string, and a sink to print results, using simple syntax and a graph DSL.

Create a finite source of integers 1 to 10 using akka.stream.javadsl source.range, and connect the source with a flow and sink to form and run a graph.

Create a sink in Akka streams that receives strings and prints each value to the console using a foreach sink and a concise Java lambda.

Create a flow in akka.stream.javadsl that receives integers from a source, maps them to strings, and sends them to a sink, illustrating one-to-one processing with the map method.

Connect a source, a flow, and a sink to form a runnable graph with via and to. Run the graph using an actor system as the materializer.

Discover how finite sources emit a defined set of values and terminate, using range, source.single, and from(list) to build streams from iterables.

Learn how infinite sources in reactive streams work using repeat, cycle, and from iterator to emit data endlessly, with examples like a pi source and an infinite range.

Slow down a source to emit one element every three seconds and take five items using throttle and take operators in reactive streams.

Explore sinks in reactive streams, using sink.foreach and sink.ignore, and learn basic console output while noting future possibilities like file output and materialised values.

Learn how convenience methods offer shortcut constructions for reactive streams graphs in Akka and Java, comparing sink-first and source-first approaches with via and flow.

Apply map and filter in Akka streams to a source and sink, using a one-to-one mapping and a predicate to keep numbers divisible by 17.

Use mapConcat in Akka streams after a filter to emit multiple items per input, turning each integer into a list and flattening it into separate outputs.

Explore the grouped flow operator in reactive streams, converting a flow of integers into lists of a defined size using mapconcat, grouped, and a print sink to emit grouped results.

Chain flows to ungroup a list of integers back into individual values using MapConcat, and compare Java generics with Scholar’s type inference to show practical workarounds.

Learn to combine flows with sources and sinks to create new graphs. Use via to connect flows, and use to connect a flow to a sink.

Practice building and running a from-scratch Akka stream graph by creating a 10-element source, transforming to random BigInteger values, grouping primes into lists, sorting ascending, and printing the final list.

Follow a hands-on walkthrough to build a Maven Akka streams project named BigPrimes, create an actor system, generate primes with flows, group and sort them, and print the results.

Understand materialised values, the one-time values exposed by a graph’s source, flow, or sink. The sink often provides the materialised value, illustrated by a source and filters printing results.

Learn to use the fold method to create a sink with a materialised integer value, and extract it from the graph with toMat and keep.

Terminate the actor system by using materialised values to detect graph completion, employing via, toMat, and Keep.right, so the application shuts down automatically when the stream finishes.

Master the reduce method, like fold without a zeroth element, where the first item becomes the zeroth value, using a two-parameter lambda to produce the graph's materialised value.

Reuse graph objects across multiple graphs while ensuring a completed graph cannot restart; materialised values signal completion, finite streams reach their endpoint, and the CompletionStage flows through the graph.

Convert an infinite stream to a finite stream using take and limit, processing a fixed number of items and illustrating why limit may throw an exception.

Explore takeWhile and takeWithin to turn infinite streams finite, using a predicate and a five-second window to demonstrate throttle-driven termination.

Learn how to log Akka streams by configuring logback.xml and using flow-level log calls or actorSystem.log in lambdas to show flow input and output.

Explore back pressure and asynchronous boundaries in Akka by refactoring the big-prime graph into three actors: source, prime generator, and sink, and observe runtime improvements.

Explore backpressure in reactive streams with Akka, examining upstream and downstream data rates, buffers, and how signaling slows or speeds data to prevent bottlenecks.

Add an extra buffer in the graph to increase storage and explore overflow strategies like back pressure. Adjust buffer sizes with code add attributes to optimize throughput.

Explore alternative overflow strategies to back pressure, using added buffers and options like dropHead, dropTail, dropNew, and dropBuffer to manage data overflow in reactive streams.

Leverage parallelism by running multiple actor flows concurrently within the graph using mapAsync, and explore mapAsyncUnordered to relax ordering and boost efficiency.

Build and run a reactive graph that polls eight vans every 10 seconds, computes speed from positions, filters speeds above 95, and returns its first result as its materialised value.

Walkthrough demonstrates building a reactive streams graph in Akka with Java, producing timed strings, mapping to vehicle ids, computing speeds, filtering fast vehicles, and running with asynchronous boundaries.