Axon FrameWork：如何在domain_event_entry表中回滚

Question

You can see my sample classes below.

Basically, I want to use Axon's domain_event_entry table to store the events, and my own entity table to store the entities. I know that If I fire a CreateTemplateCommand which is handled in the Aggregate an Event will be published, and that after that it will go to the @EventSourcingHandler where Axon will persist the event in his domain_event_entry table.

After this part, it will go to my external @EventHandler where I want to persist my entity from the event. As you can see, I throw a RunTimeException , because I want to simulate a rollback. It will rollback in my own table, but in the Axon's domain_event_entry table there will be the event. So I will get my entity table empty, and my Axon's table with the TemplateCreatedEvent in it, but I want to rollback the domain_event_entry too.

How can I rollback the domain_event_entry table or should I use compensating events for that?

@Aggregate
@Getter
@Setter
@NoArgsConstructor
public class TemplateAggregate {

  private static final transient Logger logger = LoggerFactory.getLogger(TemplateAggregate.class);
  @AggregateIdentifier
  private String templateId;

   private LocalDate createdAt;

   private String createdBy;

   private String description;

   private LocalDate modifiedAt;

   private String modifiedBy;

   private String name;

   private LocalDate validFrom;

   private LocalDate validTo;

   private File file;

   private String fileName;

   private long fileSize;

   private LocalDate fileDate;

   private String fileUploader;

  @CommandHandler
  public TemplateAggregate(CreateTemplateCommand cmd) {
    AggregateLifecycle.apply(new TemplateCreatedEvent(cmd));
  }

  @CommandHandler
  public void handle(ModifyTemplateCommand cmd) {
    AggregateLifecycle.apply(new TemplateModifiedEvent(cmd));
  }

  @EventSourcingHandler
  public void on(TemplateCreatedEvent event) {
    this.templateId = event.getTemplateId();
     this.createdAt = event.getCreatedAt();
     this.createdBy = event.getCreatedBy();
     this.description = event.getDescription();
     this.name = event.getName();
     this.validFrom = event.getValidFrom();
     this.validTo = event.getValidTo();
     this.file = event.getFile();
     this.fileName = event.getFileName();
     this.fileSize = event.getFileSize();
     this.fileDate = event.getFileDate();
     this.fileUploader = event.getFileUploader();
    logger.info("TemplateAggregate - TemplateCreatedEvent");
  }

  @EventSourcingHandler
  public void on(TemplateModifiedEvent event) {
    this.templateId = event.getTemplateId();
     this.createdAt = event.getCreatedAt();
     this.createdBy = event.getCreatedBy();
     this.description = event.getDescription();
     this.name = event.getName();
     this.validFrom = event.getValidFrom();
     this.validTo = event.getValidTo();
     this.file = event.getFile();
     this.fileName = event.getFileName();
     this.fileSize = event.getFileSize();
     this.fileDate = event.getFileDate();
     this.fileUploader = event.getFileUploader();
     this.modifiedAt = event.getModifiedAt();
     this.modifiedBy = event.getModifiedBy();
    logger.info("TemplateAggregate - TemplateModifiedEvent");
  }

}

My External @EventHandler class:

@Service
public class TemplateCreatedEventHandler {

  private static final transient Logger logger =
      LoggerFactory.getLogger(TemplateCreatedEventHandler.class);

  @Autowired
  private TemplateRepository templateRepository;

  @Transactional
  @EventHandler
  public void on(TemplateCreatedEvent event) {
    templateRepository.save(new TemplateQueryEntity(event));
    logger.info("EventHandler - TemplateCreatedEvent");
    throw new RuntimeException();
  }



}

Answer 1

This is correct and expected behavior of a tracking event processor. The event store is the source of truth, and once your TemplateCreatedEvent has been persisted in the event store, this means 'a template created event has occurred'.

Your event processor down the line is unable to handle the event, and throws and exception. This means the transaction in your TemplateCreatedEventHandler is rolled back. This does not mean history has suddenly been changed; your event handler down the line does not get to decide that a TemplateCreatedEvent has not occurred.

When you later roll out a fix for the TemplateCreatedEventHandler so it is able to handle that event (remove the RuntimeException), the handler will handle the event and persist the entity.

If this behavior is not what you want, you can choose to use a subscribing event processor.

The SubscribingEventProcessor will have the exception bubble up to the publishing component of the Event, allowing it to deal with it, accordingly.

https://docs.axoniq.io/reference-guide/configuring-infrastructure-components/event-processing/event-processors#exceptions-during-processing