Uses of Class
org.hibernate.cache.CacheException

Packages that use CacheException

org.hibernate.action	This package defines "actions" that are scheduled for asycnchronous execution by the event listeners.
org.hibernate.cache	This package defines APIs and implementations for the second-level cache and query cache.
org.hibernate.persister.collection	This package abstracts the persistence mechanism for collections.

Uses of CacheException in org.hibernate.action

Methods in org.hibernate.action that throw CacheException

void	EntityUpdateAction.afterTransactionCompletion(boolean success)
void	CollectionAction.afterTransactionCompletion(boolean success)
void	CollectionAction.beforeExecutions()
protected void	CollectionAction.evict()

Constructors in org.hibernate.action that throw CacheException

CollectionAction(CollectionPersister persister, PersistentCollection collection, Serializable key, SessionImplementor session)

CollectionRecreateAction(PersistentCollection collection, CollectionPersister persister, Serializable id, SessionImplementor session)

CollectionRemoveAction(Object affectedOwner, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)
Removes a persistent collection from a specified owner.

CollectionRemoveAction(PersistentCollection collection, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)
Removes a persistent collection from its loaded owner.

CollectionUpdateAction(PersistentCollection collection, CollectionPersister persister, Serializable id, boolean emptySnapshot, SessionImplementor session)

Uses of CacheException in org.hibernate.cache

Subclasses of CacheException in org.hibernate.cache

class

NoCachingEnabledException Implementation of NoCachingEnabledException.

Methods in org.hibernate.cache that throw CacheException

boolean	TransactionalCache.afterInsert(Object key, Object value, Object version) Do nothing.
boolean	ReadWriteCache.afterInsert(Object key, Object value, Object version) Add the new item to the cache, checking that no other transaction has accessed the item.
boolean	ReadOnlyCache.afterInsert(Object key, Object value, Object version) Do nothing.
boolean	NonstrictReadWriteCache.afterInsert(Object key, Object value, Object version) Do nothing.
boolean	CacheConcurrencyStrategy.afterInsert(Object key, Object value, Object version) Called after an item has been inserted (after the transaction completes), instead of calling release().
boolean	TransactionalCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock) Do nothing.
boolean	ReadWriteCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock) Re-cache the updated state, if and only if there there are no other concurrent soft locks.
boolean	ReadOnlyCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock) Unsupported!
boolean	NonstrictReadWriteCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock) Invalidate the item (again, for safety).
boolean	CacheConcurrencyStrategy.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock) Called after an item has been updated (after the transaction completes), instead of calling release().
Cache	TreeCacheProvider.buildCache(String regionName, Properties properties) Construct and configure the Cache representation of a named cache region.
Cache	SwarmCacheProvider.buildCache(String regionName, Properties properties)
Cache	OSCacheProvider.buildCache(String region, Properties properties) Builds a new Cache instance, and gets it's properties from the OSCache Config which reads the properties file (oscache.properties) from the classpath.
Cache	OptimisticTreeCacheProvider.buildCache(String regionName, Properties properties) Construct and configure the Cache representation of a named cache region.
Cache	NoCacheProvider.buildCache(String regionName, Properties properties) Configure the cache
Cache	JndiBoundTreeCacheProvider.buildCache(String regionName, Properties properties) Construct a Cache representing the "region" within in the underlying cache provider.
Cache	HashtableCacheProvider.buildCache(String regionName, Properties properties)
Cache	EhCacheProvider.buildCache(String name, Properties properties) Builds a Cache.
Cache	CacheProvider.buildCache(String regionName, Properties properties) Configure the cache
void	UpdateTimestampsCache.clear()
void	TreeCache.clear()
void	TransactionalCache.clear()
void	SwarmCache.clear() Clear the cache
void	StandardQueryCache.clear()
void	ReadWriteCache.clear()
void	ReadOnlyCache.clear()
void	QueryCache.clear()
void	OSCache.clear()
void	OptimisticTreeCache.clear()
void	NonstrictReadWriteCache.clear()
void	HashtableCache.clear()
void	EhCache.clear() Remove all elements in the cache, but leave the cache in a useable state.
void	CacheConcurrencyStrategy.clear() Evict all items from the cache immediately.
void	Cache.clear() Clear the cache
void	TreeCache.destroy()
void	SwarmCache.destroy() Clean up
void	OSCache.destroy()
void	OptimisticTreeCache.destroy()
void	HashtableCache.destroy()
void	EhCache.destroy() Remove the cache and make it unuseable.
void	Cache.destroy() Clean up
void	TransactionalCache.evict(Object key)
void	ReadWriteCache.evict(Object key) Do nothing.
void	ReadOnlyCache.evict(Object key) Do nothing.
void	NonstrictReadWriteCache.evict(Object key) Invalidate the item
void	CacheConcurrencyStrategy.evict(Object key) Called after an item has become stale (before the transaction completes).
Object	TreeCache.get(Object key)
Object	SwarmCache.get(Object key) Get an item from the cache
Object	OSCache.get(Object key)
Object	OptimisticTreeCache.get(Object key)
Object	HashtableCache.get(Object key)
Object	EhCache.get(Object key) Gets a value of an element which matches the given key.
Object	Cache.get(Object key) Get an item from the cache, nontransactionally
Object	TransactionalCache.get(Object key, long txTimestamp)
Object	ReadWriteCache.get(Object key, long txTimestamp) Do not return an item whose timestamp is later than the current transaction timestamp.
Object	ReadOnlyCache.get(Object key, long timestamp)
Object	NonstrictReadWriteCache.get(Object key, long txTimestamp) Get the most recent version, if available.
Object	CacheConcurrencyStrategy.get(Object key, long txTimestamp) Attempt to retrieve an object from the cache.
boolean	TransactionalCache.insert(Object key, Object value, Object currentVersion)
boolean	CacheConcurrencyStrategy.insert(Object key, Object value, Object currentVersion) Called after an item has been inserted (before the transaction completes), instead of calling evict().
void	UpdateTimestampsCache.invalidate(Serializable[] spaces)
void	TreeCache.lock(Object key)
void	SwarmCache.lock(Object key) If this is a clustered cache, lock the item
void	OSCache.lock(Object key)
void	OptimisticTreeCache.lock(Object key)
void	HashtableCache.lock(Object key)
void	EhCache.lock(Object key) Calls to this method should perform there own synchronization.
void	Cache.lock(Object key) If this is a clustered cache, lock the item
CacheConcurrencyStrategy.SoftLock	TransactionalCache.lock(Object key, Object version) Do nothing, returning null.
CacheConcurrencyStrategy.SoftLock	ReadWriteCache.lock(Object key, Object version) Stop any other transactions reading or writing this item to/from the cache.
CacheConcurrencyStrategy.SoftLock	NonstrictReadWriteCache.lock(Object key, Object version) Do nothing.
CacheConcurrencyStrategy.SoftLock	CacheConcurrencyStrategy.lock(Object key, Object version) We are going to attempt to update/delete the keyed object.
void	UpdateTimestampsCache.preinvalidate(Serializable[] spaces)
void	JndiBoundTreeCacheProvider.prepare(Properties properties)
void	TreeCache.put(Object key, Object value)
void	SwarmCache.put(Object key, Object value) Add an item to the cache
void	OSCache.put(Object key, Object value)
void	OptimisticTreeCache.put(Object key, Object value)
void	HashtableCache.put(Object key, Object value)
void	EhCache.put(Object key, Object value) Puts an object into the cache.
void	Cache.put(Object key, Object value) Add an item to the cache, nontransactionally, with failfast semantics
boolean	TransactionalCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
boolean	ReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut) Do not add an item to the cache unless the current transaction timestamp is later than the timestamp at which the item was invalidated.
boolean	ReadOnlyCache.put(Object key, Object value, long timestamp, Object version, Comparator versionComparator, boolean minimalPut)
boolean	NonstrictReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut) Add an item to the cache.
boolean	CacheConcurrencyStrategy.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut) Attempt to cache an object, after loading from the database.
Object	TreeCache.read(Object key)
Object	SwarmCache.read(Object key)
Object	OSCache.read(Object key)
Object	OptimisticTreeCache.read(Object key)
Object	HashtableCache.read(Object key)
Object	EhCache.read(Object key)
Object	Cache.read(Object key) Get an item from the cache
void	TransactionalCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock) Do nothing.
void	ReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock) Release the soft lock on the item.
void	NonstrictReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock lock) Invalidate the item (again, for safety).
void	CacheConcurrencyStrategy.release(Object key, CacheConcurrencyStrategy.SoftLock lock) Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
void	TreeCache.remove(Object key)
void	TransactionalCache.remove(Object key)
void	SwarmCache.remove(Object key) Remove an item from the cache
void	ReadWriteCache.remove(Object key)
void	ReadOnlyCache.remove(Object key)
void	OSCache.remove(Object key)
void	OptimisticTreeCache.remove(Object key)
void	NonstrictReadWriteCache.remove(Object key)
void	HashtableCache.remove(Object key)
void	EhCache.remove(Object key) Removes the element which matches the key.
void	CacheConcurrencyStrategy.remove(Object key) Evict an item from the cache immediately (without regard for transaction isolation).
void	Cache.remove(Object key) Remove an item from the cache
void	SwarmCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	OSCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	NoCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	HashtableCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	EhCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	CacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	AbstractJndiBoundCacheProvider.start(Properties properties) Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
void	TreeCache.unlock(Object key)
void	SwarmCache.unlock(Object key) If this is a clustered cache, unlock the item
void	OSCache.unlock(Object key)
void	OptimisticTreeCache.unlock(Object key)
void	HashtableCache.unlock(Object key)
void	EhCache.unlock(Object key) Calls to this method should perform there own synchronization.
void	Cache.unlock(Object key) If this is a clustered cache, unlock the item
void	TreeCache.update(Object key, Object value)
void	SwarmCache.update(Object key, Object value) Add an item to the cache
void	OSCache.update(Object key, Object value)
void	OptimisticTreeCache.update(Object key, Object value)
void	HashtableCache.update(Object key, Object value)
void	EhCache.update(Object key, Object value) Puts an object into the cache.
void	Cache.update(Object key, Object value) Add an item to the cache
boolean	TransactionalCache.update(Object key, Object value, Object currentVersion, Object previousVersion)
boolean	CacheConcurrencyStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion) Called after an item has been updated (before the transaction completes), instead of calling evict().

Constructors in org.hibernate.cache that throw CacheException

OptimisticTreeCache(org.jboss.cache.TreeCache cache, String regionName)

TreeCache(org.jboss.cache.TreeCache cache, String regionName, TransactionManager transactionManager)

Uses of CacheException in org.hibernate.persister.collection

Constructors in org.hibernate.persister.collection that throw CacheException

AbstractCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)

BasicCollectionPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)

OneToManyPersister(Collection collection, CacheConcurrencyStrategy cache, Configuration cfg, SessionFactoryImplementor factory)