org.hibernate.cache
Interface CacheConcurrencyStrategy

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

Deprecated. As of 3.3; see for details.

public interface CacheConcurrencyStrategy

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

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

In terms of collection caches, all modification actions actually just invalidate the entry(s). The call sequence here is: lock(java.lang.Object, java.lang.Object) -> evict(java.lang.Object) -> release(java.lang.Object, org.hibernate.cache.access.SoftLock)

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
 boolean afterInsert(Object key, Object value, Object version)
          Deprecated. Called after an item has been inserted (after the transaction completes), instead of calling release().
 boolean afterUpdate(Object key, Object value, Object version, SoftLock lock)
          Deprecated. Called after an item has been updated (after the transaction completes), instead of calling release().
 void clear()
          Deprecated. Evict all items from the cache immediately.
 void destroy()
          Deprecated. Clean up all resources.
 void evict(Object key)
          Deprecated. Called after an item has become stale (before the transaction completes).
 Object get(Object key, long txTimestamp)
          Deprecated. Attempt to retrieve an object from the cache.
 Cache getCache()
          Deprecated. Get the wrapped cache implementation
 String getRegionName()
          Deprecated. Get the cache region name
 boolean insert(Object key, Object value, Object currentVersion)
          Deprecated. Called after an item has been inserted (before the transaction completes), instead of calling evict().
 SoftLock lock(Object key, Object version)
          Deprecated. We are going to attempt to update/delete the keyed object.
 boolean put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Deprecated. Attempt to cache an object, after loading from the database.
 void release(Object key, SoftLock lock)
          Deprecated. Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
 void remove(Object key)
          Deprecated. Evict an item from the cache immediately (without regard for transaction isolation).
 void setCache(Cache cache)
          Deprecated. Set the underlying cache implementation.
 boolean update(Object key, Object value, Object currentVersion, Object previousVersion)
          Deprecated. Called after an item has been updated (before the transaction completes), instead of calling evict().
 

Method Detail

get

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.

Parameters:
key -
txTimestamp - a timestamp prior to the transaction start time
Returns:
the cached object or null
Throws:
CacheException

put

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.

Parameters:
key -
value -
txTimestamp - a timestamp prior to the transaction start time
version - the item version number
versionComparator - a comparator used to compare version numbers
minimalPut - indicates that the cache should avoid a put is the item is already cached
Returns:
true if the object was successfully cached
Throws:
CacheException

lock

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.

Parameters:
key -
version -
Throws:
CacheException

evict

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.

Throws:
CacheException

update

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.

Throws:
CacheException

insert

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.

Throws:
CacheException

release

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.

Parameters:
key -
Throws:
CacheException

afterUpdate

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.

Throws:
CacheException

afterInsert

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.

Throws:
CacheException

remove

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

Parameters:
key -
Throws:
CacheException

clear

void clear()
           throws CacheException
Deprecated. 
Evict all items from the cache immediately.

Throws:
CacheException

destroy

void destroy()
Deprecated. 
Clean up all resources.


setCache

void setCache(Cache cache)
Deprecated. 
Set the underlying cache implementation.

Parameters:
cache -

getRegionName

String getRegionName()
Deprecated. 
Get the cache region name


getCache

Cache getCache()
Deprecated. 
Get the wrapped cache implementation



Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.