Представленные примеры реализованы на языке Kotlin с использованием Spring, базы данных MongoDB. Но все тоже самое может быть легко реализовано и с использованием реляционной модели.

abstract class Entity<ID : Serializable>(val id: ID) {

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other == null || this::class != other::class) return false

        val casted = other as Entity<*>

        if (id != casted.id) return false

        return true
    }

    override fun hashCode() = id.hashCode()
}

Сущность характеризуется только своей идентичностью (id)

abstract class DomainEvent<A : RootAggregate<A, ID>, ID : Serializable, BODY : Any>(
    val id: Id,
    val type: String,
    val aggregate: String,
    val aggregateId: ID,
    val occurredOn: ZonedDateTime,
    val body: BODY?
) {
    constructor(aggregate: A, type: String, body: BODY? = null) : this(
        Id(),
        "${aggregate.aggregateName}.$type",
        aggregate.aggregateName,
        aggregate.id,
        ZonedDateTime.now(),
        body
    )

    data class Id(val id: UUID? = UUID.randomUUID())


    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (other == null || this::class != other::class)
            return false

        val casted = this::class.cast(other)

        if (id != casted.id) return false

        return true
    }

    override fun hashCode() = id.hashCode()

    override fun toString(): String =
        "${this::class.simpleName}(id=$id, type='$type', aggregate='$aggregate', aggregateId=$aggregateId, occurredOn=$occurredOn, body=$body)"

}

abstract class RootAggregate<A : RootAggregate<A, ID>, ID : Serializable>(id: ID) : Entity<ID>(id) {
    companion object {
        private val camelRegex = "(?<=[a-zA-Z])[A-Z]".toRegex()
    }

    private fun String.camelToSnakeCase(): String {
        return camelRegex.replace(this) { "_${it.value}" }.lowercase(Locale.getDefault())
    }

    @Transient
    val aggregateName = this::class.simpleName!!.camelToSnakeCase()

    @Transient
    private val _events = mutableListOf<DomainEvent<A, ID, *>>()
    val events: List<DomainEvent<A, ID, *>>
        get() = _events.toList()

    protected fun addEvent(event: DomainEvent<A, ID, *>) {
        _events.add(event)
    }

    fun clearEvents() {
        _events.clear()
    }
}

interface DomainRepository<A : RootAggregate<A, ID>, ID : Serializable> {
    fun save(aggregate: A): A

    fun saveAll(aggregates: Iterable<A>): List<A>

    fun findById(id: ID): A?
  
    fun deleteById(id: ID)
    
    fun delete(aggregate: A)
}

import org.aopalliance.intercept.MethodInterceptor
import org.springframework.aop.framework.ProxyFactory
import org.springframework.beans.factory.BeanFactory
import org.springframework.beans.factory.BeanFactoryAware
import org.springframework.beans.factory.config.BeanPostProcessor
import org.springframework.core.Ordered
import org.springframework.data.mongodb.core.MongoTemplate
import org.springframework.transaction.support.TransactionTemplate
import pro.korobovn.domaintypes.DomainRepository
import pro.korobovn.domaintypes.RootAggregate


class TransactionalOutboxBeanPostProcessor : BeanPostProcessor, Ordered, BeanFactoryAware {

    private lateinit var transactionTemplate: TransactionTemplate

    private lateinit var mongoTemplate: MongoTemplate

    private lateinit var domainEventRepository: DomainEventRepository

    override fun postProcessBeforeInitialization(bean: Any, beanName: String): Any = bean

    override fun postProcessAfterInitialization(bean: Any, beanName: String): Any =
        if (bean is DomainRepository<*, *>) createTransactionalProxy(bean) else bean

    private fun createTransactionalProxy(bean: Any) =
        ProxyFactory(bean)
            .apply {
                addAdvice(saveInterceptor)
                addAdvice(saveAllInterceptor)
            }.proxy

    private val saveInterceptor = MethodInterceptor { invocation ->
        if (
            invocation.method.name == "save" &&
            RootAggregate::class.java.isAssignableFrom(invocation.method.returnType) &&
            invocation.arguments.firstOrNull() is RootAggregate<*, *> &&
            (invocation.arguments.firstOrNull() as RootAggregate<*, *>).events.isNotEmpty()
        ) {
            val aggregate = invocation.arguments.firstOrNull() as RootAggregate<*, *>
            transactionTemplate.execute {
                domainEventRepository.insertAll(aggregate.events)
                invocation.proceed()
            }
        } else invocation.proceed()
    }

    private val saveAllInterceptor = MethodInterceptor { invocation ->
        if (
            invocation.method.name == "saveAll" &&
            List::class.java.isAssignableFrom(invocation.method.returnType) &&
            invocation.arguments.firstOrNull() is Iterable<*>
        ) {
            @Suppress("UNCHECKED_CAST")
            val aggregates = invocation.arguments.firstOrNull() as Iterable<RootAggregate<*, *>>
            val events = aggregates.flatMap(RootAggregate<*, *>::events).toList()
            if (events.isNotEmpty())
                transactionTemplate.execute {
                    domainEventRepository.insertAll(events)
                    invocation.proceed()
                }
            else invocation.proceed()
        } else invocation.proceed()
    }

    override fun getOrder(): Int = Ordered.LOWEST_PRECEDENCE

    override fun setBeanFactory(beanFactory: BeanFactory) {
        this.transactionTemplate = beanFactory.getBean(TransactionTemplate::class.java)
        this.mongoTemplate = beanFactory.getBean(DomainEventRepository::class.java)
    }

}

@Document
class Cart(id: Id = Id()) : RootAggregate<Cart, Cart.Id>(id) {

    data class Id(val id: UUID = UUID.randomUUID()) : Serializable

    data class Item(val name: String, val quantity: Quantity = Quantity.ONE)

    private var _items: MutableList<Item> = mutableListOf()

    val items: List<Item>
        get() = _items.toList()

    fun add(item: Item) {
        _items.add(item)
        addEvent(CartWasChangedEvent.itemWasAdded(this, item))
    }


    override fun toString(): String {
        return "Cart(id=$id, items=$items)"
    }

}

Тут мы видим, что при изменении корзины сам агрегат фактически размещает addEvent событие об изменение своего состояния CartWasChangedEvent. Формально выполнили простой перенос размещения события со слоя сервисов на слой доменной логики. Эти изменения делают доменную модель менее анемичной, агрегат самостоятельно отвечает за соблюдение своих инвариантов о необходимости размещение события при изменении, не полагаясь на уровень сервисов.

class CartWasChangedEvent : DomainEvent<Cart, Cart.Id, CartWasChangedEvent.Body> {
    enum class ChangeType {
        ADDED, REMOVED
    }

    data class Body(val type: ChangeType, val item: Cart.Item)

    @PersistenceCreator
    private constructor(
        id: Id,
        type: String,
        aggregate: String,
        aggregateId: Cart.Id,
        occurredOn: ZonedDateTime,
        body: Body
    ) : super(id, type, aggregate, aggregateId, occurredOn, body)

    constructor(aggregate: Cart, body: Body) : super(aggregate, "changed.added", body)

    companion object {
        fun itemWasAdded(cart: Cart, item: Cart.Item) = CartWasChangedEvent(cart, Body(ChangeType.ADDED, item))
    }
}

У события имеется два констуктора. Первый конструктор для восстановления объекта из базы данных - приватный, вызывается только фреймворком. Второй конструктор - пользовательский.