Package org.axonframework.eventsourcing.eventstore

Class InterceptingEventStore

java.lang.Object
org.axonframework.eventsourcing.eventstore.InterceptingEventStore
All Implemented Interfaces:
DescribableComponent, EventStore, SubscribableEventSource, EventBus, EventSink, StreamableEventSource, TrackingTokenSource
@Internal public class InterceptingEventStore extends Object implements EventStore
Decorator around the EventStore intercepting all events before they are appended or published with dispatch interceptors.

This InterceptingEventStore is typically registered as a decorator and automatically kicks in whenever MessageDispatchInterceptors are present.

Since:
5.0.0
Author:
Steven van Beelen

  • Field Details

    • DECORATION_ORDER

      public static final int DECORATION_ORDER
      The order in which the InterceptingEventStore is applied as a decorator to the EventStore.

      As such, any decorator with a lower value will be applied to the delegate, and any higher value will be applied to the InterceptingEventStore itself. Using the same value can either lead to application of the decorator to the delegate or the InterceptingEventStore, depending on the order of registration.

      The order of the InterceptingEventStore is set to Integer.MIN_VALUE + 50 to ensure it is applied very early in the configuration process, but not the earliest to allow for other decorators to be applied.

      See Also:

  • Constructor Details

  • Method Details

    • transaction

      public EventStoreTransaction transaction(@Nonnull ProcessingContext processingContext)
      Description copied from interface: EventStore
      Retrieves the transaction for appending events for the given processingContext. If no transaction is available, a new, empty transaction is created.
      Specified by:
      transaction in interface EventStore
      Parameters:
      processingContext - The context for which to retrieve the EventStoreTransaction.
      Returns:
      The EventStoreTransaction, existing or newly created, for the given processingContext.

    • publish

      public CompletableFuture<Void> publish(@Nullable ProcessingContext context, @Nonnull List<EventMessage> events)
      Description copied from interface: EventSink
      Publishes the given events within the given context, when present.

      When present, the post invocation phase is used to publish the events. As a consequence, the resulting CompletableFuture completes when the events are staged in that phase.

      When no ProcessingContext is provided, implementers of this interface may choose to create a ProcessingContext when necessary.

      Specified by:
      publish in interface EventSink
      Parameters:
      context - The processing context, if any, to publish the given events in.
      events - The events to publish in this sink.
      Returns:
      A CompletableFuture of Void. When this completes and a non-null context was given, this means the events have been successfully staged. When a null context was provided, successful completion of this future means the events where published.

    • open

      public MessageStream<EventMessage> open(@Nonnull StreamingCondition condition, @Nullable ProcessingContext context)
      Description copied from interface: StreamableEventSource
      Open an event stream containing all events matching the given condition.

      To retrieve the position of the returned events, the TrackingToken.fromContext(Context) operation should be used by providing the entire MessageStream.Entry wrapping the returned events.

      Note that the returned stream is infinite, so beware of applying terminal operations to the returned stream.

      When all events are of interest during streaming, then use EventCriteria.havingAnyTag() as the condition criteria.

      Specified by:
      open in interface StreamableEventSource
      Parameters:
      condition - The StreamingCondition defining the starting position of the stream and event criteria to filter the stream with.
      context - The current ProcessingContext, if any.
      Returns:
      An event stream matching the given condition.

    • firstToken

      public CompletableFuture<TrackingToken> firstToken(@Nullable ProcessingContext context)
      Description copied from interface: TrackingTokenSource
      Creates a TrackingToken representing the first position of the event stream.

      As the retrieved token represents the point from which to

      invalid reference 
      open
      the event stream, the first event to be streamed when opening is the one right after the returned token.

      Subsequent invocation of this method will yield the same result, unless the stream's initial values are deleted.

      Specified by:
      firstToken in interface TrackingTokenSource
      Parameters:
      context - The current ProcessingContext, if any.
      Returns:
      A CompletableFuture of a TrackingToken representing the first event of the event stream.

    • latestToken

      public CompletableFuture<TrackingToken> latestToken(@Nullable ProcessingContext context)
      Description copied from interface: TrackingTokenSource
      Creates a TrackingToken representing the latest position, thus pointing at the next event of the event stream.

      As the retrieved token represents the point from which to

      invalid reference 
      open
      the event stream, the first event to be streamed when opening is the one right after the returned token.

      Since the event stream of this source is theoretically infinite, subsequent invocation of this operation typically return a different token. Only if this StreamableEventSource is idle, will several latestToken() invocations result in the same TrackingToken.

      Specified by:
      latestToken in interface TrackingTokenSource
      Parameters:
      context - The current ProcessingContext, if any.
      Returns:
      A CompletableFuture of a TrackingToken representing the latest event, thus pointing at the next event of the event stream.

    • tokenAt

      public CompletableFuture<TrackingToken> tokenAt(@Nonnull Instant at, @Nullable ProcessingContext context)
      Description copied from interface: TrackingTokenSource
      Creates a TrackingToken tracking all events after the given at from an event stream.

      When there is an EventMessage exactly at the given dateTime, it will be tracked too.

      Specified by:
      tokenAt in interface TrackingTokenSource
      Parameters:
      at - The Instant determining how the TrackingToken should be created. The returned token points at very first event before this Instant.
      context - The current ProcessingContext, if any.
      Returns:
      A CompletableFuture of TrackingToken pointing at the very first event before the given at of the event stream.

    • describeTo

      public void describeTo(@Nonnull ComponentDescriptor descriptor)
      Description copied from interface: DescribableComponent
      Describe the properties of this DescribableComponent with the given descriptor.

      Components should call the appropriate describeProperty methods on the descriptor to register their properties. The descriptor is responsible for determining how these properties are formatted and structured in the final output.

      Best Practices: As a general rule, all relevant fields of a DescribableComponent implementation should be described in this method. However, developers have discretion to include only the fields that make sense in the context. Not every field may be meaningful for description purposes, especially internal implementation details. Furthermore, components might want to expose different information based on their current state. The final decision on what properties to include lies with the person implementing the describeTo method, who should focus on providing information that is useful for understanding the component's configuration and state.

      Example implementation: 

       public void describeTo(ComponentDescriptor descriptor) {
     descriptor.describeProperty("name", this.name);
     descriptor.describeProperty("enabled", this.enabled);
     descriptor.describeProperty("configuration", this.configuration); // A nested component
     descriptor.describeProperty("handlers", this.eventHandlers);      // A collection
 }
      Specified by:
      describeTo in interface DescribableComponent
      Parameters:
      descriptor - The component descriptor to describe this DescribableComponentn its properties in.

    • subscribe

      public Registration subscribe(@Nonnull BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
      Description copied from interface: SubscribableEventSource
      Subscribe the given eventsBatchConsumer to this event source. When subscribed, it will receive all events published to this source since the subscription.

      If the given eventsBatchConsumer is already subscribed, nothing happens.

      Note on ProcessingContext: The ProcessingContext parameter passed to the consumer may be null. When null, it is the responsibility of the registered eventsBatchConsumer to create an appropriate ProcessingContext as needed for processing the events.

      Specified by:
      subscribe in interface SubscribableEventSource
      Parameters:
      eventsBatchConsumer - The event batches consumer to subscribe.
      Returns:
      A Registration handle to unsubscribe the eventsBatchConsumer. When unsubscribed, it will no longer receive events.