How to manage the transaction between domain logic and events in DDD?

Question

I am learning programming in DDD and event source.

I saw one example: when the domain logic was called (e.g. Order.placeOrder() ), it would post an event (e.g. OrderPlaced ). And the event will be sent to MQ as an event repository.

The domain logic ( Order.placeOrder() ) must be an atomic API, and it must have the @Transactional annotation if Spring is used for the transaction manager.

And now my question is:

• How to make sure that changing a database and sending an event are in the same transaction? those. if an error occurred while transferring data to the database, the event should never be sent to MQ.

  I know that there is a solution, such as XA or 2-phase commit, to force the database to be updated and send MQ messages in a single transaction. But it seems that it is not widely used these days.

• If you still use the Spring @Transactional annotation and there is no XA, is it possible that we will execute some logic after the transaction completes successfully? What is the best practice for this?

Answer 1

The following two properties must have a reliable system:

• P1: Published domain events MUST describe the change that has occurred (i.e., not trigger ghost events).
• P2: Changes to the database that trigger MUST domain events result in the publication of the event (i.e. do not lose the event).

There are the following possibilities for achieving this, all of which I either used myself or saw that it is used in the project:

• Use a messaging infrastructure that uses the same database as your application so that you can use one transaction. This solution is viable when the messaging infrastructure is simple enough and the team decides to create it itself.

• Use 2-phase fixations. I have no impression that this is no longer being used, but perhaps they are talking less about it because it is not fancy technology ...

• Use some clever tricks to keep both conditions intact. For example. with what I call chicken and egg solution:

  • First, publish events synchronously, and then save to the database. This provides P2.
  • Then use an event processor that checks the flow of events and checks to see if the event can be found in the database. If not, remove the event from the stream. This ensures that P1 is executed.

Decision 3 requires careful development and analysis of the guarantees that each part of the system makes in terms of fault behavior, so law is probably the most difficult. But it is also a very elegant solution when it works.

By the way, I do not agree that Spring annotations should be added to domain objects, but rather to related applications. This is just a note.