org.hibernate.cache: public interface: CacheConcurrencyStrategy

org.hibernate.cache
public interface: CacheConcurrencyStrategy [javadoc | source]

All Known Implementing Classes:
NonstrictReadWriteCache, TransactionalCache, ReadOnlyCache, ReadWriteCache

Deprecated! As - of 3.3; see for details.

Implementors manage transactional access to cached data. Transactions pass in a timestamp indicating transaction start time. Two different implementation patterns are provided for.

A transaction-aware cache implementation might be wrapped by a "synchronous" concurrency strategy, where updates to the cache are written to the cache inside the transaction.
A non transaction-aware cache would be wrapped by an "asynchronous" concurrency strategy, where items are merely "soft locked" during the transaction and then updated during the "after transaction completion" phase; the soft lock is not an actual lock on the database row - only upon the cached representation of the item.

In terms of entity caches, the expected call sequences are:

DELETES : #lock -> #evict -> #release
UPDATES : #lock -> #update -> #afterUpdate
INSERTS : #insert -> #afterInsert

In terms of collection caches, all modification actions actually just invalidate the entry(s). The call sequence here is: #lock -> #evict -> #release

Note that, for an asynchronous cache, cache invalidation must be a two step process (lock->release, or lock-afterUpdate), since this is the only way to guarantee consistency with the database for a nontransactional cache implementation. For a synchronous cache, cache invalidation is a single step process (evict, or update). Hence, this interface defines a three step process, to cater for both models.

Note that query result caching does not go through a concurrency strategy; they are managed directly against the underlying cache regions .

Method from org.hibernate.cache.CacheConcurrencyStrategy Summary:
afterInsert, afterUpdate, clear, destroy, evict, get, getCache, getRegionName, insert, lock, put, release, remove, setCache, update

Method from org.hibernate.cache.CacheConcurrencyStrategy Detail:
public boolean afterInsert(Object key, Object value, Object version) throws CacheException Deprecated! Called after an item has been inserted (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.
public boolean afterUpdate(Object key, Object value, Object version, SoftLock lock) throws CacheException Deprecated! Called after an item has been updated (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.
public void clear() throws CacheException Deprecated! Evict all items from the cache immediately.
public void destroy() Deprecated! Clean up all resources.
public void evict(Object key) throws CacheException Deprecated! Called after an item has become stale (before the transaction completes). This method is used by "synchronous" concurrency strategies.
public Object get(Object key, long txTimestamp) throws CacheException Deprecated! Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache.
public Cache getCache() Deprecated! Get the wrapped cache implementation
public String getRegionName() Deprecated! Get the cache region name
public boolean insert(Object key, Object value, Object currentVersion) throws CacheException Deprecated! Called after an item has been inserted (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.
public SoftLock lock(Object key, Object version) throws CacheException Deprecated! 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 release(), to release the lock. Concurrency strategies which do not support client-visible locks may silently return null.
public boolean put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut) throws CacheException Deprecated! Attempt to cache an object, after loading from the database.
public void release(Object key, SoftLock lock) throws CacheException Deprecated! 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.
public void remove(Object key) throws CacheException Deprecated! Evict an item from the cache immediately (without regard for transaction isolation).
public void setCache(Cache cache) Deprecated! Set the underlying cache implementation.
public boolean update(Object key, Object value, Object currentVersion, Object previousVersion) throws CacheException Deprecated! Called after an item has been updated (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.