Why does Axon throw a ConcurrencyException from second request onwards? - spring-boot

Question

I'm doing a POC with Axon. I found that axon is able to process my first POST request and for all subsequent POST request I get the following exception. For every Create request , I create unique identifier IdentifierFactory.getInstance().generateIdentifier(), So, this should Ideally work and I see this also changing from breakpoint but index id is becoming same.
Can someone please find the missing part here.
org.hsqldb.HsqlException: integrity constraint violation: unique constraint or index violation; UK8S1F994P4LA2IPB13ME2XQM1W table: DOMAIN_EVENT_ENTRY
org.axonframework.modelling.command.ConcurrencyException(An event for aggregate [0] at
sequence [0] was already inserted)
POST Requests:
Request 1: This one succeeds
curl --location --request POST 'http://localhost:8080/raise/issues' \
--header 'Content-Type: application/json' \
--data-raw '{"description":"Demo issue1","type":"DEMO1"}'
Request 2: This one onwards it fails
curl --location --request POST 'http://localhost:8080/raise/issues' \
--header 'Content-Type: application/json' \
--data-raw '{"description":"Demo issue2","type":"DEMO2"}'
Controller:
public class IssueTracker {
#Inject
private IssueTrackerService issueTrackerService;
#GetMapping("/issues")
public List<Issue> getAllIssues() {
return issueTrackerService.getAllIssues();
}
#PostMapping(value = "/raise/issues", consumes = "application/json")
public CompletableFuture<IssueCommand> raiseIssue(#RequestBody IssueView issueView) {
return issueTrackerService.raiseIssue(issueView);
}
}
Service:
package com.axon.axondemo.service;
import com.axon.axondemo.dao.Issue;
import com.axon.axondemo.dto.IssueCommand;
import com.axon.axondemo.repository.IssueTRepository;
import com.axon.axondemo.view.IssueView;
import org.axonframework.commandhandling.gateway.CommandGateway;
import org.axonframework.common.IdentifierFactory;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.concurrent.CompletableFuture;
#Service
public class IssueTrackerService {
private final IssueTRepository issueTRepository;
private final CommandGateway commandGateway;
public IssueTrackerService(IssueTRepository issueTRepository, CommandGateway commandGateway) {
this.issueTRepository = issueTRepository;
this.commandGateway = commandGateway;
}
public CompletableFuture<IssueCommand> raiseIssue(IssueView issueView) {
return commandGateway.send(new IssueCommand(IdentifierFactory.getInstance().generateIdentifier(), issueView.getDescription(), issueView.getType()));
}
public List<Issue> getAllIssues() {
return issueTRepository.findAll();
}
}
Entity:
import com.axon.axondemo.dto.IssueCommand;
import com.axon.axondemo.events.IssueEvent;
import org.axonframework.commandhandling.CommandHandler;
import org.axonframework.eventsourcing.EventSourcingHandler;
import org.axonframework.modelling.command.AggregateIdentifier;
import org.axonframework.spring.stereotype.Aggregate;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import static org.axonframework.modelling.command.AggregateLifecycle.apply;
#Aggregate
#Entity
public class Issue {
#Id
#GeneratedValue(strategy = GenerationType.AUTO)
#AggregateIdentifier
private long id;
private String description;
private String type;
public Issue() {}
public Issue(String description, String type) {
this.description = description;
this.type = type;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
#CommandHandler
public Issue(IssueCommand issueCommand) {
apply(new IssueEvent(issueCommand.getAggregateRefno(), issueCommand.getDescription(), issueCommand.getType()));
}
#EventSourcingHandler
public void on(IssueEvent issueEvent) {
this.description = issueEvent.getDescription();
this.type = issueEvent.getType();
}
}
Command:
package com.axon.axondemo.dto;
import org.axonframework.modelling.command.TargetAggregateIdentifier;
public class IssueCommand {
private String description;
private String type;
#TargetAggregateIdentifier
private String aggregateRefno;
public IssueCommand(String aggregateRefno, String description, String type) {
this.aggregateRefno = aggregateRefno;
this.description = description;
this.type = type;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getAggregateRefno() {
return aggregateRefno;
}
public void setAggregateRefno(String aggregateRefno) {
this.aggregateRefno = aggregateRefno;
}
}
Event:
package com.axon.axondemo.events;
public class IssueEvent {
private String aggregateRefno;
private String description;
private String type;
public IssueEvent() {}
public IssueEvent(String aggregateRefno, String description, String type) {
this.description = description;
this.type = type;
this.aggregateRefno = aggregateRefno;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getAggregateRefno() {
return aggregateRefno;
}
public void setAggregateRefno(String aggregateRefno) {
this.aggregateRefno = aggregateRefno;
}
}
Query/Handler:
package com.axon.axondemo.handler;
import com.axon.axondemo.events.IssueEvent;
import org.axonframework.eventhandling.EventHandler;
import org.springframework.stereotype.Component;
#Component
public class IssueEventHandler {
#EventHandler
public void on(IssueEvent issueEvent) {
System.out.println("*************");
System.out.println("*************");
System.out.println("Issue event handled!!!!");
System.out.println(issueEvent.getDescription());
System.out.println("*************");
System.out.println("*************");
}
}
Repository:
package com.axon.axondemo.repository;
import com.axon.axondemo.dao.Issue;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
#Repository
public interface IssueTRepository extends JpaRepository<Issue, Long> {
}

Answer 1

#Flaxel his/her argument is something to take note of:
I would not implement the entity and aggregate as a common object.
I'd add though that it is definitely not wrong what you are doing there. The main difference is that you are not doing Event Sourcing if you make the Aggregate a stored entity as is. A choice you have, which from Axon's Reference Guide lands you up on the "State-Stored Aggregate". However, your Aggregate snippet does use an #EventSourcingHandler annotated method, seemingly showing you do want to use Event Sourcing for said aggregate. Hence it be worth taking either the state-stored or event sourcing approach within your aggregate design to keep things clear. However, this doesn't answer the problem you are encountering though, so let's focus on that further.
The exception you are receiving is being sent because your application tries to store events for the same aggregate on the same location. Normally this suggests that two distinct instances of your service are loading the same aggregate and performing operations on it, something which is undesirable because it introduces concurrency exceptions. Hence why Axon throws a ConcurrencyException.
As you've seen from the message, the uniqueness constraint is build out of the aggregate identifier and the sequence number. The latter is an incremental number describing the position of an events in an Aggregates stream. You don't have immediate control over this value. The thing you do control is the aggregate identifier.
Currently, your #AggregateIdentifier annotated field is the same as the #Id annotated field. Again nothing wrong with this. What I wouldn't do though is make it a long. Using a long (generated or not) will make it so that you will see that concurrency exception quite often I think, especially once you start scaling out. Assume you have four instances of this application running, all concurrently handling commands. Will you be using a distributed sequence generator just so that the Aggregate Identifiers all walk in line? Doable, yes, but it introduces quite some complexity on that end.
I'd recommend using a regular random UUID as the #AggregateIdentifier annotated field instead. You are far more certain to (virtually) never hit a duplicate id in that case.
Still, this doesn't answer to me why the second command you issue makes it so that your sequence generator reuses ID 0 instead of adjusting it. What I do know, is that it's not so much an Axon Framework thing anymore, as this occurs due to usage of the #GeneratedValue annotation.
The Baeldung page referenced by #flaxel could proof as a nice starting point, as it has been updated by the AxonIQ team themselves. On top of that, there are a bunch of quick start videos you could check out. Lastly, partaking in a Fast Lane Axon Training (just 2 hours) could proof helpful as well if you find yourself stuck in the future.

Answer 2

I would not implement the entity and aggregate as a common object. Maybe this causes problems because the AggregateIdentifier and the Id is set to a variable and the Id is autogenerated. It mixes two concepts. Baeldung made a nice tutorial about Axon and Spring Boot. If the tutorial does not help you, then you can ask again.
What else you could use is Lombok. This makes your classes look even more clearly arranged.