Book Image

Scala Reactive Programming

By : Rambabu Posa

Book Image

Scala Reactive Programming

By: Rambabu Posa

Overview of this book

Reactive programming is a scalable, fast way to build applications, and one that helps us write code that is concise, clear, and readable. It can be used for many purposes such as GUIs, robotics, music, and others, and is central to many concurrent systems. This book will be your guide to getting started with Reactive programming in Scala. You will begin with the fundamental concepts of Reactive programming and gradually move on to working with asynchronous data streams. You will then start building an application using Akka Actors and extend it using the Play framework. You will also learn about reactive stream specifications, event sourcing techniques, and different methods to integrate Akka Streams into the Play Framework. This book will also take you one step forward by showing you the advantages of the Lagom framework while working with reactive microservices. You will also learn to scale applications using multi-node clusters and test, secure, and deploy your microservices to the cloud. By the end of the book, you will have gained the knowledge to build robust and distributed systems with Scala and Akka.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Getting Started with Reactive and Functional Programming

Getting Started with Reactive and Functional Programming

Introduction to Reactive

Functional programming

Reactive Manifesto

The Java 9 Flow API

Implementations of Reactive Streams

How are Reactive Streams born?

Marble diagrams

Functional Scala

Functional Scala

Introduction to Scala

Principles of Scala FP

Scala anonymous functions

Everything is an expression

Referential transparency

Functions are first-class citizens

Scala tail-recursion

Scala Type class

Scala Collections in action

Scala Functional Design Patterns

Scala Traits in action

Asynchronous Programming with Scala

Asynchronous Programming with Scala

Introduction to Scala AP

The Scala Future API

The Scala Future

The Scala Promise

Scala ExecutionContext

The relationship between Scala Future components

Scala Future API callbacks

Scala Future API combinators

Scala Future.sequence()

The Scala Async Library

The Scala Future API in Play Framework

The Scala Future API in the Akka Toolkit

A Scala Future versus a Java Future

Building Reactive Applications with Akka

Building Reactive Applications with Akka

Introduction to Akka

Actor Model in-depth

Akka ActorSystem

Actor basic operations

Akka Supervision

What is Akka's Let It Crash model?

Akka Actors communicate example

Akka Actor's lifecycle example

Akka parent-child Actors example

Actor's Path versus Reference

When we execute actorRef.tell (message), what happens internally?

How to configure a dispatcher?

Akka Configuration

Akka SBT Templates

Business problem

Akka Actor's implementation

Adding Reactiveness with RxScala

Adding Reactiveness with RxScala

Introduction to RxScala

Building blocks of RxScala

RxScala Marble diagrams

Extending Applications with Play

Extending Applications with Play

Introduction to Play Framework

Model and Forms

Play Framework View Template constructs

Architecture of Play Framework

What is Play Dependency Injection (DI)

Extend HelloWorld Example With DI

Extending HelloWorld example with Scala Futures

Play Form – Data Model

Extending Play/Scala HelloWorld example with Akka Toolkit

Play Fileupload web application

Working with Reactive Streams

Working with Reactive Streams

Introduction to Akka Streams

Other Reactive Streams implementations

Components of Akka Streams

The Akka Streams API

Modules of Akka Streams

Akka Materialization

Akka Streams programming basics

Why do we need ActorSystem and ActorMaterializer?

Akka Streams HelloWorld example

Extending the Akka Streams HelloWorld example with the Flow component

Akka Streams GraphDSL

An Akka Streams GraphDSL example

Akka Persistence

The CQRS pattern

How to develop Akka Persistence Actors

Akka Persistence MongoDB Weather example

Integrating Akka Streams to Play Application

Integrating Akka Streams to Play Application

Developing Akka Dynamic Streams

Integrating Akka Streams into Play

Akka Persistence Query

Reactive Microservices with Lagom

Reactive Microservices with Lagom

Introduction to Lagom Framework

Drawbacks of monolith architecture

Benefits of microservice architecture

Principles of microservices

Lagom Reactive Platform architecture

Modules of Lagom Framework

Kafka with ZooKeeper

Lagom project structure

Lagom System API

Lagom System – implementation

Lagom System – frontend

Lagom Hello Reactive System

Lagom Hello Reactive System microservices

Understanding the Hello Service API code

Understanding HelloService implementation code

Developing Lagom WF Reactive System

Testing Reactive Microservices

Testing Reactive Microservices

Introduction to TDD

Unit testing frameworks

Unit testing Play Framework components

Unit testing Lagom services

Managing Microservices in ConductR

Managing Microservices in ConductR

Introduction to Lightbend's ConductR

Installing Lightbend ConductR

Preparing WF Reactive System for ConductR

Deploying the WF Reactive System on ConductR

Starting ConductR Sandbox with a single node

Observing the WF Reactive System bundles

Running and testing WF Reactive System bundles

Useful ConductR commands

Reactive Design Patterns and Best Practices

Reactive Design Patterns and Best Practices

Understanding Design Patterns

The Circuit Breaker pattern

The Sharding Pattern

The Event Sourcing pattern

The Event Streaming Pattern

The Active-Passive Replication Pattern

The Resource Management Design Patterns

Message Flow Patterns

The Request-Response Design Pattern

Understanding the Reactive Design Pattern

Ask Reactive Design Pattern

The Throttling Pattern

The Pull pattern

Reactive System's best practices and tools

Scala Plugin for IntelliJ IDEA

Scala Plugin for IntelliJ IDEA

Understanding Scala Plugin

How to set up Scala Plugin for IntelliJ IDE

Installing Robomongo

Installing Robomongo

What is Robomongo?

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Akka Persistence Query

In this section, we will develop a WF (Weather Forecasting) Reactive system using the following technology stack:

Akka Persistence API
Akka Persistence Query API
Scala
Apache Cassandra

As we discussed in Chapter 7, Working with Reactive Streams, Akka Persistence supports the CQRS/ES (Command and Query Responsibility Segregation with Event Sourcing) Design pattern.

CQRS/ES is a Reactive Statement Management and Persistence pattern.

The Akka Persistence API is used to write data into a data store, whereas the Akka Persistence Query API is used to read data from a data store. Here we can use any RDBMS or No SQL database as a data store. We will use Apache Cassandra as our WF Reactive System data store for both the WRITE and READ sides.

Building blocks of Akka...