Btukfyl

I try to define immutable Event-Entites (Event Sourcing) using Java JPA/Hibernate and want those events to have an absolute ordering that already is defined right after object-creation, before any persistence has taken place (no distributed setup where one would need consensus)

We are using automatic auditing properties using @CreatedDate but I crossed that off my list since this is only populated during persistence.

I can think of 2 options:

1. using a global database-sequence that is queried during object-creation


2. 
   Long ordering = System.nanoTime()

any advice/idea appreciated.

want those events to have an absolute ordering that already is defined
right after object-creation

1. 
   

   The simpliest solution is like:

   
   
   

   public class SomeEntity {
   
       private LocalDateTime createdAt = LocalDateTime.now();
   
   }
   
   

   
   
   

   Of course it is possible that two objects will be created simultaneously and will have the same date, but it might be extremely hard to get.

   
   


2. 
   

   A bit more complex - ordered by id if dates are equal and both objects are persisted. There may be indeterminacy if some of objects is not persisted yet, but if both are persisted - strict order is guaranteed:

   
   
   

   public class SomeEntity implements Comparable<SomeEntity> {
   
   
   
       private Long id;
   
   
   
       private LocalDateTime createdAt = LocalDateTime.now();
   
   
   
       @Override
   
       public int compareTo(SomeEntity o) {
   
           int result = createdAt.compareTo(o.createdAt);
   
           if (result == 0) {
   
               if (id != null && o.id != null) {
   
                   result = id.compareTo(o.id);
   
               } else if (id != null) {
   
                   result = 1;
   
               } else if (o.id != null) {
   
                   result = -1;
   
               }
   
           }
   
           return result;
   
       }
   
   }
   
   

   
   


3. 
   

   The most complex option but strict ordering is guaranteed: you can create counter service in your JVM and create events through factory, that will use that counter during event creation.

   
   
   

   public class CounterService {
   
       AtomicInteger counter = new AtomicInteger();
   
       public int getNext() {
   
           return counter.incrementAndGet();
   
       }
   
   }
   
   
   
   public class SomeEntityFactory {
   
       private CounterService counterService;
   
   
   
       public SomeEntity create() {
   
           return new SomeEntity(counterService.getNext());
   
       }
   
   }
   
   
   
   public class SomeEntity {
   
       private int order;
   
   
   
       SomeEntity(int order) {
   
           this.order = order;
   
       }
   
   }
   
   

   
   
   

   Of course, this is example only, counter service might return BigInteger and be a web service, for instance. Or you can use a database sequence like a counter.