Uses of Class org.hibernate.cache.CacheException (Hibernate API Documentation) - Hibernate 3.2.3 正式版 API 英文文档

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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

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


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


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


CollectionAction(CollectionPersister persister, PersistentCollection collection, Serializable key, 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

void UpdateTimestampsCache.clear()


void UpdateTimestampsCache.preinvalidate(Serializable[] spaces)


void UpdateTimestampsCache.invalidate(Serializable[] spaces)


Cache TreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.

Object TreeCache.get(Object key)


Object TreeCache.read(Object key)


void TreeCache.update(Object key, Object value)


void TreeCache.put(Object key, Object value)


void TreeCache.remove(Object key)


void TreeCache.clear()


void TreeCache.destroy()


void TreeCache.lock(Object key)


void TreeCache.unlock(Object key)


Object TransactionalCache.get(Object key, long txTimestamp)


boolean TransactionalCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)


CacheConcurrencyStrategy.SoftLock TransactionalCache.lock(Object key, Object version)
          Do nothing, returning null.

void TransactionalCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.

boolean TransactionalCache.update(Object key, Object value, Object currentVersion, Object previousVersion)


boolean TransactionalCache.insert(Object key, Object value, Object currentVersion)


void TransactionalCache.evict(Object key)


void TransactionalCache.remove(Object key)


void TransactionalCache.clear()


boolean TransactionalCache.afterInsert(Object key, Object value, Object version)
          Do nothing.

boolean TransactionalCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock clientLock)
          Do nothing.

Cache SwarmCacheProvider.buildCache(String regionName, Properties properties)


void SwarmCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Object SwarmCache.get(Object key)
          Get an item from the cache

Object SwarmCache.read(Object key)


void SwarmCache.update(Object key, Object value)
          Add an item to the cache

void SwarmCache.put(Object key, Object value)
          Add an item to the cache

void SwarmCache.remove(Object key)
          Remove an item from the cache

void SwarmCache.clear()
          Clear the cache

void SwarmCache.destroy()
          Clean up

void SwarmCache.lock(Object key)
          If this is a clustered cache, lock the item

void SwarmCache.unlock(Object key)
          If this is a clustered cache, unlock the item

void StandardQueryCache.clear()


Object ReadWriteCache.get(Object key, long txTimestamp)
          Do not return an item whose timestamp is later than the current transaction timestamp.

CacheConcurrencyStrategy.SoftLock ReadWriteCache.lock(Object key, Object version)
          Stop any other transactions reading or writing this item to/from the cache.

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.

void ReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock clientLock)
          Release the soft lock on the item.

void ReadWriteCache.clear()


void ReadWriteCache.remove(Object key)


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 ReadWriteCache.afterInsert(Object key, Object value, Object version)
          Add the new item to the cache, checking that no other transaction has accessed the item.

void ReadWriteCache.evict(Object key)
          Do nothing.

Object ReadOnlyCache.get(Object key, long timestamp)


boolean ReadOnlyCache.put(Object key, Object value, long timestamp, Object version, Comparator versionComparator, boolean minimalPut)


void ReadOnlyCache.clear()


void ReadOnlyCache.remove(Object key)


boolean ReadOnlyCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Unsupported!

boolean ReadOnlyCache.afterInsert(Object key, Object value, Object version)
          Do nothing.

void ReadOnlyCache.evict(Object key)
          Do nothing.

void QueryCache.clear()


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.

void OSCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Object OSCache.get(Object key)


Object OSCache.read(Object key)


void OSCache.update(Object key, Object value)


void OSCache.put(Object key, Object value)


void OSCache.remove(Object key)


void OSCache.clear()


void OSCache.destroy()


void OSCache.lock(Object key)


void OSCache.unlock(Object key)


Cache OptimisticTreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct and configure the Cache representation of a named cache region.

Object OptimisticTreeCache.get(Object key)


Object OptimisticTreeCache.read(Object key)


void OptimisticTreeCache.update(Object key, Object value)


void OptimisticTreeCache.put(Object key, Object value)


void OptimisticTreeCache.remove(Object key)


void OptimisticTreeCache.clear()


void OptimisticTreeCache.destroy()


void OptimisticTreeCache.lock(Object key)


void OptimisticTreeCache.unlock(Object key)


Object NonstrictReadWriteCache.get(Object key, long txTimestamp)
          Get the most recent version, if available.

boolean NonstrictReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Add an item to the cache.

CacheConcurrencyStrategy.SoftLock NonstrictReadWriteCache.lock(Object key, Object version)
          Do nothing.

void NonstrictReadWriteCache.remove(Object key)


void NonstrictReadWriteCache.clear()


void NonstrictReadWriteCache.evict(Object key)
          Invalidate the item

void NonstrictReadWriteCache.release(Object key, CacheConcurrencyStrategy.SoftLock lock)
          Invalidate the item (again, for safety).

boolean NonstrictReadWriteCache.afterUpdate(Object key, Object value, Object version, CacheConcurrencyStrategy.SoftLock lock)
          Invalidate the item (again, for safety).

boolean NonstrictReadWriteCache.afterInsert(Object key, Object value, Object version)
          Do nothing.

Cache NoCacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache

void NoCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Cache JndiBoundTreeCacheProvider.buildCache(String regionName, Properties properties)
          Construct a Cache representing the "region" within in the underlying cache provider.

void JndiBoundTreeCacheProvider.prepare(Properties properties)


Cache HashtableCacheProvider.buildCache(String regionName, Properties properties)


void HashtableCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Object HashtableCache.read(Object key)


Object HashtableCache.get(Object key)


void HashtableCache.update(Object key, Object value)


void HashtableCache.put(Object key, Object value)


void HashtableCache.remove(Object key)


void HashtableCache.clear()


void HashtableCache.destroy()


void HashtableCache.lock(Object key)


void HashtableCache.unlock(Object key)


Cache EhCacheProvider.buildCache(String name, Properties properties)
          Builds a Cache.

void EhCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Object EhCache.get(Object key)
          Gets a value of an element which matches the given key.

Object EhCache.read(Object key)


void EhCache.update(Object key, Object value)
          Puts an object into the cache.

void EhCache.put(Object key, Object value)
          Puts an object into the cache.

void EhCache.remove(Object key)
          Removes the element which matches the key.

void EhCache.clear()
          Remove all elements in the cache, but leave the cache in a useable state.

void EhCache.destroy()
          Remove the cache and make it unuseable.

void EhCache.lock(Object key)
          Calls to this method should perform there own synchronization.

void EhCache.unlock(Object key)
          Calls to this method should perform there own synchronization.

Cache CacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache

void CacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Object CacheConcurrencyStrategy.get(Object key, long txTimestamp)
          Attempt to retrieve an object from 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.

CacheConcurrencyStrategy.SoftLock CacheConcurrencyStrategy.lock(Object key, Object version)
          We are going to attempt to update/delete the keyed object.

void CacheConcurrencyStrategy.evict(Object key)
          Called after an item has become stale (before the transaction completes).

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().

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 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.

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().

boolean CacheConcurrencyStrategy.afterInsert(Object key, Object value, Object version)
          Called after an item has been inserted (after the transaction completes), instead of calling release().

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

void CacheConcurrencyStrategy.clear()
          Evict all items from the cache immediately.

Object Cache.read(Object key)
          Get an item from the cache

Object Cache.get(Object key)
          Get an item from the cache, nontransactionally

void Cache.put(Object key, Object value)
          Add an item to the cache, nontransactionally, with failfast semantics

void Cache.update(Object key, Object value)
          Add an item to the cache

void Cache.remove(Object key)
          Remove an item from the cache

void Cache.clear()
          Clear the cache

void Cache.destroy()
          Clean up

void Cache.lock(Object key)
          If this is a clustered cache, lock the item

void Cache.unlock(Object key)
          If this is a clustered cache, unlock the item

void AbstractJndiBoundCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.

Constructors in org.hibernate.cache that throw CacheException

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

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

Uses of CacheException in org.hibernate.persister.collection

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

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


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


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