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
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
chevron up
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 2. Simplifying Concurrent Programming with Actors

Before we get started on our refactoring journey (which I promise will start in earnest in Chapter 3, Curing Anemic Models with Domain-Driven Design), it makes sense to refresh ourselves on the actor model and Akka's implementation of it. We will tear down the walls and reframe our house with new programming techniques, but Akka's actors will always be the foundation to that house. Even though some of the newer aspects of Akka (such as Streams and HTTP) abstract up one level from directly using actors, the actor is still a core building block of those frameworks. As such, we should have a solid understanding of what an actor is and how they fit into the world of concurrent programming. We'll even do a little bit of refactoring work in this chapter as we have some bad actor debt (the SalesOrderManager) to clean up first. Here are the things you can expect to learn in this chapter:

  • The origins of the actor model...
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