Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Scala Reactive Programming

By : Rambabu Posa

2.8 (10)

Scala Reactive Programming

2.8 (10)

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

Preface

Who this book is for

What this book covers

To get the most out of this book

Get in touch

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

Summary

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

Summary

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

Summary

Building Reactive Applications with Akka

Building Reactive Applications with Akka

Introduction to Akka

Actor Model in-depth

Akka ActorSystem

Akka Actors

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

Akka Logging

Business problem

Akka Actor's implementation

Summary

Adding Reactiveness with RxScala

Adding Reactiveness with RxScala

Introduction to RxScala

Building blocks of RxScala

RxScala Marble diagrams

Summary

Extending Applications with Play

Extending Applications with Play

Introduction to Play Framework

View Templates

Model and Forms

Configuration

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

Summary

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

Backpressure

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

Summary

Integrating Akka Streams to Play Application

Integrating Akka Streams to Play Application

Akka Streams

Developing Akka Dynamic Streams

Integrating Akka Streams into Play

Akka Persistence Query

Summary

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

Summary

Testing Reactive Microservices

Testing Reactive Microservices

Introduction to TDD

Unit testing frameworks

Unit testing Play Framework components

Unit testing Lagom services

Summary

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

Summary

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

Summary

Scala Plugin for IntelliJ IDEA

Scala Plugin for IntelliJ IDEA

Understanding Scala Plugin

How to set up Scala Plugin for IntelliJ IDE

Summary

Installing Robomongo

Installing Robomongo

What is Robomongo?

Summary

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

2.8 (10)

5 star

40%

4 star

0

3 star

10%

2 star

0

1 star

50%

Lagom Hello Reactive System microservices

Even though this basic Lagom HelloWorld System looks very simple, we can learn many Lagom concepts. Let's pick up each service and understand the code.

It mainly has two services (microservices):

Hello Lagom service
Hello Lagom Stream service

Again, each microservice has two parts: one is for the API and another for the implementation.

The Hello (hello) Microservice has the following two parts:

Hello API service (hello-lagom-api)
Hello implementation service (hello-lagom-impl)

In the same way, the Hello Stream (hello-lagom-stream) microservice has two parts:

Hello Stream API service (hello-lagom-stream-api)
Hello Stream implementation service (hello-lagom-stream-impl)

The whole HelloWorld System looks like the following in the IntelliJ IDE:

It's time to understand the code in both the API and the implementation projects...

Search

Your notes and bookmarks