How to use org.axonframework.eventhandling

@Override
public void prepareReset() {
  try {
    handle(GenericEventMessage.asEventMessage(new ResetTriggeredEvent()));
  } catch (Exception e) {
    throw new ResetNotSupportedException("An Error occurred while notifying handlers of the reset", e);
  }
}

/**
 * Indicates whether the given message is "redelivered", as a result of a previous reset. If {@code true}, this
 * means this message has been delivered to this processor before its token was reset.
 *
 * @param message The message to inspect
 * @return {@code true} if the message is a replay
 */
public static boolean isReplay(Message<?> message) {
  return message instanceof TrackedEventMessage
      && isReplay(((TrackedEventMessage) message).trackingToken());
}

  @SuppressWarnings("unchecked")
  public <T> TrackedEventMessage<T> alterToken(TrackedEventMessage<T> message) {
    if (lastToken == null) {
      return message;
    }
    if (message instanceof DomainEventMessage) {
      return new GenericTrackedDomainEventMessage<>(lastToken.advancedTo(message.trackingToken()),
                             (DomainEventMessage<T>) message);
    } else {
      return new GenericTrackedEventMessage<>(lastToken.advancedTo(message.trackingToken()), message);
    }
  }
}

@EventHandler
protected void handle(EventMessage event) {
  identifier = ((DomainEventMessage) event).getAggregateIdentifier();
}

/**
 * Initialize a DomainEventMessage originating from an aggregate.
 *
 * @param trackingToken Tracking token of the event
 * @param delegate      Delegate domain event containing other event data
 */
public GenericTrackedDomainEventMessage(TrackingToken trackingToken, DomainEventMessage<T> delegate) {
  this(trackingToken, delegate.getType(), delegate.getAggregateIdentifier(), delegate.getSequenceNumber(),
     delegate, delegate.getTimestamp());
}

@Before
public void setUp() {
  SimpleEventHandlerInvoker eventHandlerInvoker = SimpleEventHandlerInvoker.builder()
                                       .eventHandlers(this)
                                       .build();
  eventProcessor = SubscribingEventProcessor.builder()
                       .name("test")
                       .eventHandlerInvoker(eventHandlerInvoker)
                       .messageSource(eventBus)
                       .build();
  eventProcessor.start();
}

private void configureProcessor(TrackingEventProcessorConfiguration processorConfiguration) {
  testSubject = TrackingEventProcessor.builder()
                    .name("test")
                    .eventHandlerInvoker(eventHandlerInvoker)
                    .messageSource(eventBus)
                    .tokenStore(tokenStore)
                    .transactionManager(NoTransactionManager.INSTANCE)
                    .trackingEventProcessorConfiguration(processorConfiguration)
                    .build();
}

@Override
public Instant resolveParameterValue(Message message) {
  if (message instanceof EventMessage) {
    return ((EventMessage) message).getTimestamp();
  }
  return null;
}

@Override
public TrackingToken resolveParameterValue(Message<?> message) {
  return unwrap(((TrackedEventMessage) message).trackingToken());
}

/**
 * Indicates whether this tracking processor supports a "reset". Generally, a reset is supported if at least one
 * of the event handlers assigned to this processor supports it, and no handlers explicitly prevent the resets.
 *
 * @return {@code true} if resets are supported, {@code false} otherwise
 */
public boolean supportsReset() {
  return eventHandlerInvoker().supportsReset();
}

@Override
public void handle(EventMessage<?> message, Segment segment) throws Exception {
  for (EventMessageHandler handler : wrappedEventHandlers) {
    try {
      handler.handle(message);
    } catch (Exception e) {
      listenerInvocationErrorHandler.onError(e, message, handler);
    }
  }
}

private TrackingToken unwrap(TrackingToken trackingToken) {
  if (trackingToken instanceof WrappedToken) {
    return unwrap(((WrappedToken) trackingToken).unwrap());
  }
  return trackingToken;
}

@Override
public boolean supportsReset() {
  for (EventMessageHandler eventHandler : wrappedEventHandlers) {
    if (!eventHandler.supportsReset()) {
      return false;
    }
  }
  return true;
}

/**
 * Initializes a {@link TrackingEventProcessor} as specified through this Builder.
 *
 * @return a {@link TrackingEventProcessor} as specified through this Builder
 */
public TrackingEventProcessor build() {
  return new TrackingEventProcessor(this);
}

/**
 * Instantiate an {@link AbstractEventBus} based on the fields contained in the {@link Builder}.
 *
 * @param builder the {@link Builder} used to instantiate an {@link AbstractEventBus} instance
 */
protected AbstractEventBus(Builder builder) {
  builder.validate();
  this.messageMonitor = builder.messageMonitor;
}

/**
 * {@inheritDoc}. Defaults to a {@link RollbackConfigurationType#ANY_THROWABLE})
 */
@Override
public Builder rollbackConfiguration(RollbackConfiguration rollbackConfiguration) {
  super.rollbackConfiguration(rollbackConfiguration);
  return this;
}

@Override
public Builder name(String name) {
  super.name(name);
  return this;
}

@Override
public Builder eventHandlerInvoker(EventHandlerInvoker eventHandlerInvoker) {
  super.eventHandlerInvoker(eventHandlerInvoker);
  return this;
}

@Override
public Builder errorHandler(ErrorHandler errorHandler) {
  super.errorHandler(errorHandler);
  return this;
}

/**
 * Instantiate a Builder to be able to create a {@link SimpleEventBus}.
 * <p>
 * The {@link MessageMonitor} is defaulted to a {@link NoOpMessageMonitor} and the {@code queueCapacity} to
 * {@link Integer#MAX_VALUE}.
 *
 * @return a Builder to be able to create a {@link SimpleEventBus}
 */
public static Builder builder() {
  return new Builder();
}