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/SPIs and implementations for the Hibernate second-level cache. 
org.hibernate.cache.access Defines contracts for transactional and concurrent access to cached entity and collection data. 
org.hibernate.cache.impl   
org.hibernate.cache.impl.bridge   
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 CacheConcurrencyStrategy.afterInsert(Object key, Object value, Object version)
          Deprecated. Called after an item has been inserted (after the transaction completes), instead of calling release().
 boolean NonstrictReadWriteCache.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 TransactionalCache.afterUpdate(Object key, Object value, Object version, SoftLock clientLock)
          Do nothing.
 boolean CacheConcurrencyStrategy.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().
 boolean NonstrictReadWriteCache.afterUpdate(Object key, Object value, Object version, SoftLock lock)
          Invalidate the item (again, for safety).
 boolean ReadWriteCache.afterUpdate(Object key, Object value, Object version, 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, SoftLock lock)
          Unsupported!
 EntityRegionAccessStrategy EntityRegion.buildAccessStrategy(AccessType accessType)
          Build an access strategy for the requested access type.
 CollectionRegionAccessStrategy CollectionRegion.buildAccessStrategy(AccessType accessType)
          Build an access strategy for the requested access type.
 Cache NoCacheProvider.buildCache(String regionName, Properties properties)
          Configure the cache
 Cache CacheProvider.buildCache(String regionName, Properties properties)
          Deprecated. Configure the cache
 Cache HashtableCacheProvider.buildCache(String regionName, Properties properties)
           
 CollectionRegion RegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)
          Build a cache region specialized for storing collection data.
 EntityRegion RegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)
          Build a cache region specialized for storing entity data.
 QueryResultsRegion RegionFactory.buildQueryResultsRegion(String regionName, Properties properties)
          Build a cache region specialized for storing query results
 TimestampsRegion RegionFactory.buildTimestampsRegion(String regionName, Properties properties)
          Build a cache region specialized for storing update-timestamps data.
 void QueryCache.clear()
           
 void UpdateTimestampsCache.clear()
           
 void Cache.clear()
          Deprecated. Clear the cache
 void TransactionalCache.clear()
           
 void CacheConcurrencyStrategy.clear()
          Deprecated. Evict all items from the cache immediately.
 void NonstrictReadWriteCache.clear()
           
 void ReadWriteCache.clear()
           
 void HashtableCache.clear()
           
 void ReadOnlyCache.clear()
           
 void StandardQueryCache.clear()
           
 void Region.destroy()
          The "end state" contract of the region's lifecycle.
 void Cache.destroy()
          Deprecated. Clean up
 void HashtableCache.destroy()
           
 void GeneralDataRegion.evict(Object key)
          Evict an item from the cache immediately (without regard for transaction isolation).
 void TransactionalCache.evict(Object key)
           
 void CacheConcurrencyStrategy.evict(Object key)
          Deprecated. Called after an item has become stale (before the transaction completes).
 void NonstrictReadWriteCache.evict(Object key)
          Invalidate the item
 void ReadWriteCache.evict(Object key)
          Do nothing.
 void ReadOnlyCache.evict(Object key)
          Do nothing.
 void GeneralDataRegion.evictAll()
          Evict all contents of this particular cache region (without regard for transaction isolation).
 Object GeneralDataRegion.get(Object key)
          Get an item from the cache.
 Object Cache.get(Object key)
          Deprecated. Get an item from the cache, nontransactionally
 Object HashtableCache.get(Object key)
           
 Object TransactionalCache.get(Object key, long txTimestamp)
           
 Object CacheConcurrencyStrategy.get(Object key, long txTimestamp)
          Deprecated. Attempt to retrieve an object from the cache.
 Object NonstrictReadWriteCache.get(Object key, long txTimestamp)
          Get the most recent version, if available.
 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)
           
 boolean TransactionalCache.insert(Object key, Object value, Object currentVersion)
           
 boolean CacheConcurrencyStrategy.insert(Object key, Object value, Object currentVersion)
          Deprecated. Called after an item has been inserted (before the transaction completes), instead of calling evict().
 void UpdateTimestampsCache.invalidate(Serializable[] spaces)
           
 void Cache.lock(Object key)
          Deprecated. If this is a clustered cache, lock the item
 void HashtableCache.lock(Object key)
           
 SoftLock TransactionalCache.lock(Object key, Object version)
          Do nothing, returning null.
 SoftLock CacheConcurrencyStrategy.lock(Object key, Object version)
          Deprecated. We are going to attempt to update/delete the keyed object.
 SoftLock NonstrictReadWriteCache.lock(Object key, Object version)
          Do nothing.
 SoftLock ReadWriteCache.lock(Object key, Object version)
          Stop any other transactions reading or writing this item to/from the cache.
 void UpdateTimestampsCache.preinvalidate(Serializable[] spaces)
           
 void GeneralDataRegion.put(Object key, Object value)
          Put an item into the cache.
 void Cache.put(Object key, Object value)
          Deprecated. Add an item to the cache, nontransactionally, with failfast semantics
 void HashtableCache.put(Object key, Object value)
           
 boolean TransactionalCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 boolean CacheConcurrencyStrategy.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Deprecated. Attempt to cache an object, after loading from the database.
 boolean NonstrictReadWriteCache.put(Object key, Object value, long txTimestamp, Object version, Comparator versionComparator, boolean minimalPut)
          Add an item to 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.
 boolean ReadOnlyCache.put(Object key, Object value, long timestamp, Object version, Comparator versionComparator, boolean minimalPut)
           
 Object Cache.read(Object key)
          Deprecated. Get an item from the cache
 Object HashtableCache.read(Object key)
           
 void TransactionalCache.release(Object key, SoftLock clientLock)
          Do nothing.
 void CacheConcurrencyStrategy.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 NonstrictReadWriteCache.release(Object key, SoftLock lock)
          Invalidate the item (again, for safety).
 void ReadWriteCache.release(Object key, SoftLock clientLock)
          Release the soft lock on the item.
 void Cache.remove(Object key)
          Deprecated. Remove an item from the cache
 void TransactionalCache.remove(Object key)
           
 void CacheConcurrencyStrategy.remove(Object key)
          Deprecated. Evict an item from the cache immediately (without regard for transaction isolation).
 void NonstrictReadWriteCache.remove(Object key)
           
 void ReadWriteCache.remove(Object key)
           
 void HashtableCache.remove(Object key)
           
 void ReadOnlyCache.remove(Object key)
           
 void NoCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void CacheProvider.start(Properties properties)
          Deprecated. 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 AbstractJndiBoundCacheProvider.start(Properties properties)
          Callback to perform any necessary initialization of the underlying cache implementation during SessionFactory construction.
 void RegionFactory.start(Settings settings, Properties properties)
          Lifecycle callback to perform any necessary initialization of the underlying cache implementation(s).
 void Cache.unlock(Object key)
          Deprecated. If this is a clustered cache, unlock the item
 void HashtableCache.unlock(Object key)
           
 void Cache.update(Object key, Object value)
          Deprecated. Add an item to the cache
 void HashtableCache.update(Object key, Object value)
           
 boolean TransactionalCache.update(Object key, Object value, Object currentVersion, Object previousVersion)
           
 boolean CacheConcurrencyStrategy.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().
 

Uses of CacheException in org.hibernate.cache.access
 

Methods in org.hibernate.cache.access that throw CacheException
 boolean EntityRegionAccessStrategy.afterInsert(Object key, Object value, Object version)
          Called after an item has been inserted (after the transaction completes), instead of calling release().
 boolean EntityRegionAccessStrategy.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)
          Called after an item has been updated (after the transaction completes), instead of calling release().
 void EntityRegionAccessStrategy.evict(Object key)
          Forcibly evict an item from the cache immediately without regard for transaction isolation.
 void CollectionRegionAccessStrategy.evict(Object key)
          Forcibly evict an item from the cache immediately without regard for transaction isolation.
 void EntityRegionAccessStrategy.evictAll()
          Forcibly evict all items from the cache immediately without regard for transaction isolation.
 void CollectionRegionAccessStrategy.evictAll()
          Forcibly evict all items from the cache immediately without regard for transaction isolation.
 Object EntityRegionAccessStrategy.get(Object key, long txTimestamp)
          Attempt to retrieve an object from the cache.
 Object CollectionRegionAccessStrategy.get(Object key, long txTimestamp)
          Attempt to retrieve an object from the cache.
 boolean EntityRegionAccessStrategy.insert(Object key, Object value, Object version)
          Called after an item has been inserted (before the transaction completes), instead of calling evict().
 SoftLock EntityRegionAccessStrategy.lockItem(Object key, Object version)
          We are going to attempt to update/delete the keyed object.
 SoftLock CollectionRegionAccessStrategy.lockItem(Object key, Object version)
          We are going to attempt to update/delete the keyed object.
 SoftLock EntityRegionAccessStrategy.lockRegion()
          Lock the entire region
 SoftLock CollectionRegionAccessStrategy.lockRegion()
          Lock the entire region
 boolean EntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)
          Attempt to cache an object, after loading from the database.
 boolean CollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version)
          Attempt to cache an object, after loading from the database.
 boolean EntityRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)
          Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
 boolean CollectionRegionAccessStrategy.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)
          Attempt to cache an object, after loading from the database, explicitly specifying the minimalPut behavior.
 void EntityRegionAccessStrategy.remove(Object key)
          Called after an item has become stale (before the transaction completes).
 void CollectionRegionAccessStrategy.remove(Object key)
          Called after an item has become stale (before the transaction completes).
 void EntityRegionAccessStrategy.removeAll()
          Called to evict data from the entire region
 void CollectionRegionAccessStrategy.removeAll()
          Called to evict data from the entire region
 void EntityRegionAccessStrategy.unlockItem(Object key, SoftLock lock)
          Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
 void CollectionRegionAccessStrategy.unlockItem(Object key, SoftLock lock)
          Called when we have finished the attempted update/delete (which may or may not have been successful), after transaction completion.
 void EntityRegionAccessStrategy.unlockRegion(SoftLock lock)
          Called after we have finished the attempted invalidation of the entire region
 void CollectionRegionAccessStrategy.unlockRegion(SoftLock lock)
          Called after we have finished the attempted invalidation of the entire region
 boolean EntityRegionAccessStrategy.update(Object key, Object value, Object currentVersion, Object previousVersion)
          Called after an item has been updated (before the transaction completes), instead of calling evict().
 

Uses of CacheException in org.hibernate.cache.impl
 

Methods in org.hibernate.cache.impl that throw CacheException
 CollectionRegion NoCachingRegionFactory.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)
           
 EntityRegion NoCachingRegionFactory.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)
           
 QueryResultsRegion NoCachingRegionFactory.buildQueryResultsRegion(String regionName, Properties properties)
           
 TimestampsRegion NoCachingRegionFactory.buildTimestampsRegion(String regionName, Properties properties)
           
 void NoCachingRegionFactory.start(Settings settings, Properties properties)
           
 

Uses of CacheException in org.hibernate.cache.impl.bridge
 

Methods in org.hibernate.cache.impl.bridge that throw CacheException
 boolean EntityAccessStrategyAdapter.afterInsert(Object key, Object value, Object version)
           
 boolean EntityAccessStrategyAdapter.afterUpdate(Object key, Object value, Object currentVersion, Object previousVersion, SoftLock lock)
           
 EntityRegionAccessStrategy EntityRegionAdapter.buildAccessStrategy(AccessType accessType)
           
 CollectionRegionAccessStrategy CollectionRegionAdapter.buildAccessStrategy(AccessType accessType)
           
 CollectionRegion RegionFactoryCacheProviderBridge.buildCollectionRegion(String regionName, Properties properties, CacheDataDescription metadata)
           
 EntityRegion RegionFactoryCacheProviderBridge.buildEntityRegion(String regionName, Properties properties, CacheDataDescription metadata)
           
 QueryResultsRegion RegionFactoryCacheProviderBridge.buildQueryResultsRegion(String regionName, Properties properties)
           
 TimestampsRegion RegionFactoryCacheProviderBridge.buildTimestampsRegion(String regionName, Properties properties)
           
 void BaseRegionAdapter.clear()
           
 void BaseRegionAdapter.destroy()
           
 void CollectionAccessStrategyAdapter.evict(Object key)
           
 void EntityAccessStrategyAdapter.evict(Object key)
           
 void BaseGeneralDataRegionAdapter.evict(Object key)
           
 void CollectionAccessStrategyAdapter.evictAll()
           
 void EntityAccessStrategyAdapter.evictAll()
           
 void BaseGeneralDataRegionAdapter.evictAll()
           
 Object BaseGeneralDataRegionAdapter.get(Object key)
           
 Object CollectionAccessStrategyAdapter.get(Object key, long txTimestamp)
           
 Object EntityAccessStrategyAdapter.get(Object key, long txTimestamp)
           
 boolean EntityAccessStrategyAdapter.insert(Object key, Object value, Object version)
           
 SoftLock CollectionAccessStrategyAdapter.lockItem(Object key, Object version)
           
 SoftLock EntityAccessStrategyAdapter.lockItem(Object key, Object version)
           
 SoftLock CollectionAccessStrategyAdapter.lockRegion()
           
 SoftLock EntityAccessStrategyAdapter.lockRegion()
           
 void BaseGeneralDataRegionAdapter.put(Object key, Object value)
           
 boolean CollectionAccessStrategyAdapter.putFromLoad(Object key, Object value, long txTimestamp, Object version)
           
 boolean EntityAccessStrategyAdapter.putFromLoad(Object key, Object value, long txTimestamp, Object version)
           
 boolean CollectionAccessStrategyAdapter.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)
           
 boolean EntityAccessStrategyAdapter.putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)
           
 void CollectionAccessStrategyAdapter.remove(Object key)
           
 void EntityAccessStrategyAdapter.remove(Object key)
           
 void CollectionAccessStrategyAdapter.removeAll()
           
 void EntityAccessStrategyAdapter.removeAll()
           
 void RegionFactoryCacheProviderBridge.start(Settings settings, Properties properties)
           
 void CollectionAccessStrategyAdapter.unlockItem(Object key, SoftLock lock)
           
 void EntityAccessStrategyAdapter.unlockItem(Object key, SoftLock lock)
           
 void CollectionAccessStrategyAdapter.unlockRegion(SoftLock lock)
           
 void EntityAccessStrategyAdapter.unlockRegion(SoftLock lock)
           
 boolean EntityAccessStrategyAdapter.update(Object key, Object value, Object currentVersion, Object previousVersion)
           
 

Uses of CacheException in org.hibernate.persister.collection
 

Constructors in org.hibernate.persister.collection that throw CacheException
AbstractCollectionPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
BasicCollectionPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
OneToManyPersister(Collection collection, CollectionRegionAccessStrategy cacheAccessStrategy, Configuration cfg, SessionFactoryImplementor factory)
           
 



Copyright © 2011 Hibernate.org. All Rights Reserved.