Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Mastering Akka

By : Baxter

3.7 (6)

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.

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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

Customer Reviews

3.7 (6)

5 star

50%

4 star

16.7%

3 star

0

2 star

16.7%

1 star

16.7%

What this book covers

Chapter 1, Building a Better Reactive App, introduces you to the initial sample application and how it will be improved over the course of this book.

Chapter 2, Simplifying Concurrent Programming with Actors, is a refresher on Actors with some refactoring work using Akka’s FSM.

Chapter 3, Curing Anemic Models with Domain-Driven Design, introduces you to domain-driven design (DDD) and how it helps in modeling and building software.

Chapter 4, Making History with Event Sourcing, presents Akka Persistence as a means to build event-sourced entities.

Chapter 5, Separating Concerns with CQRS, teaches you how to separate read and write models using the CQRS pattern.

Chapter 6, Going with the Flow with Akka Streams, explains how Akka Streams can be used to build back-pressure aware, stream-based processing components.

Chapter 7, REST Easy with Akka HTTP, shows you how to leverage Akka HTTP to build and consume RESTful interfaces.

Chapter 8, Scaling Out with Akka Remoting/Clustering, demonstrates how to use remoting and clustering to gain horizontal scalability and high availability.

Chapter 9, Managing Deployments with ConductR, illustrates building, deploying, and locating your microservices with ConductR.

Chapter 10, Troubleshooting and Best Practices, presents a few final tips and best practices for using Akka.

Search

Your notes and bookmarks