Short explanation and some code examples how the CQRS and ES architectural patterns are implemented in Akka.

1. 1
CQRS & ES
With Akka, Cassandra and
RabbitMQ
Miel Donkers, codecentric

2. 2 . 1
Why??

3. 2 . 2
What is CQRS

4. 2 . 3
What is CQRS
Command Query Responsibility Segregation

5. 2 . 4
Traditional Architecture
© Martin Fowler

6. 2 . 5
CQRS Architecture
© Martin Fowler

7. 2 . 6
Storing data
Simple approach
Single database
Normalized tables for write-side data
Views for denormalizing data
Keep queries simple

8. 2 . 7
CQRS related to DDD
DDD - Domain Driven Design
Bounded Context
Aggregate
Command
Event

9. 2 . 8
What is ES

10. 2 . 9
What is ES
Event Sourcing
Event describes the state change of aggregate
Event is saved in event store
Events can be replayed to re-create the current state.

11. 2 . 10
CQRS & ES Combined

12. 2 . 11
Architecture with Transactions
© Microsoft - CQRS Journey

13. 2 . 12
Architecture with Events
© Microsoft - CQRS Journey

14. 2 . 13
Architecture with Messages
© Microsoft - CQRS Journey

15. 2 . 14
The hard parts

16. 2 . 15
Consistency
Key feature for the Event Store
Without transactions, much work needed to make as
reliable
Versioning / timestamps
Eventual consistency

17. 2 . 16
Error Handling
Distinguish between business faults and errors.
Errors can be re-tried.
Business faults should have pre-determined
reaction.

18. 2 . 17
Other disadvantages
Many moving parts, makes it hard to debug the
system as a whole
CQRS not for every bounded context

19. 2 . 18
Advantages

20. 2 . 19
Advantages
Task-based UI
Read and write side can be optimized separately
Debug in local environment
Small components which are easy to update / fix

21. 2 . 20
Code

22. 2 . 21
User Aggregate
Not Finished

23. 2 . 22
User Repository
private var users = Set.empty[User]
override def receiveCommand: Receive = {
case GetUsers =>
sender() ! users
case AddUser(name) if users.exists(_.name == name) =>
sender() ! UserExists(name)
case AddUser(user) =>
persist(user) { persistedUser =>
receiveRecover(persistedUser)
sender() ! UserAdded(persistedUser)
}
}
override def receiveRecover: Receive = {
case user: User => users += user
}

24. 2 . 23
Event Sender
private var unconfirmed = immutable.SortedMap.empty[Long, ActorPath]
override def receive: Receive = {
case Msg(deliveryId, user) =>
unconfirmed = unconfirmed.updated(deliveryId, sender().path)
val headersMap = Map(RabbitMQConstants.MESSAGE_ID -> deliveryId, RabbitMQ
camelSender ! CamelMessage(user.asJson.noSpaces, headersMap)
case CamelMessage(_, headers) =>
val deliveryId: Long = headers.getOrElse(RabbitMQConstants.MESSAGE_ID, -
unconfirmed.get(deliveryId).foreach(
senderActor => {
unconfirmed -= deliveryId
context.actorSelection(senderActor) ! Confirm(deliveryId)
})
case Status.Failure(ex) =>

25. 2 . 24
Event Receiver
override def receive: Receive = {
case msg: CamelMessage =>
val body: Xor[Error, User] = decode[User](msg.bodyAs[String])
body.fold({ error =>
sender() ! Failure(error)
}, { user =>
sender() ! Ack
})
case _ => log.warning("Unexpected event received")
}

26. 2 . 25
Links
Martin Fowler - CQRS
Microsoft - CQRS Journey
Akka
Heiko Seeberger - Reactive Flows Demo

27. 3 . 1
Wrapping Up

28. 3 . 2
Feedback

29. 3 . 3
The End
Copyright 2016