Domain Events: события домена и путь к Event-Driven
Domain Events: события домена и путь к Event-Driven
Пользователь прошёл урок. Что должно произойти дальше? Обновить прогресс, пересчитать процент завершения курса, отправить email "Поздравляем!", записать аналитику, проверить - может, пора выдать сертификат.
Если всю эту логику запихнуть в один метод CompleteLesson, получится бог-функция на 200 строк. Добавление каждой новой реакции потребует правки этого метода, а падение email-сервиса сломает основной сценарий.
Domain Events решают эту проблему: основной метод фиксирует факт ("урок пройден"), а все побочные реакции запускаются отдельно. Это базовый кирпичик event-driven архитектуры.
Событие - это факт в прошедшем времени
Domain Event - это неизменяемая запись о том, что уже произошло в домене. Не запрос, не команда, а свершившийся факт.
| Command (Команда) | Event (Событие) | |
|---|---|---|
| Время | Будущее, императив | Прошедшее, свершившийся факт |
| Пример | CompleteLesson | LessonCompleted |
| Может быть отклонена? | Да | Нет (факт уже случился) |
| Отправитель знает получателя? | Да | Нет (pub/sub) |
| Изменяемость | Может быть переформулирована | Иммутабельна |
Команда говорит: "Сделай это". Событие говорит: "Это случилось".
События BackendStart
На платформе BackendStart можно выделить такие доменные события:
package domain
import "time"
// Пользователь завершил урок
type LessonCompleted struct {
UserID int64
CourseSlug string
LessonSlug string
OccurredAt time.Time
}
// Пользователь прошёл квиз
type QuizPassed struct {
UserID int64
LessonSlug string
Score int // процент правильных ответов
OccurredAt time.Time
}
// Пользователь завершил весь курс
type CourseFinished struct {
UserID int64
CourseSlug string
OccurredAt time.Time
}
// Новый пользователь зарегистрировался
type UserRegistered struct {
UserID int64
Email string
Provider string // "github", "email"
OccurredAt time.Time
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use DateTimeImmutable;
// Domain Event - final readonly: факт в прошедшем времени, иммутабельный.
// Пользователь завершил урок
final readonly class LessonCompleted
{
public function __construct(
public int $userId,
public string $courseSlug,
public string $lessonSlug,
public DateTimeImmutable $occurredAt,
) {}
}
// Пользователь прошёл квиз
final readonly class QuizPassed
{
public function __construct(
public int $userId,
public string $lessonSlug,
public int $score, // процент правильных ответов
public DateTimeImmutable $occurredAt,
) {}
}
// Пользователь завершил весь курс
final readonly class CourseFinished
{
public function __construct(
public int $userId,
public string $courseSlug,
public DateTimeImmutable $occurredAt,
) {}
}
// Новый пользователь зарегистрировался
final readonly class UserRegistered
{
public function __construct(
public int $userId,
public string $email,
public string $provider, // 'github', 'email'
public DateTimeImmutable $occurredAt,
) {}
}
from dataclasses import dataclass
from datetime import datetime
# Domain Event - frozen dataclass: факт в прошедшем времени, иммутабельный.
# Пользователь завершил урок
@dataclass(frozen=True, slots=True)
class LessonCompleted:
user_id: int
course_slug: str
lesson_slug: str
occurred_at: datetime
# Пользователь прошёл квиз
@dataclass(frozen=True, slots=True)
class QuizPassed:
user_id: int
lesson_slug: str
score: int # процент правильных ответов
occurred_at: datetime
# Пользователь завершил весь курс
@dataclass(frozen=True, slots=True)
class CourseFinished:
user_id: int
course_slug: str
occurred_at: datetime
# Новый пользователь зарегистрировался
@dataclass(frozen=True, slots=True)
class UserRegistered:
user_id: int
email: str
provider: str # "github", "email"
occurred_at: datetime
Обрати внимание на паттерн: имя в прошедшем времени, событие передаётся по значению и после создания не меняется, есть метка времени OccurredAt.
ℹ️ Событие - контракт между контекстами
Структура события - это публичный контракт. Если контекст Analytics слушает LessonCompleted, любое удаление поля сломает подписчика. Добавлять поля безопасно, удалять - нет.
Publisher: интерфейс и реализация
Для публикации событий нужен простой интерфейс и in-memory реализация для старта. Внутри одного процесса это в точности Observer: publisher держит список подписчиков и не знает, кто и зачем подписался, поэтому новый обработчик добавляется без правок домена.
package domain
import (
"context"
)
// Интерфейс публикации событий.
// Возвращает error: публикация в брокер может упасть, и вызывающий
// должен об этом узнать. In-memory реализация просто вернёт nil.
type EventPublisher interface {
Publish(ctx context.Context, events ...any) error
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
// Интерфейс публикации событий
interface EventPublisher
{
public function publish(object ...$events): void;
}
from typing import Protocol
# Интерфейс публикации событий
class EventPublisher(Protocol):
def publish(self, *events: object) -> None: ...
package infra
import (
"context"
"log/slog"
"sync"
)
// EventHandler обрабатывает одно событие
type EventHandler interface {
Handle(ctx context.Context, event interface{})
}
// InMemoryPublisher - синхронная реализация для монолита
type InMemoryPublisher struct {
mu sync.RWMutex
handlers []EventHandler
}
func NewInMemoryPublisher() *InMemoryPublisher {
return &InMemoryPublisher{}
}
func (p *InMemoryPublisher) Subscribe(h EventHandler) {
p.mu.Lock()
defer p.mu.Unlock()
p.handlers = append(p.handlers, h)
}
func (p *InMemoryPublisher) Publish(ctx context.Context, events ...any) error {
// Снимаем копию списка под блокировкой и отпускаем её ДО вызовов.
//
// Держать RLock во время Handle нельзя: обработчик, который сам вызовет
// Subscribe, встанет на Lock и не дождётся - sync.RWMutex
// не реентерабелен, и получится дедлок. Копия списка стоит дёшево,
// а инварианта «Publish не держит блокировку на время чужого кода»
// достаточно, чтобы такой случай стал невозможен.
p.mu.RLock()
handlers := make([]EventHandler, len(p.handlers))
copy(handlers, p.handlers)
p.mu.RUnlock()
for _, event := range events {
for _, h := range handlers {
// Паника одного обработчика не должна ронять остальных
// и тем более транзакцию, которая опубликовала событие.
func() {
defer func() {
if r := recover(); r != nil {
slog.Error("обработчик события упал",
slog.Any("event", event),
slog.Any("panic", r))
}
}()
h.Handle(ctx, event)
}()
}
}
// Синхронной доставке нечему падать: сбои обработчиков уже залогированы.
return nil
}
<?php
declare(strict_types=1);
namespace App\Learning\Infrastructure;
use App\Learning\Domain\EventPublisher;
// EventHandler обрабатывает одно событие
interface EventHandler
{
public function handle(object $event): void;
}
// InMemoryPublisher - синхронная реализация для монолита.
// В продакшене можно заменить на Symfony Messenger или RabbitMQ - интерфейс тот же.
final class InMemoryPublisher implements EventPublisher
{
/** @var EventHandler[] */
private array $handlers = [];
public function subscribe(EventHandler $h): void
{
$this->handlers[] = $h;
}
public function publish(object ...$events): void
{
foreach ($events as $event) {
foreach ($this->handlers as $h) {
$h->handle($event);
}
}
}
}
import logging
import threading
from typing import Protocol
log = logging.getLogger(__name__)
class EventHandler(Protocol):
"""Обрабатывает одно событие."""
def handle(self, event: object) -> None: ...
class InMemoryPublisher:
"""Синхронная реализация для монолита."""
def __init__(self) -> None:
self._lock = threading.Lock()
self._handlers: list[EventHandler] = []
def subscribe(self, handler: EventHandler) -> None:
with self._lock:
self._handlers.append(handler)
def publish(self, *events: object) -> None:
# Снимаем копию списка под блокировкой и отпускаем её ДО вызовов.
#
# Держать lock во время handle нельзя: обработчик, который сам вызовет
# subscribe, встанет на тот же lock и не дождётся - threading.Lock
# не реентерабелен, и получится дедлок. Копия списка стоит дёшево,
# а инварианта «publish не держит блокировку на время чужого кода»
# достаточно, чтобы такой случай стал невозможен.
with self._lock:
handlers = list(self._handlers)
for event in events:
for handler in handlers:
# Исключение одного обработчика не должно ронять остальных
# и тем более транзакцию, которая опубликовала событие.
try:
handler.handle(event)
except Exception:
log.exception("обработчик события упал: event=%r", event)
В монолите этого достаточно. Когда появится потребность в асинхронности, реализацию можно заменить на Kafka или NATS: Go-сигнатура уже возвращает ошибку (а в PHP и Python сбой придёт исключением), поэтому вызывающий код менять не придётся.
Агрегат собирает события
Агрегат не публикует события сразу. Он накапливает их в слайсе, а публикация происходит после успешного сохранения в базу. Забирает накопленное и публикует не сам агрегат, а сценарий поверх него - роль этого слоя разобрана в уроке Domain Service vs Application Service:
package domain
import (
"fmt"
"time"
)
// Поля закрыты, как в уроке про агрегаты: состояние меняют только методы.
// Чтение - через геттеры (Percent(), Lessons() и т.д.), их здесь опускаем.
type CourseProgress struct {
id int64
userID int64
courseSlug CourseSlug
lessons []LessonProgress
percent int
events []interface{} // накопленные события
}
// collectEvent добавляет событие в очередь.
// Неэкспортируемый: события рождает только сам агрегат,
// внешний код не может подложить ему чужое событие.
func (p *CourseProgress) collectEvent(e interface{}) {
p.events = append(p.events, e)
}
// FlushEvents возвращает накопленные события и очищает очередь
func (p *CourseProgress) FlushEvents() []interface{} {
events := p.events
p.events = nil
return events
}
// CompleteLesson - бизнес-операция, которая генерирует событие
func (p *CourseProgress) CompleteLesson(lessonSlug string) error {
for i, lp := range p.lessons {
if lp.slug == lessonSlug {
// В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
// идемпотентный вариант: повторный запрос (ретрай, двойной клик)
// не должен ни падать, ни порождать второе событие. Это решение
// домена, а не правило DDD; важно лишь, чтобы второго
// LessonCompleted не было.
if lp.completed {
return nil // идемпотентность
}
p.lessons[i].completed = true
p.recalcPercent()
p.collectEvent(LessonCompleted{
UserID: p.userID,
CourseSlug: string(p.courseSlug),
LessonSlug: lessonSlug,
OccurredAt: time.Now(),
})
if p.percent == 100 {
p.collectEvent(CourseFinished{
UserID: p.userID,
CourseSlug: string(p.courseSlug),
OccurredAt: time.Now(),
})
}
return nil
}
}
return fmt.Errorf("lesson %s not found in course %s", lessonSlug, p.courseSlug)
}
<?php
declare(strict_types=1);
namespace App\Learning\Domain;
use DateTimeImmutable;
use DomainException;
// Aggregate Root - final, но НЕ readonly: меняются Lessons, Percent, events.
final class CourseProgress
{
/**
* @param LessonProgress[] $lessons
* @param object[] $events
*/
public function __construct(
public readonly int $id,
public readonly int $userId,
public readonly CourseSlug $courseSlug,
private array $lessons,
private int $percent,
private array $events = [],
) {}
// recordEvent добавляет событие в очередь
private function recordEvent(object $e): void
{
$this->events[] = $e;
}
// pullEvents возвращает накопленные события и очищает очередь
/** @return object[] */
public function pullEvents(): array
{
$events = $this->events;
$this->events = [];
return $events;
}
// completeLesson - бизнес-операция, которая генерирует событие
public function completeLesson(string $lessonSlug): void
{
foreach ($this->lessons as $i => $lp) {
if ($lp->slug === $lessonSlug) {
// В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
// идемпотентный вариант: повторный запрос (ретрай, двойной клик)
// не должен ни падать, ни порождать второе событие. Это решение
// домена, а не правило DDD; важно лишь, чтобы второго
// LessonCompleted не было.
if ($lp->completed) {
return; // идемпотентность
}
$this->lessons[$i] = $lp->withCompleted(true);
$this->recalcPercent();
$this->recordEvent(new LessonCompleted(
userId: $this->userId,
courseSlug: $this->courseSlug->value(),
lessonSlug: $lessonSlug,
occurredAt: new DateTimeImmutable(),
));
if ($this->percent === 100) {
$this->recordEvent(new CourseFinished(
userId: $this->userId,
courseSlug: $this->courseSlug->value(),
occurredAt: new DateTimeImmutable(),
));
}
return;
}
}
throw new DomainException(sprintf(
'lesson %s not found in course %s',
$lessonSlug,
$this->courseSlug->value(),
));
}
}
from dataclasses import dataclass, field
from datetime import datetime
class DomainError(Exception):
"""Нарушение правил домена."""
# Aggregate Root - обычный dataclass, не frozen: меняются _lessons, _percent, _events.
# Подчёркивание - «приватно по соглашению», как в уроке про агрегаты:
# менять состояние можно только методами (свойства для чтения здесь опущены).
@dataclass
class CourseProgress:
progress_id: int
user_id: int
course_slug: CourseSlug
_lessons: list[LessonProgress]
_percent: int = 0
_events: list[object] = field(default_factory=list, repr=False) # накопленные события
def _collect_event(self, event: object) -> None:
"""Добавляет событие в очередь.
Приватный: события рождает только сам агрегат.
"""
self._events.append(event)
def flush_events(self) -> list[object]:
"""Возвращает накопленные события и очищает очередь."""
events = self._events
self._events = []
return events
def complete_lesson(self, lesson_slug: str) -> None:
"""Бизнес-операция, которая генерирует событие."""
for lp in self._lessons:
if lp.slug == lesson_slug:
# В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
# идемпотентный вариант: повторный запрос (ретрай, двойной клик)
# не должен ни падать, ни порождать второе событие. Это решение
# домена, а не правило DDD; важно лишь, чтобы второго
# LessonCompleted не было.
if lp.completed:
return # идемпотентность
lp.completed = True
self._recalc_percent()
self._collect_event(LessonCompleted(
user_id=self.user_id,
course_slug=str(self.course_slug),
lesson_slug=lesson_slug,
occurred_at=datetime.now(),
))
if self._percent == 100:
self._collect_event(CourseFinished(
user_id=self.user_id,
course_slug=str(self.course_slug),
occurred_at=datetime.now(),
))
return
raise DomainError(f"lesson {lesson_slug} not found in course {self.course_slug}")
Порядок в use-case: (1) загрузить агрегат, (2) вызвать бизнес-метод, (3) сохранить, (4) опубликовать события:
func (uc *CompleteLessonUseCase) Execute(ctx context.Context, cmd CompleteLesson) error {
progress, err := uc.progressRepo.FindByUserAndCourse(ctx, cmd.UserID, cmd.CourseSlug)
if err != nil {
return err
}
if err := progress.CompleteLesson(cmd.LessonSlug); err != nil {
return err
}
if err := uc.progressRepo.Save(ctx, progress); err != nil {
return err
}
// Публикуем ПОСЛЕ успешного сохранения: подписчики не должны узнать
// о том, чего в базе нет. Цену этого порядка см. во врезке под кодом.
if err := uc.publisher.Publish(ctx, progress.FlushEvents()...); err != nil {
return fmt.Errorf("publish events: %w", err)
}
return nil
}
final class CompleteLessonUseCase
{
public function __construct(
private readonly ProgressRepository $progressRepo,
private readonly EventPublisher $publisher,
) {}
public function execute(CompleteLessonCommand $cmd): void
{
$progress = $this->progressRepo->findByUserAndCourse(
$cmd->userId,
$cmd->courseSlug,
);
$progress->completeLesson($cmd->lessonSlug);
$this->progressRepo->save($progress);
// Публикуем ПОСЛЕ успешного сохранения
$this->publisher->publish(...$progress->pullEvents());
}
}
class CompleteLessonUseCase:
def __init__(self, progress_repo: ProgressRepository, publisher: EventPublisher) -> None:
self._progress_repo = progress_repo
self._publisher = publisher
def execute(self, cmd: CompleteLesson) -> None:
progress = self._progress_repo.find_by_user_and_course(cmd.user_id, cmd.course_slug)
progress.complete_lesson(cmd.lesson_slug)
self._progress_repo.save(progress)
# Публикуем ПОСЛЕ успешного сохранения: подписчики не должны узнать
# о том, чего в базе нет. Цену этого порядка см. во врезке под кодом.
self._publisher.publish(*progress.flush_events())
⚠️ Между
SaveиPublishесть окно, и его надо назватьПорядок «сначала сохранить, потом публиковать» правильный: подписчики не должны узнать о том, чего в базе нет. Но он не делает доставку надёжной, и этот пример её не гарантирует.
Что происходит, если процесс упадёт (или сеть до брокера пропадёт) между третьим и четвёртым шагом: прогресс в базе есть, события нет и уже никогда не будет. Никто не заметит - в базе всё консистентно, а письмо о завершении курса просто не придёт.
Обратный порядок не помогает, а делает хуже: публикация до сохранения означает событие о том, чего не случилось, - подписчики отреагируют на непроизошедший факт.
Транзакцией это тоже не закрывается: брокер не участвует в транзакции базы.
ROLLBACKне отзывает уже отправленное сообщение.Чем закрывается по-настоящему: событие пишется в ту же транзакцию, что и бизнес-данные - в таблицу-очередь, а отдельный процесс дочитывает её и публикует. Это паттерн Transactional Outbox, и он разобран в уроке Outbox и Inbox, с рабочим стендом и тестами на сбой в каждой точке.
Здесь его нет намеренно: цель урока - показать, как агрегат порождает события и как они доходят до обработчиков, а не собрать надёжную шину. Для процесса в одном приложении, где потеря уведомления неприятна, но не критична, показанного достаточно. Если потеря события означает потерю денег или расхождение данных между сервисами - нужен outbox.
Обработчики событий
Каждый обработчик выполняет одну побочную реакцию:
// Отправка email при завершении курса
type SendCourseFinishedEmail struct {
mailer EmailSender
log *slog.Logger
}
func (h *SendCourseFinishedEmail) Handle(ctx context.Context, event interface{}) {
e, ok := event.(domain.CourseFinished)
if !ok {
return
}
// Handle не возвращает ошибку - значит лог единственный канал, где сбой
// может стать видимым. `_ =` вместо лога превращает недоставленное
// письмо в событие, о котором никто никогда не узнает.
if err := h.mailer.Send(ctx, e.UserID, "course-finished", map[string]string{
"course": e.CourseSlug,
}); err != nil {
h.log.ErrorContext(ctx, "course-finished email failed",
slog.Int64("user_id", e.UserID),
slog.String("course", e.CourseSlug),
slog.String("err", err.Error()),
)
}
}
// Обновление статистики при прохождении урока
type UpdateProgressStats struct {
statsRepo StatsRepository
log *slog.Logger
}
func (h *UpdateProgressStats) Handle(ctx context.Context, event interface{}) {
e, ok := event.(domain.LessonCompleted)
if !ok {
return
}
// Здесь проглоченная ошибка опаснее, чем с письмом: это запись в базу,
// и её потеря означает, что статистика тихо расходится с реальностью.
// Письмо пользователь хотя бы не получит и заметит, а расхождение
// в счётчике не заметит никто.
if err := h.statsRepo.IncrementLessonsCompleted(ctx, e.UserID); err != nil {
h.log.ErrorContext(ctx, "stats increment failed",
slog.Int64("user_id", e.UserID),
slog.String("err", err.Error()),
)
}
}
<?php
declare(strict_types=1);
namespace App\Learning\Application\Handler;
use App\Learning\Domain\CourseFinished;
use App\Learning\Domain\EmailSender;
use App\Learning\Domain\LessonCompleted;
use App\Learning\Domain\StatsRepository;
use App\Learning\Infrastructure\EventHandler;
use Throwable;
// Отправка email при завершении курса
final class SendCourseFinishedEmail implements EventHandler
{
public function __construct(
private readonly EmailSender $mailer,
private readonly LoggerInterface $logger,
) {}
public function handle(object $event): void
{
if (!$event instanceof CourseFinished) {
return;
}
// Исключение здесь ловится намеренно: сбой письма не должен
// отменять прохождение курса. Но пустой catch превратил бы
// недоставленное письмо в невидимое событие - поэтому логируем.
try {
$this->mailer->send(
userId: $event->userId,
template: 'course-finished',
params: ['course' => $event->courseSlug],
);
} catch (Throwable $e) {
$this->logger->error('course-finished email failed', [
'user_id' => $event->userId,
'course' => $event->courseSlug,
'exception' => $e,
]);
}
}
}
// Обновление статистики при прохождении урока
final class UpdateProgressStats implements EventHandler
{
public function __construct(
private readonly StatsRepository $statsRepo,
private readonly LoggerInterface $logger,
) {}
public function handle(object $event): void
{
if (!$event instanceof LessonCompleted) {
return;
}
try {
$this->statsRepo->incrementLessonsCompleted($event->userId);
} catch (Throwable $e) {
$this->logger->error('stats increment failed', [
'user_id' => $event->userId,
'exception' => $e,
]);
}
}
}
import logging
# Отправка email при завершении курса
class SendCourseFinishedEmail:
def __init__(self, mailer: EmailSender, log: logging.Logger) -> None:
self._mailer = mailer
self._log = log
def handle(self, event: object) -> None:
if not isinstance(event, CourseFinished):
return
# handle ничего не возвращает - значит лог единственный канал, где сбой
# может стать видимым. Пустой except вместо лога превращает недоставленное
# письмо в событие, о котором никто никогда не узнает.
try:
self._mailer.send(event.user_id, "course-finished", {"course": event.course_slug})
except Exception as err:
self._log.error(
"course-finished email failed",
extra={"user_id": event.user_id, "course": event.course_slug, "err": str(err)},
)
# Обновление статистики при прохождении урока
class UpdateProgressStats:
def __init__(self, stats_repo: StatsRepository, log: logging.Logger) -> None:
self._stats_repo = stats_repo
self._log = log
def handle(self, event: object) -> None:
if not isinstance(event, LessonCompleted):
return
# Здесь проглоченная ошибка опаснее, чем с письмом: это запись в базу,
# и её потеря означает, что статистика тихо расходится с реальностью.
# Письмо пользователь хотя бы не получит и заметит, а расхождение
# в счётчике не заметит никто.
try:
self._stats_repo.increment_lessons_completed(event.user_id)
except Exception as err:
self._log.error(
"stats increment failed",
extra={"user_id": event.user_id, "err": str(err)},
)
⚠️ Падение обработчика не должно ломать основной сценарий
Если email-сервис недоступен, урок всё равно должен считаться пройденным. Обработчик событий - это побочный эффект. В синхронной реализации оборачивай вызов в recover или логируй ошибку без возврата. В асинхронной - используй retry-очередь.
Eventual Consistency
В синхронном монолите события обрабатываются мгновенно. Но при переходе к очередям (Kafka, RabbitMQ) обработка становится eventually consistent: факт записан, а побочные эффекты придут позже.
Пример: пользователь завершил курс, но сертификат появится через 2-3 секунды, когда обработчик прочитает событие из очереди. Для пользователя это незаметно, но архитектурно - принципиальная разница.
Правило: если побочный эффект может быть задержан на секунды без ущерба для UX - используй события. Если нет (например, проверка прав доступа) - это не событие, а часть основного потока.
Event Store: аудит и воспроизведение
Журнал доменных событий (event log) - хранилище всех событий в хронологическом порядке. В DDD Lite это не замена базы данных, а дополнение: текущее состояние хранится в таблицах, а история изменений - в журнале. В Event Sourcing тот же журнал становится Event Store - единственным источником правды, из которого восстанавливается состояние.
package domain
import (
"context"
"time"
)
type StoredEvent struct {
ID int64
EventType string
Payload []byte // JSON
OccurredAt time.Time
AggregateID int64
}
type EventStore interface {
Append(ctx context.Context, events ...StoredEvent) error
LoadByAggregate(ctx context.Context, aggregateID int64) ([]StoredEvent, error)
}
Зачем это нужно:
- Аудит: видно, кто и когда прошёл урок, даже если прогресс был сброшен
- Отладка: можно воспроизвести последовательность действий пользователя
- Аналитика: построить воронку прохождения курса по событиям
Для DDD Lite полноценный Event Sourcing избыточен. Достаточно простого лога событий в таблице domain_events - это даст аудит без сложности CQRS.
Увидеть события в работе, а не по частям, можно в мини-проекте трека: там агрегат накапливает LessonCompleted и CourseFinished, сценарий публикует их после сохранения, а обработчик по CourseFinished выдаёт сертификат.
Мини-задание
- Определи 3 доменных события для своего проекта (имена в прошедшем времени)
- Реализуй структуру одного события со всеми необходимыми полями
- Напиши интерфейс EventPublisher и InMemoryPublisher
- Добавь методы collectEvent/FlushEvents в один из своих агрегатов
- Реализуй обработчик для одного события (логирование или запись статистики)