Hibernate Core 3.6.10.Final · org.hibernate.cache.CacheConcurrencyStrategy

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 Summary

Modifier and Type	Method and Description
public boolean	afterInsert(Object key, Object value, Object version) Called after an item has been inserted (after the transaction completes), instead of calling release().
public boolean	afterUpdate(Object key, Object value, Object version, SoftLock lock) Called after an item has been updated (after the transaction completes), instead of calling release().
public void	clear() Evict all items from the cache immediately.
public void	destroy() Clean up all resources.
public void	evict(Object key) Called after an item has become stale (before the transaction completes).
public Object	Returns: the cached object or `null` get(Object key, long a timestamp prior to the transaction start time txTimestamp) Attempt to retrieve an object from the cache.
public Cache	getCache() Deprecated as a consequence of `Cache` being deprecated. Get the wrapped cache implementation
public String	getRegionName() Get the cache region name
public boolean	insert(Object key, Object value, Object currentVersion) Called after an item has been inserted (before the transaction completes), instead of calling evict().
public SoftLock	lock(Object key, Object version) We are going to attempt to update/delete the keyed object.
public boolean	Returns: `true` if the object was successfully cached put(Object key, Object value, long a timestamp prior to the transaction start time txTimestamp, Object the item version number version, Comparator<T> a comparator used to compare version numbers versionComparator, boolean indicates that the cache should avoid a put is the item is already cached minimalPut) Attempt to cache an object, after loading from the database.
public void	release(Object key, SoftLock lock) Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
public void	remove(Object key) Evict an item from the cache immediately (without regard for transaction isolation).
public void	setCache(Cache cache) Deprecated as a consequence of `Cache` being deprecated. Set the underlying cache implementation.
public boolean	update(Object key, Object value, Object currentVersion, Object previousVersion) Called after an item has been updated (before the transaction completes), instead of calling evict().

Method Detail

afterInsert	back to summary
public boolean afterInsert(Object key, Object value, Object version) throws CacheException Called after an item has been inserted (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

afterUpdate	back to summary
public boolean afterUpdate(Object key, Object value, Object version, SoftLock lock) throws CacheException Called after an item has been updated (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

clear	back to summary
public void clear() throws CacheException Evict all items from the cache immediately.

destroy	back to summary
public void destroy() Clean up all resources.

evict	back to summary
public void evict(Object key) throws CacheException Called after an item has become stale (before the transaction completes). This method is used by "synchronous" concurrency strategies.

get back to summary

get	back to summary
public Object get(Object key, long txTimestamp) throws CacheException Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache. Parameters txTimestamp:long a timestamp prior to the transaction start time Returns:Object the cached object or `null`

public Object get(Object key, long txTimestamp) throws CacheException

Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache.

Parameters

txTimestamp:long: a timestamp prior to the transaction start time

Returns:Object

the cached object or null

getCache	back to summary
public Cache getCache() Deprecated as a consequence of `Cache` being deprecated. See corresponding docs for further information. Get the wrapped cache implementation

getRegionName	back to summary
public String getRegionName() Get the cache region name

insert	back to summary
public boolean insert(Object key, Object value, Object currentVersion) throws CacheException Called after an item has been inserted (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

lock	back to summary
public SoftLock lock(Object key, Object version) throws CacheException 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.

lock

back to summary

public SoftLock lock(Object key, Object version) throws CacheException

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.

put back to summary

put	back to summary
public boolean put(Object key, Object value, long txTimestamp, Object version, Comparator<T> versionComparator, boolean minimalPut) throws CacheException Attempt to cache an object, after loading from the database. Parameters txTimestamp:long a timestamp prior to the transaction start time version:Object the item version number versionComparator:Comparator<T> a comparator used to compare version numbers minimalPut:boolean indicates that the cache should avoid a put is the item is already cached Returns:boolean `true` if the object was successfully cached

public boolean put(Object key, Object value, long txTimestamp, Object version, Comparator<T> versionComparator, boolean minimalPut) throws CacheException

Attempt to cache an object, after loading from the database.

Parameters

txTimestamp:long: a timestamp prior to the transaction start time
version:Object: the item version number
versionComparator:Comparator<T>: a comparator used to compare version numbers
minimalPut:boolean: indicates that the cache should avoid a put is the item is already cached

Returns:boolean

true if the object was successfully cached

release	back to summary
public void release(Object key, SoftLock lock) throws CacheException 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.

remove	back to summary
public void remove(Object key) throws CacheException Evict an item from the cache immediately (without regard for transaction isolation).

setCache	back to summary
public void setCache(Cache cache) Deprecated as a consequence of `Cache` being deprecated. See corresponding docs for further information. Set the underlying cache implementation.

update	back to summary
public boolean update(Object key, Object value, Object currentVersion, Object previousVersion) throws CacheException Called after an item has been updated (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

public Interface CacheConcurrencyStrategy

Method Summary

Method Detail