The document discusses CQRS (Command Query Responsibility Segregation), an architectural pattern that separates read and write operations into different models. It describes how CQRS can help simplify complex systems by separating commands, which change the system state, from queries that read the state. The key aspects of implementing CQRS are discussed, including using command and query handlers, a command dispatcher, and ensuring consistency between read and write models. The document advocates implementing CQRS yourself using simple interfaces and classes rather than a framework.

1. Prosta architektura
dla nieprostego systemu
Mateusz Stasch

2. Mateusz Stasch
@mattstasch
http://mattstasch.net

3. CQRS

4. CQRS

5. CQRS
jest trudny

6. CQRS
jest trudny *

7. CQRS

8. CQRS
Implementacja zasady CQS
w postaci wzorca architektonicznego*

9. DBModel
Business
Logic
UI
DTO
DTO
ORM

10. DBDomain Model
Commands
UI
DTO
DTO
ORM
Queries

11. DB
WRITE Domain ModelCommands
UI
DTO
DTO
ORM
Queries READ Model

12. DB
WRITE Domain ModelCommands
UI
DTO
DTO
ORM
Queries
SELECT … FROM … WHERE …
READ
Model

13. READ DB
WRITE Domain ModelCommands
UI
DTO
DTO Queries
SELECT … FROM … WHERE …
WRITE DB
PROJECTION

14. READ DB
WRITE Domain ModelCommands
UI
DTO
DTO Queries
SELECT … FROM … WHERE …
PROJECTION
Event Stream

15. CQRS != ES

16. public class UserManager : IUserManager
{
public UserDetails UpdateUserStatus(...)
{
// ...
return user;
}
}

17. public class UserManager : IUserManager
{
public UserDetails UpdateUserStatus(...)
{
// ...
return user;
}
}

18. RESPONSIBILITY?

20. Manager

22. Command – zmienia stan systemu
Query – odczytuje stan systemu

23. public interface IQuery<out TResult>
{
TResult Execute();
}

24. public interface IQuery<out TResult>
{
TResult Execute();
}
public class QueryDispatcher : IQueryDispatcher
{
TResult Run<TResult>(IQuery<TResult> query)
{
using(var tx = session.OpenReadOnlyTransaction())
{
return query.Execute();
}
}
}

25. public interface IQuery<out TResult>
{
TResult Execute();
}
public class QueryDispatcher : IQueryDispatcher
{
TResult Run<TResult>(IQuery<TResult> query)
{
using(var tx = session.OpenReadOnlyTransaction())
{
return query.Execute();
}
}
}

26. public interface ICommandHandler<in TCommand>
{
void Execute(TCommand command);
}

27. public interface ICommandHandler<in TCommand>
{
void Execute(TCommand command);
}
public class CommandDispatcher : ICommandDispatcher
{
public void Execute<in TCommand>(TCommand command)
{
var handler = ResolveCommandHandler<TCommand>();
handler.Execute(command);
}
}

28. public interface ICommandHandler<in TCommand>
{
void Execute(TCommand command);
}
public class CommandDispatcher : ICommandDispatcher
{
public void Execute<in TCommand>(TCommand command)
{
var handler = ResolveCommandHandler<TCommand>();
handler.Execute(command);
}
}

29. Semantyka

30. Ekspresywność kodu
Semantyka

31. Ekspresywność kodu
Semantyka
Single Responsibility

32. using(var tx = session.BeginTransaction())
{
try
{
var user = repository.GetById<UserDetails>(id);
user.Status = newStatus;
tx.Commit();
return user;
}
catch
{
tx.Rollback();
throw;
}
}

33. public class UserManager : IUserManager
{
[Transactional]
public UserDetails UpdateUserStatus(...)
{
// ...
return user;
}
}

34. using(var tx = session.BeginTransaction())
{
try
{
var user = repository.GetById<UserDetails>(id);
user.Status = newStatus;
tx.Commit();
return user;
}
catch
{
tx.Rollback();
throw;
}
}

35. using(var tx = session.BeginTransaction())
{
try
{
var user = repository.GetById<UserDetails>(id);
user.Status = newStatus;
tx.Commit();
return user;
}
catch
{
tx.Rollback();
throw;
}
}

36. public UpdateUserStatusCommandHandler
: ICommandHandler<UpdateUserStatusCommand>
{
public void Execute(UpdateUserStatusCommand command)
{
var user = repository.GetById(command.Id);
user.Status = command.NewStatus;
}
}

37. public class CommandDispatcher : ICommandDispatcher
{
public void Execute<in TCommand>(TCommand command)
{
var handler = ResolveCommandHandler<TCommand>();
using(var tx = session.OpenTransaction())
{
try
{
handler.Execute(command);
tx.Commit();
}
catch
{
tx.Rollback();
throw;
}
}
}
}

38. public class TransactionalCommandDispatcherDecorator : ICommandDispatcher
{
public TransactionalCommandDispatcher(ICommandDispatcher …)
{…}
public void Execute<in TCommand>(TCommand command)
{
using(var tx = session.OpenTransaction())
{
try
{
decoratedDispatcher.Execute(command);
tx.Commit();
}
catch
{
tx.Rollback();
throw;
}
}
}
}

39. Logika biznesowa
Infrastruktura

40. Database
Infrastructure
Domain
Business Logic
UI

41. Domena

42. Database
Infrastructure
Domain
Querying
UI

43. Database
Infrastructure
Domain
Querying
UI
DependencyInjection
IQuery
IQueryDispatcher
GetUserDetailsQuery

44. Database
Infrastructure
Domain
Querying
UI
IUserRepository
ICommand ICommandHandler
ICommandDispatcher
DependencyInjection
IQuery
IQueryDispatcher
UpdateStatusCommand(Handler)
GetUserDetailsQuery

45. Database
Infrastructure
Domain
Querying
UI
IUserRepository
ICommand ICommandHandler
ICommandDispatcher
DependencyInjection
IQuery
IQueryDispatcher
UpdateStatusCommand(Handler)
CommandDispatcher
UserRepository
QueryDispatcher
GetUserDetailsQuery

46. Domain
Infrastructure
ICommandDispatcher
CommandDispatcher
ICommand
DeactivateUserCommand
IQuery
QueryDispatcher
IUserRepository
UserRepository
…

47. using(var tx = session.BeginTransaction())
{
try
{
var user = repository.GetById<UserDetails>(id);
user.Status = newStatus;
tx.Commit();
return user;
}
catch
{
tx.Rollback();
throw;
}
}

48. public UpdateUserStatusCommandHandler
: ICommandHandler<UpdateUserStatusCommand>
{
// ...
public void Execute(UpdateUserStatusCommand command)
{
var user = repository.GetById(command.Id);
user.Status = command.NewStatus;
}
}

49. public UpdateUserStatusCommandHandler
: ICommandHandler<UpdateUserStatusCommand>
{
// ...
public void Execute(UpdateUserStatusCommand command)
{
var user = repository.GetById(command.Id);
user.Status = command.NewStatus;
}
}

50. Robienie CRUDa w CQRSie jest bezsensowne!

51. Robienie CRUDa w CQRSie jest bezsensowne!

52. public DeactivateUserCommandHandler
: ICommandHandler<DeactivateUserCommand>
{
// ...
public void Execute(DeactivateUserCommand command)
{
var user = repository.GetById(command.Id);
user.Deactivate();
}
}

53. READ DB
WRITE Domain ModelCommands
UI
ORM
Queries
SELECT … FROM … WHERE …
WRITE DB
PROJECTION

54. READ DB
WRITE Domain ModelCommands
UI
ORM
Queries
SELECT … FROM … WHERE …
WRITE DB
PROJECTION

55. READ DB

56. READ DB WRITE DB!=

57. READ DB WRITE DB!=
Eager Read Derivation

58. READ DB ==
READ DB
READ DB
READ DB

59. READ DB
WRITE Domain ModelCommands
UI
ORM
Queries
SELECT … FROM … WHERE …
WRITE DB
PROJECTION
Eventual Consistency

60. DB
WRITE Domain ModelCommands
UI
ORM
Queries
SELECT … FROM … WHERE …
READ
Model

61. Jak zacząć?

62. Jakiś Framework?

63. Nope!

64. Napisz to sam!
To proste!

65. public interface IQuery<out TResult>
{
TResult Execute();
}
public class QueryDispatcher : IQueryDispatcher
{
TResult Run<out TResult>(IQuery<TResult> query)
{
using(var tx = session.OpenReadOnlyTransaction())
{
return query.Execute();
}
}
}

66. public interface IQuery<out TResult>
{
TResult Execute();
}
public class QueryDispatcher : IQueryDispatcher
{
TResult Run<out TResult>(IQuery<TResult> query)
{
using(var tx = session.OpenReadOnlyTransaction())
{
return query.Execute();
}
}
}

67. public interface ICommandHandler<in TCommand>
{
void Execute(TCommand command);
}
public class CommandDispatcher : ICommandDispatcher
{
public void Execute<in TCommand>(TCommand command)
{
var handler = ResolveCommandHandler<TCommand>();
handler.Execute(command);
}
}

68. public class TaskController
{
public TaskController(TaskManager taskManager) {…}
public ActionResult MarkAsFinalized(TaskId taskId)
{
taskManager.UpdateStatus(taskId, TaskStatuses.Finalized);
taskManager.UpdateFinalizationDate(taskId, DateTime.Now);
taskManager.UpdateFinalizedBy(taskId, CurrentUser.Id);
return Success;
}
}

69. public class TaskController : Controller
{
public TaskController(CommandDispatcher commandDispatcher) {…}
public ActionResult MarkAsFinalized(TaskId taskId)
{
var finalizeCommand = new FinalizeTaskCommand(taskId,
CurrrentUser.Id);
commandDispatcher.Execute(finalizeCommand);
return Success;
}
}

70. public class FinalizeTaskCommand
{
public FinalizeTaskCommand(TaskId id, UserId finalizingUser)
{…}
public TaskId Id { get; private set; }
public UserId FinalizingUser { get; private set; }
}

71. public class FinalizeTaskCommandHandler
: ICommandHandler<FinalizeTaskCommand>
{
public FinalizeTaskCommandHanlder(
ITaskRepository repository,
IDateTimeProvider dtp
) {…}
public void Execute(FinalizeTaskCommand command)
{
var task = repository.GetById(command.Id);
task.Status = TaskStatuses.Done;
task.FinalizedAt = dtp.Now();
task.FinalizedBy = command.FinalizingUser;
}
}

72. public class FinalizeTaskCommandHandler
: ICommandHandler<FinalizeTaskCommand>
{
public FinalizeTaskCommandHanlder(
ITaskRepository repository,
IDateTimeProvider dtp
) {…}
public void Execute(FinalizeTaskCommand command)
{
var task = repository.GetById(command.Id);
task.Finalize(dtp.Now(), command.FinalizingUser);
}
}

73. Q&A
Prosta architektura
dla nieprostego systemu
Mateusz Stasch

74. Dziękuję
za uwagę
Prosta architektura
dla nieprostego systemu
Mateusz Stasch