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.
  • Mastering Akka
  • Toc
  • feedback
Mastering Akka

Mastering Akka

By : Baxter
3.7 (6)
close
Mastering Akka

Mastering Akka

3.7 (6)
By: Baxter

Overview of this book

For a programmer, writing multi-threaded applications is critical as it is important to break large tasks into smaller ones and run them simultaneously. Akka is a distributed computing toolkit that uses the abstraction of the Actor model, enabling developers to build correct, concurrent, and distributed applications using Java and Scala with ease. The book begins with a quick introduction that simplifies concurrent programming with actors. We then proceed to master all aspects of domain-driven design. We’ll teach you how to scale out with Akka Remoting/Clustering. Finally, we introduce Conductr as a means to deploy to and manage microservices across a cluster.
Table of Contents (11 chapters)
close
close
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Conventions
Reader feedback
Customer support
Free Chapter
1
1. Building a Better Reactive App
chevron up
1. Building a Better Reactive App
Understanding the initial example app
Working with the example application
So what's wrong with this application?
Summary
2
2. Simplifying Concurrent Programming with Actors
2. Simplifying Concurrent Programming with Actors
Understanding the actor model's origin
Differentiating concurrency and parallelism
Using Akka actors for safe concurrency
A word on dispatchers in Akka
Mailbox types in Akka
Refactoring a bad actor to FSM
Testing your Akka actors
Summary
3
3. Curing Anemic Models with Domain-Driven Design
3. Curing Anemic Models with Domain-Driven Design
What is DDD?
Identifying anemic vs rich models
Designing our DDD refactor
Understanding the refactored bookstore code
Fixing the transaction in the order creation process
Improvements needed for the refactor
Refactoring homework
Summary
4
4. Making History with Event Sourcing
4. Making History with Event Sourcing
Event sourcing primer
Akka Persistence for event sourcing
Using Cassandra for our persistent store
Refactoring the inventory management module
The refactored sales order processing module
Refactoring homework
Summary
5
5. Separating Concerns with CQRS
5. Separating Concerns with CQRS
A brief history of CQRS
CQRS in the event sourced world
Designing our read model implementation
Implementing the Book read model
Refactoring sales order processing
Playing around with the new application
Refactoring homework
Closing comments
Summary
6
6. Going with the Flow with Akka Streams
6. Going with the Flow with Akka Streams
Understanding the Reactive Streams API
The Akka Streams API
Refactoring the view building code
Refactoring homework
Summary
7
7. REST Easy with Akka HTTP
7. REST Easy with Akka HTTP
Creating RESTful HTTP interfaces
Comparing Akka HTTP to Spray
Creating RESTful interfaces with Akka HTTP
Invoking RESTful APIs with Akka HTTP
Refactoring homework
Summary
8
8. Scaling Out with Akka Remoting/Clustering
8. Scaling Out with Akka Remoting/Clustering
Using Akka Remoting
Using Akka Clustering
Using clustering in the bookstore application
Summary
9
9. Managing Deployments with ConductR
9. Managing Deployments with ConductR
An overview of ConductR
Installing and setting up ConductR locally
Using the ConductR CLI
Preparing your services for ConductR
Refactoring the bookstore for ConductR
Building and deploying the bookstore bundles
Testing the bookstore modules in ConductR
Summary
10
10. Troubleshooting and Best Practices
10. Troubleshooting and Best Practices
Refactoring retrospective
Troubleshooting and best practices for actors
Troubleshooting and best practices for Akka HTTP
Troubleshooting and best practices for Akka Clustering/Akka Remoting
Further reading
Summary

Chapter 1. Building a Better Reactive App

This book is meant to be geared towards the more experienced Scala and Akka developers looking to build reactive applications on top of the Akka platform.

This book is written for an engineer who has already leveraged Akka in the 2.3.x series and below to build reactive applications. You have a firm understanding of the actor model and how the Akka framework leverages actors to build highly scalable, concurrent, asynchronous, event-driven, and fault-tolerant applications. You've seen the new changes rolled out in Akka 2.4.2 and are curious about how some of these new features such as Akka Streams and Akka HTTP can be leveraged within your reactive applications.

This book will serve as a guide for an engineer who wants to take a functional but flawed reactive application and, through a series of refactors, make improvements to it. It will help you understand what some of the common pitfalls are when building Akka applications. Throughout the various chapters in the book, you will learn how to use Akka and some of the newer features to address the following shortcomings:

  • Building a more domain-centric model using domain-driven design
  • Using event sourcing and Akka Persistence for high throughput persistence
  • Understanding reactive streams and how Akka makes use of them in Akka Streams and Akka HTTP
  • Decomposing a monolith into a set of fully decoupled and independent services
End of Section 1
Next Section
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