Package org.axonframework.modelling.repository

Class SimpleRepository<ID,E>

java.lang.Object
org.axonframework.modelling.repository.SimpleRepository<ID,E>
Type Parameters:
ID - The type of the identifier of the entity.
E - The type of the entity.
All Implemented Interfaces:
DescribableComponent, Repository<ID,E>, Repository.LifecycleManagement<ID,E>
public class SimpleRepository<ID,E> extends Object implements Repository.LifecycleManagement<ID,E>
Simple implementation of an Repository that can load and persist entities of a given type. When an entity is loaded, it is stored in the ProcessingContext to ensure that the same entity is returned when it is loaded again in the same context.

When an entity is successfully loaded, it's scheduled to automatically be persisted when the ProcessingContext is committed.

Both the load(Object, ProcessingContext) and loadOrCreate(Object, ProcessingContext) use the SimpleRepositoryEntityLoader to load the entity. If you wish to create an entity when it does not exist, you can return a value when you have found none.

Since:
5.0.0
Author:
Mitchell Herrijgers

  • Constructor Details

    • SimpleRepository

      public SimpleRepository(@Nonnull Class<ID> idType, @Nonnull Class<E> entityType, @Nonnull SimpleRepositoryEntityLoader<ID,E> loader, @Nonnull SimpleRepositoryEntityPersister<ID,E> persister)
      Constructs a new simple Repository for entities of type entityType with identifiers of type idType. The given loader is used to load entities and the given persister is used to persist entities.
      Parameters:
      idType - The type of the identifier of the entity.
      entityType - The type of the entity.
      loader - The component capable of loading entities.
      persister - The component capable of persisting entities.

  • Method Details

    • attach

      public ManagedEntity<ID,E> attach(@Nonnull ManagedEntity<ID,E> entity, @Nonnull ProcessingContext context)
      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.
      context - 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 id, @Nonnull ProcessingContext context)
      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:
      id - The identifier of the entity to load.
      context - 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 id, @Nonnull E entity, @Nonnull ProcessingContext context)
      Description copied from interface: Repository
      Persists the given entity in this repository
      Specified by:
      persist in interface Repository<ID,E>
      Parameters:
      id - The identifier of the entity.
      entity - The current state of the entity to store.
      context - 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.