server/io.spine.server.aggregate/AggregateRepository

AggregateRepository

public abstract class AggregateRepository<I, A extends Aggregate<I, ? extends Object, ? extends Object>> extends Repository<I, E> implements CommandDispatcher, EventProducingRepository, EventDispatcherDelegate

The repository which manages instances of Aggregates.

Parameters

<I>

the type of the aggregate IDs

<A>

the type of the aggregates managed by this repository

See also

Inheritors

AggregatePartRepository

DefaultAggregateRepository

Constructors

AggregateRepository

protected void AggregateRepository()

Creates a new instance.

Functions

protected final AggregateClass<A> aggregateClass()

Obtains class information of aggregates managed by this repository.

aggregateStorage

protected AggregateStorage<I> aggregateStorage()

Returns the storage assigned to this aggregate.

public void close()

Closes the repository by closing the underlying storage.

public A create(I id)

Create a new entity instance with its default state.

protected AggregateStorage<I> createStorage()

Creates aggregate storage for the repository.

public final DispatchOutcome dispatch(CommandEnvelope cmd)

Dispatches the passed command to an aggregate.

public DispatchOutcome dispatchEvent(EventEnvelope event)

Dispatches event to one or more aggregates reacting on the event.

protected A doLoadOrCreate(I id)

public ImmutableSet<EventClass> domesticEvents()

Obtains domestic event classes dispatched by this delegate.

protected void doStore(A aggregate)

public final EventBus eventBus()

Obtains the EventBus to which the repository posts.

public ImmutableSet<EventClass> events()

Obtains all event classes dispatched by this delegate.

public ImmutableSet<EventClass> externalEvents()

Obtains external event classes dispatched by this delegate.

public Optional<A> find(I id)

Loads an aggregate by the passed ID.

importableEvents

public ImmutableSet<EventClass> importableEvents()

Obtains classes of events that can be imported by aggregates of this repository.

public final ImmutableSet<CommandClass> messageClasses()

Obtains a set of message classes that can be processed by this dispatcher.

onRoutingFailed

protected final void onRoutingFailed(SignalEnvelope<? extends Object, ? extends Object, ? extends Object> envelope, Throwable cause)

A callback invoked when an exception is thrown from message routing.

public ImmutableSet<EventClass> outgoingEvents()

Obtains classes of the events produced by entities of this repository.

protected A play(I id, AggregateHistory history)

Plays the given Aggregate history for an instance of Aggregate with the given ID.

public void registerWith(BoundedContext context)

Initializes the repository during its registration with its context.

setSnapshotTrigger

protected void setSnapshotTrigger(int snapshotTrigger)

Changes the number of events between making aggregate snapshots to the passed value.

setupCommandRouting

protected void setupCommandRouting(CommandRouting<I> routing)

A callback for derived classes to customize routing schema for commands.

setupEventRouting

protected void setupEventRouting(EventRouting<I> routing)

A callback for derived classes to customize routing schema for events.

setupImportRouting

protected void setupImportRouting(EventRouting<I> routing)

A callback for derived classes to customize routing schema for importable events.

snapshotTrigger

protected int snapshotTrigger()

Returns the number of events until a next Snapshot is made.

protected final void store(A aggregate)

Stores the passed aggregate and commits its uncommitted events.

protected AggregateClass<A> toModelClass(Class<A> cls)

Obtains a model class for the passed entity class value.

Inherited functions

public boolean canDispatch(E envelope)

Checks if this dispatcher can dispatch the given message.

checkNotRegistered

public void checkNotRegistered()

Verifies that this instance is NOT registered yet.

public void checkOpen()

Ensures that the object is open.

checkRegistered

public void checkRegistered()

Verifies that this instance is already registered.

protected static S checkStorage<S extends AutoCloseable>(S storage)

Ensures that the storage is not null.

public abstract void close()

protected final BoundedContext context()

Obtains the BoundedContext to which this repository belongs.

defaultStorageFactory

protected static StorageFactory defaultStorageFactory()

Obtains StorageFactory associated with the ServerEnvironment for creating standard storages.

dispatchesCommands

public boolean dispatchesCommands()

Verifies if this instance dispatches at least one command.

dispatchesEvents

public boolean dispatchesEvents()

Verifies if this instance dispatches at least one event.

dispatchesExternalEvents

public boolean dispatchesExternalEvents()

Verifies if this instance dispatches at least one external event.

public final Class<E> entityClass()

Returns the class of entities managed by this repository.

entityModelClass

public EntityClass<E> entityModelClass()

Obtains model class for the entities managed by this repository.

entityStateType

public final TypeUrl entityStateType()

Obtains the TypeUrl for the state objects wrapped by entities managed by this repository.

public EventFilter eventFilter()

Creates an EventFilter for this repository.

public Iterable<Event> filter(Collection<Event> events)

Filters passed events using the eventFilter filter} of this repository.

protected final boolean hasContext()

Verifies whether the repository is registered with a BoundedContext.

public final Class<I> idClass()

Returns the class of IDs used by this repository.

public ImmutableSet<String> identity()

Returns immutable set with one element with the identity of the multicast dispatcher that dispatches messages to itself.

public Iterator<I> index()

Returns an iterator over the identifiers of all the entities managed by this repository.

public final boolean isOpen()

Verifies if the repository is open.

public boolean isRegistered()

Tells if the repository is registered in a BoundedContext.

protected boolean isTypeSupplier()

Tells if this repository should be registered as a type supplier with a Stand of the BoundedContext to which this repository belongs.

public Iterator<E> iterator(Predicate<E> filter)

Returns an iterator over the entities managed by the repository that match the passed filter.

public EntityLifecycle lifecycleOf(I id)

Obtains an instance of EntityLifecycle for the entity with the given ID.

public void onRegistered()

The callback is invoked by a BoundedContext when adding the repository.

protected final void open()

Initializes the storage of the repository.

public void postEvents(Collection<Event> events)

Filters the passed events and posts the result to the EventBus.

postIfCommandRejected

public void postIfCommandRejected(SignalEnvelope<? extends Object, ? extends Object, ? extends Object> signal, Throwable cause)

If the passed signal is a command and the thrown cause is a rejection, posts the rejection to the associated EventBus.

protected final Optional<R> route<M extends Message, C extends MessageContext, R>(Route<M, C, R> routing, SignalEnvelope<? extends Object, ? extends Object, C> envelope)

protected final Storage<I, ? extends Object, ? extends Object> storage()

Returns the storage assigned to this repository.

storageAssigned

public final boolean storageAssigned()

Returns true if the storage is assigned, false otherwise.