Package org.axonframework.modelling.repository

Class AccessSerializingRepository<ID,E>

java.lang.Object
org.axonframework.modelling.repository.AccessSerializingRepository<ID,E>
Type Parameters:
ID - The type of identifier used to identify entities stored by this repository.
E - The type of entity stored in this repository.
All Implemented Interfaces:
DescribableComponent, Repository<ID,E>, Repository.LifecycleManagement<ID,E>
public class AccessSerializingRepository<ID,E> extends Object implements Repository.LifecycleManagement<ID,E>, DescribableComponent
Repository implementation that ensures safe concurrent access to entities stored in it. It delegates the actual loading of entities to another Repository, but attempts to pass loaded elements to waiting components immediately, to avoid avoidable load operations on the underlying repository.
Since:
5.0.0
Author:
Allard Buijze

  • Constructor Details

    • AccessSerializingRepository

      public AccessSerializingRepository(Repository.LifecycleManagement<ID,E> delegate)
      Initialize the repository to serialize access to given delegate.
      Parameters:
      delegate - The repository implementation to delegate loading of the entities to

  • Method Details

    • attach

      public ManagedEntity<ID,E> attach(@Nonnull ManagedEntity<ID,E> entity, @Nonnull ProcessingContext processingContext)
      Description copied from interface: Repository.LifecycleManagement
      Ensures that the given entity has its lifecycle managed in the given processingContext. This ensures that when the processingContext commits, any changes detected in the entity state are persisted in this repository's underlying storage, if present.

      If a managed entity for this identifier was already present in the ProcessingContext, the new instance will replace it.

      Repositories may wrap entities. In that case, the returned instance may not be exactly the same (`==` comparison) as the instance provided. It is always recommended to use the returned instance.

      Specified by:
      attach in interface Repository.LifecycleManagement<ID,E>
      Parameters:
      entity - The entity to have its lifecycle attached to the given processing context.
      processingContext - The processing context to link the lifecycle with.
      Returns:
      The instance of the entity whose lifecycle is managed by this repository.

    • entityType

      @Nonnull public Class<E> entityType()
      Description copied from interface: Repository
      The type of entity stored in this repository.
      Specified by:
      entityType in interface Repository<ID,E>
      Returns:
      The type of entity stored in this repository.

    • idType

      @Nonnull public Class<ID> idType()
      Description copied from interface: Repository
      The type of the identifier used to identify entities in this repository.
      Specified by:
      idType in interface Repository<ID,E>
      Returns:
      The type of the identifier used to identify entities in this repository.

    • load

      public CompletableFuture<ManagedEntity<ID,E>> load(@Nonnull ID identifier, @Nonnull ProcessingContext processingContext)
      Description copied from interface: Repository
      Load the entity with the given unique identifier. No version checks are done when loading an entity, meaning that concurrent access will not be checked for.
      Specified by:
      load in interface Repository<ID,E>
      Parameters:
      identifier - The identifier of the entity to load.
      processingContext - The processing context in which to manage the lifecycle of the entity.
      Returns:
      A CompletableFuture resolving to the ManagedEntity with the given identifier, or null if it can't be found.

    • loadOrCreate

      public CompletableFuture<ManagedEntity<ID,E>> loadOrCreate(@Nonnull ID identifier, @Nonnull ProcessingContext processingContext)
      Description copied from interface: Repository
      Loads an entity from the repository.
      Specified by:
      loadOrCreate in interface Repository<ID,E>
      Parameters:
      identifier - The identifier of the entity to load.
      processingContext - The processing context in which to manage the lifecycle of the entity.
      Returns:
      A CompletableFuture resolving to the ManagedEntity with the given identifier, or a newly constructed entity instance based on the factoryMethod.

    • persist

      public ManagedEntity<ID,E> persist(@Nonnull ID identifier, @Nonnull E entity, @Nonnull ProcessingContext processingContext)
      Description copied from interface: Repository
      Persists the given entity in this repository
      Specified by:
      persist in interface Repository<ID,E>
      Parameters:
      identifier - The identifier of the entity.
      entity - The current state of the entity to store.
      processingContext - The ProcessingContext in which the entity is active.
      Returns:
      a ManagedEntity wrapping the entity managed in the ProcessingContext.

    • 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.