4. Making History with Event Sourcing | Mastering Akka

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

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

Refactoring the inventory management module

We'll start out by refactoring the inventory management module, like we did in in the section titled The Book and InventoryClerk actors, in Chapter 3, Curing Anemic Models with Domain-Driven Design. The focus of the next few sections will be to get the Book entity to use PersistentActor and an event sourced approach to its persistence. This will be a multi-part process where we do an initial simple refactor. Then, we'll layer in some improvements as I introduce a few new concepts from Akka Persistence.

The PersistentEntity abstract class

The PersistentEntity abstract class, in the bookstore-common project, is the base class that all of our concrete event sourced entities will extend from. It's a similar concept to EntityActor from the Chapter 3, Curing Anemic Models with Domain-Driven Design, DDD refactor, but it's a lot less complex. The majority of the complicated stuff I hand coded is now handled by PersistentActor, which PersistentEntity extends...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Mastering Akka

Search

Your notes and bookmarks