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.

Related Content you might be interested in

Current Title:

Small book image
Scala Reactive Programming
Rambabu Posa
Feb, 2018 | 552 pages
Small book image
Akka Cookbook
Vivek Mishra | Hctor Veiga Ortiz | Piyush Mishra
May, 2017 | 414 pages
Small book image
Learn Scala Programming
Slava Schmidt
Oct, 2018 | 498 pages
Small book image
Scala Microservices
Selvam Palanimalai | Jatin Puri
Sep, 2017 | 328 pages
Table of Contents (16 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
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
2
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
3
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
4
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
5
Adding Reactiveness with RxScala
Adding Reactiveness with RxScala
Introduction to RxScala
Building blocks of RxScala
RxScala Marble diagrams
Summary
6
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
7
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
8
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
9
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
10
Testing Reactive Microservices
Testing Reactive Microservices
Introduction to TDD
Unit testing frameworks
Unit testing Play Framework components
Unit testing Lagom services
Summary
11
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
12
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
13
Scala Plugin for IntelliJ IDEA
Scala Plugin for IntelliJ IDEA
Understanding Scala Plugin
How to set up Scala Plugin for IntelliJ IDE
Summary
14
Installing Robomongo
Installing Robomongo
What is Robomongo?
Summary
15
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Architecture of Play Framework

In this section, we will discuss the typical architecture of a Play Framework web application. Here, some components are mandatory for all applications, such as the routes file, Controller, View Templates, and so on; some are optional:

We can observe the following steps in any Play Framework Web Application:

  1. The users access a Play Web Application, using the application URL and a web browser.
  2. When the user sends a HTTP request to a Play Web Application, such as /route2 in our example, first that request reaches the Play Framework's Routing component (the default route filename is routes). However, we can use any name. Some applications may have more than one route file; finally, they have one top-level routes file.
  1. Play Framework Web Application's Route component decides who is responsible to handle that Request. It will find the correct...
Previous Section
End of Section 7
Next Section