Book Image

Akka Cookbook

By : Vivek Mishra, Héctor Veiga Ortiz
Book Image

Akka Cookbook

By: Vivek Mishra, Héctor Veiga Ortiz

Overview of this book

Akka is an open source toolkit that simplifies the construction of distributed and concurrent applications on the JVM. This book will teach you how to develop reactive applications in Scala using the Akka framework. This book will show you how to build concurrent, scalable, and reactive applications in Akka. You will see how to create high performance applications, extend applications, build microservices with Lagom, and more. We will explore Akka's actor model and show you how to incorporate concurrency into your applications. The book puts a special emphasis on performance improvement and how to make an application available for users. We also make a special mention of message routing and construction. By the end of this book, you will be able to create a high-performing Scala application using the Akka framework.

Related Content you might be interested in

Current Title:

Small book image
Akka Cookbook
Vivek Mishra | Héctor Veiga Ortiz
May, 2017 | 414 pages
Small book image
Scala Reactive Programming
Rambabu Posa
Feb, 2018 | 552 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 (18 chapters)
Title Page
Title Page
Credits
Credits
About the Authors
About the Authors
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
Diving into Akka
Diving into Akka
Introduction
Creating an Akka Scala SBT project from scratch
Creating and understanding ActorSystem
Defining the actor's behavior and state
Sending messages to actors
Asking for a result from an actor
Communication between actors
Creating a custom mailbox for an actor
Prioritizing messages that an actor receives
Creating a control-aware mailbox for an actor
Become/unbecome behavior of an actor
Stopping an actor
2
Supervision and Monitoring
Supervision and Monitoring
Introduction
Creating child actors of a parent actor
Overriding the life cycle hooks of an actor
Sending messages to actors and collecting responses
Understanding OneForOneStrategy for actors
Understanding AllForOneStrategy for actors
Monitoring an actor life cycle using DeathWatch
3
Routing Messages
Routing Messages
Introduction
Creating a SmallestMailboxPool of actors
Creating a BalancingPool of actors
Creating a RoundRobinPool of actors
Creating a BroadcastPool of actors
Creating a ScatterGatherFirstCompletedPool of actors
Creating a TailChoppingPool of actors.
Creating a ConsistentHashingPool of actors
Creating a RandomPool of actors
Sending specially handled messages to routers
Creating a dynamically resizable pool of actors
4
Using Futures and Agents
Using Futures and Agents
Introduction
Using a future directly for a simple operation
Using futures with actors
Using futures inside actors
Using for-comprehensions for futures
Handling callback on futures
Creating a simple parallel application using futures
Reducing a sequence of futures
Reading and updating agents
Composing agents monadically
5
Scheduling Actors and Other Utilities
Scheduling Actors and Other Utilities
Introduction
Scheduling an operation at a specified interval 
Scheduling an actor's operation at a specified interval
Canceling a scheduled operation of the actor
Creating a circuit breaker to avoid cascading failure
How to introduce logging with actors
Writing unit test for actors
Packaging and deploying the Akka standalone application
Packaging and deploying Akka application inside a Docker container
Configurating Akka applications
6
Akka Persistence
Akka Persistence
Introduction
Preparing an actor for persistence
Recovering the state of an actor
Safely shutting down a persistent actor
Reducing recovery time using snapshots
Creating a persistence FSM model
Persisting the state to LevelDB
Persisting the state to Cassandra
Persisting the state to Redis
Understanding event sourcing
Handling failure in event sourcing
Using persistence query
Persistence query for LevelDB
7
Remoting and Akka Clustering
Remoting and Akka Clustering
Introduction
Enabling Akka applications for remoting
Creating remote actors on different machines
Looking up remote actors from different machines
Deploying remote actors programmatically on different nodes
Scaling out your application using remote actors
Creating a chat-based application using remote actors
Enabling Akka clustering for your project
Using Distributed Publish-Subscribe in the cluster
Cluster Sharding
Sharing data between nodes in an Akka cluster
Creating a singleton actor across clusters
8
Akka Streams
Akka Streams
Introduction
Creating simple Akka Streams
How to transform streams and consume them
Creating stream sources, flows, and sinks
Custom stream processing
Error handling in Akka streams
Pipelining and parallelizing streams
Working with streaming I/O
Integrating streams with Akka actors
Working with graphs
Processing RabbitMQ messages with Akka streams
Integrating Akka Streams with Kafka using Reactive Kafka
9
Akka HTTP
Akka HTTP
Introduction
Creating a minimal HTTP server using Akka HTTP
Consuming Akka HTTP services using a client-side API
Writing routing DSL for HTTP servers
Understanding the configuration of Akka HTTP
Marshaling and unmarshaling data
Encoding and decoding data
Understanding directives
Exception handling
Uploading a file using Akka HTTP
Building JSON support with Akka HTTP
XML support with Akka HTTP
10
Understanding Various Akka patterns
Understanding Various Akka patterns
Introduction
The Master Slave work pulling pattern
Ordered termination of actors
Shutdown patterns in Akka
Scheduling periodic messages to an actor
Throttling of messages while sending them to an actor
Balancing workload across actors
The aggregator pattern
The CountDownLatch pattern
Finite-state machine
The pausable actor pattern
Enveloping actor
11
Microservices with Lagom
Microservices with Lagom
Introduction
Installing Lagom and creating a Lagom project
Understanding the service locator
Understanding service descriptors
Implementing Lagom services
Consuming services
Testing services
Writing persistent and clustered services
Running Lagom in production
Integrating with Akka

Using futures with actors

In this recipe, we will see how to use a future with an actor, and how to retrieve the result of a computation done by a future.

Getting ready

Just import the Hello-Akka project, and the other prerequisites are the same as earlier.

How to do it...

The following are the steps to use a future with an actor and to retrieve a result of the computation:

  1. Create a scala file, FutureWithActor.scala, in the com.packt.chapter4 package.
  2. Add the following imports to the top of the file:
        import akka.actor.{Actor, ActorSystem, Props} 
        import akka.pattern.ask 
        import akka.util.Timeout 
        import scala.concurrent.Await 
        import scala.concurrent.duration._
  1. Create an actor that calculates the sum of two integers and sends it back to the sender, as shown in the following code snippet:
        class ComputationActor extends Actor { 
          def receive = { 
            case (a: Int, b: Int) => sender ! (a + b) 
          } 
        }
  1. Create the sample...
Previous Section
End of Section 4
Next Section