Browse Library
Sign In Start Free Trial
Close icon Search icon
Account
Browse Library Advanced Search Sign In Start Free Trial

Add to playlist

Create a Playlist

Modal Close icon
You need to login to use this feature.
  • Akka Cookbook
  • Toc
  • feedback
Akka Cookbook

Akka Cookbook

By : Mishra, Héctor Veiga Ortiz
4.2 (10)
close
Akka Cookbook

Akka Cookbook

4.2 (10)
By: 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.
Table of Contents (12 chapters)
close
close
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Sections
Conventions
Reader feedback
Customer support
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
chevron up
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

Creating a simple parallel application using futures

In this recipe, we will create an application that will compute the result in parallel. You will learn how independent operations can be parallelized, which will reduce the running time of a program.

Getting ready

To step through this recipe, we need to import the Hello-Akka project in the IDE. The rest of the prerequisites are the same as before.

How to do it...

  1. Create a simple scala file, say Parallel.scala, in the com.packt.chapter4 package.
  2. Add the following imports to the top of the file:
        import scala.concurrent.ExecutionContext.Implicits.global 
        import scala.concurrent.{Await, Future}
  1. Create a Scala object, as shown in the following code snippet, which calculates a Fibonacci number:
        object Fib { 
          def fib(n: Int): Int = { 
            def fib_tail(n: Int, a: Int, b: Int): Int = n match { 
              case 0 => a 
              case _ => fib_tail(n - 1, b, a + b) 
            } 
          fib_tail...

Unlock full access

Continue reading for free

A Packt free trial gives you instant online access to our library of over 7000 practical eBooks and videos, constantly updated with the latest in tech
Start a 7-day FREE trial
End of Chapter 4
Next Chapter
bookmark search playlist download
font-size

Change the font size

margin-width

Change margin width

day-mode

Change background colour

Close icon Search
Country selected
Close icon Your notes and bookmarks

Delete Bookmark

Modal Close icon
Are you sure you want to delete it?
Cancel
Yes, Delete