Package org.hibernate.cache.spi.access

Interface CachedDomainDataAccess

All Known Subinterfaces:
CollectionDataAccess, EntityDataAccess, NaturalIdDataAccess
All Known Implementing Classes:
AbstractCachedDomainDataAccess, AbstractCollectionDataAccess, AbstractEntityDataAccess, AbstractNaturalIdDataAccess, AbstractReadWriteAccess, CollectionNonStrictReadWriteAccess, CollectionReadOnlyAccess, CollectionReadWriteAccess, CollectionTransactionAccess, EntityNonStrictReadWriteAccess, EntityReadOnlyAccess, EntityReadWriteAccess, EntityTransactionalAccess, NaturalIdNonStrictReadWriteAccess, NaturalIdReadOnlyAccess, NaturalIdReadWriteAccess, NaturalIdTransactionalAccess
public interface CachedDomainDataAccess
Base contract for accessing the underlying cached data for a particular Navigable of the user's domain model in a transactionally ACID manner.
API Note:
Note that the following methods are not considered "transactional" in this sense: contains(java.lang.Object), lockRegion(), unlockRegion(org.hibernate.cache.spi.access.SoftLock), evict(java.lang.Object), evictAll(). The semantics of these methods come from JPA's Cache contract.
Implementation Specification:
The "non-transactional" methods noted in the @apiNote should be implemented to ignore any locking. That is, when evict(java.lang.Object) is called, the item should be forcibly removed from the cache regardless of whether anything has locked it.

  • Method Details

    • getRegion

      DomainDataRegion getRegion()
      The region containing the data being accessed

    • getAccessType

      AccessType getAccessType()
      The type of access implemented

    • get

      Object get(SharedSessionContractImplementor session, Object key)
      Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache.
      Parameters:
      session - Current session.
      key - The key of the item to be retrieved.
      Returns:
      the cached data or null
      Throws:
      CacheException - Propagated from underlying cache provider

    • putFromLoad

      boolean putFromLoad(SharedSessionContractImplementor session, Object key, Object value, Object version)
      Attempt to cache an object, afterQuery loading from the database.
      Parameters:
      session - Current session.
      key - The item key
      value - The item
      version - the item version number
      Returns:
      true if the object was successfully cached
      Throws:
      CacheException - Propagated from underlying cache provider

    • putFromLoad

      boolean putFromLoad(SharedSessionContractImplementor session, Object key, Object value, Object version, boolean minimalPutOverride)
      Attempt to cache an object, afterQuery loading from the database, explicitly specifying the minimalPut behavior.
      Parameters:
      session - Current session.
      key - The item key
      value - The item
      version - the item version number
      minimalPutOverride - Explicit minimalPut flag
      Returns:
      true if the object was successfully cached
      Throws:
      CacheException - Propagated from underlying cache provider

    • lockItem

      SoftLock lockItem(SharedSessionContractImplementor session, Object key, Object version)
      We are going to attempt to update/delete the keyed object. This method is used by "asynchronous" concurrency strategies.

      The returned object must be passed back to unlockItem(org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object, org.hibernate.cache.spi.access.SoftLock), to release the lock. Concurrency strategies which do not support client-visible locks may silently return null.

      Parameters:
      session - Current session.
      key - The key of the item to lock
      version - The item's current version value
      Returns:
      A representation of our lock on the item; or null.
      Throws:
      CacheException - Propagated from underlying cache provider

    • unlockItem

      void unlockItem(SharedSessionContractImplementor session, Object key, SoftLock lock)
      Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion. This method is used by "asynchronous" concurrency strategies.
      Parameters:
      session - Current session.
      key - The item key
      lock - The lock previously obtained from lockItem(org.hibernate.engine.spi.SharedSessionContractImplementor, java.lang.Object, java.lang.Object)
      Throws:
      CacheException - Propagated from underlying cache provider

    • remove

      void remove(SharedSessionContractImplementor session, Object key)
      Called afterQuery an item has become stale (beforeQuery the transaction completes). This method is used by "synchronous" concurrency strategies.
      Parameters:
      session - Current session.
      key - The key of the item to remove
      Throws:
      CacheException - Propagated from underlying cache provider

    • removeAll

      void removeAll(SharedSessionContractImplementor session)
      Remove all data for this accessed type
      Throws:
      CacheException - Propagated from underlying cache provider

    • contains

      boolean contains(Object key)
      Determine whether this region contains data for the given key.

      The semantic here is whether the cache contains data visible for the current call context. This should be viewed as a "best effort", meaning blocking should be avoided if possible.

      Parameters:
      key - The cache key
      Returns:
      True if the underlying cache contains corresponding data; false otherwise.

    • lockRegion

      SoftLock lockRegion()
      Lock the entire region
      Returns:
      A representation of our lock on the item; or null.
      Throws:
      CacheException - Propagated from underlying cache provider

    • unlockRegion

      void unlockRegion(SoftLock lock)
      Called after we have finished the attempted invalidation of the entire region
      Parameters:
      lock - The lock previously obtained from lockRegion()
      Throws:
      CacheException - Propagated from underlying cache provider

    • evict

      void evict(Object key)
      Forcibly evict an item from the cache immediately without regard for transaction isolation and/or locking. This behavior is exactly Hibernate legacy behavior, but it is also required by JPA - so we cannot remove it.

      Used from JPA's Cache.evict(Class, Object), as well as the Hibernate extension Cache.evictEntityData(Class, Object) and Cache.evictEntityData(String, Object)

      Parameters:
      key - The key of the item to remove
      Throws:
      CacheException - Propagated from underlying cache provider

    • evictAll

      void evictAll()
      Forcibly evict all items from the cache immediately without regard for transaction isolation. This behavior is exactly Hibernate legacy behavior, but it is also required by JPA - so we cannot remove it.

      Used from our JPA impl of Cache.evictAll() as well as the Hibernate extensions Cache.evictEntityData(Class), Cache.evictEntityData(String) and Cache.evictEntityData()

      Throws:
      CacheException - Propagated from underlying cache provider