How to use

BatchingEventStorageEngine

in

org.axonframework.eventsourcing.eventstore

@Test
@SuppressWarnings("OptionalGetWithoutIsPresent")
public void testLoad_LargeAmountOfEvents() {
  int eventCount = testSubject.batchSize() + 10;
  testSubject.appendEvents(createEvents(eventCount));
  assertEquals(eventCount, testSubject.readEvents(AGGREGATE).asStream().count());
  assertEquals(eventCount - 1,
         testSubject.readEvents(AGGREGATE).asStream().reduce((a, b) -> b).get().getSequenceNumber());
}

@Override
protected Stream<? extends DomainEventData<?>> readEventData(String identifier, long firstSequenceNumber) {
  EventStreamSpliterator<? extends DomainEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchDomainEvents(identifier,
                     lastItem == null ? firstSequenceNumber : lastItem.getSequenceNumber() + 1,
                     batchSize), batchSize, fetchForAggregateUntilEmpty());
  return StreamSupport.stream(spliterator, false);
}

/**
 * {@inheritDoc}
 * <p>
 * This implementation produces non-blocking event streams.
 */
@Override
protected Stream<? extends TrackedEventData<?>> readEventData(TrackingToken trackingToken, boolean mayBlock) {
  EventStreamSpliterator<? extends TrackedEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchTrackedEvents(lastItem == null ? trackingToken : lastItem.trackingToken(), batchSize),
      batchSize, true);
  return StreamSupport.stream(spliterator, false);
}

private Thread[] storeEvents(int threadCount, int eventsPerThread, int inverseRollbackRate) {
  Thread[] threads = new Thread[threadCount];
  for (int i = 0; i < threadCount; i++) {
    final int threadIndex = i;
    threads[i] = new Thread(() -> {
      for (int j = 0; j < eventsPerThread; j++) {
        final int s = j;
        try {
          txTemplate.execute(ts -> {
            testSubject.appendEvents(
                createEvent(AGGREGATE, threadIndex * eventsPerThread + s, "Thread" + threadIndex));
            if (s % inverseRollbackRate == 0) {
              throw new RuntimeException("Rolling back on purpose");
            }
            try {
              Thread.sleep(ThreadLocalRandom.current().nextInt(10));
            } catch (InterruptedException e) {
              e.printStackTrace();
            }
            return null;
          });
        } catch (Exception ignored) {
        }
      }
    });
    threads[i].start();
  }
  return threads;
}

  private List<TrackedEventMessage<?>> readEvents(int eventCount) {
    List<TrackedEventMessage<?>> result = new ArrayList<>();
    TrackingToken lastToken = null;
    while (result.size() < eventCount) {
      List<? extends TrackedEventMessage<?>> batch =
          testSubject.readEvents(lastToken, false).collect(Collectors.toList());
      for (TrackedEventMessage<?> message : batch) {
        result.add(message);
        if (logger.isDebugEnabled()) {
          logger.debug(message.getPayload() + " / " + ((DomainEventMessage<?>) message).getSequenceNumber() +
                     " => " + message.trackingToken().toString());
        }
        lastToken = message.trackingToken();
      }
    }
    return result;
  }
}

@Override
protected Stream<? extends DomainEventData<?>> readEventData(String identifier, long firstSequenceNumber) {
  EventStreamSpliterator<? extends DomainEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchDomainEvents(identifier,
                     lastItem == null ? firstSequenceNumber : lastItem.getSequenceNumber() + 1,
                     batchSize), batchSize, fetchForAggregateUntilEmpty());
  return StreamSupport.stream(spliterator, false);
}

/**
 * {@inheritDoc}
 * <p>
 * This implementation produces non-blocking event streams.
 */
@Override
protected Stream<? extends TrackedEventData<?>> readEventData(TrackingToken trackingToken, boolean mayBlock) {
  EventStreamSpliterator<? extends TrackedEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchTrackedEvents(lastItem == null ? trackingToken : lastItem.trackingToken(), batchSize),
      batchSize, true);
  return StreamSupport.stream(spliterator, false);
}

@Override
protected Stream<? extends DomainEventData<?>> readEventData(String identifier, long firstSequenceNumber) {
  EventStreamSpliterator<? extends DomainEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchDomainEvents(identifier,
                     lastItem == null ? firstSequenceNumber : lastItem.getSequenceNumber() + 1,
                     batchSize), batchSize, fetchForAggregateUntilEmpty());
  return StreamSupport.stream(spliterator, false);
}

/**
 * {@inheritDoc}
 * <p>
 * This implementation produces non-blocking event streams.
 */
@Override
protected Stream<? extends TrackedEventData<?>> readEventData(TrackingToken trackingToken, boolean mayBlock) {
  EventStreamSpliterator<? extends TrackedEventData<?>> spliterator = new EventStreamSpliterator<>(
      lastItem -> fetchTrackedEvents(lastItem == null ? trackingToken : lastItem.trackingToken(), batchSize),
      batchSize, true);
  return StreamSupport.stream(spliterator, false);
}