Uses of Class net.sf.hibernate.cache.CacheException (Hibernate API Documentation) - Hibernate 2.1.8 正式版 API 英文文档

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
net.sf.hibernate.cache.CacheException

Packages that use CacheException
net.sf.hibernate.cache
net.sf.hibernate.collection

Uses of CacheException in net.sf.hibernate.cache

Methods in net.sf.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.

void TreeCacheProvider.start(Properties properties)
          Prepare the underlying JBossCache TreeCache instance.

Object TreeCache.get(Object key)


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)


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

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

void TransactionalCache.update(Object key, Object value)


void TransactionalCache.insert(Object key, Object value)


void TransactionalCache.evict(Object key)


void TransactionalCache.remove(Object key)


void TransactionalCache.clear()


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

void 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

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


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

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

void ReadWriteCache.insert(Object key, Object value)
          Do nothing.

void ReadWriteCache.update(Object key, Object value)
          Do nothing.

Object ReadOnlyCache.get(Object key, long timestamp)


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


void ReadOnlyCache.clear()


void ReadOnlyCache.remove(Object key)


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

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

void ReadOnlyCache.evict(Object key)
          Do nothing.

void ReadOnlyCache.insert(Object key, Object value)
          Do nothing.

void ReadOnlyCache.update(Object key, Object value)
          Unsupported!

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)


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)


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)
          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.update(Object key, Object value)
          Invalidate the item

void NonstrictReadWriteCache.insert(Object key, Object value)
          Do nothing.

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

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

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

Cache JCSCacheProvider.buildCache(String regionName, Properties properties)
          Deprecated.

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

void JCSCache.put(Object key, Object value)
          Deprecated.

void JCSCache.remove(Object key)
          Deprecated.

void JCSCache.clear()
          Deprecated.

void JCSCache.destroy()
          Deprecated.

void JCSCache.lock(Object key)
          Deprecated.

void JCSCache.unlock(Object key)
          Deprecated.

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.get(Object key)


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.

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

void CacheConcurrencyStrategy.update(Object key, Object value)
          Called after an item has been updated (before the transaction completes), instead of calling evict().

void CacheConcurrencyStrategy.insert(Object key, Object value)
          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.

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

void 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.get(Object key)
          Get an item from the cache

void Cache.put(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

Constructors in net.sf.hibernate.cache that throw CacheException

JCSCache(String regionName, Properties properties)
Deprecated.

Uses of CacheException in net.sf.hibernate.collection

Constructors in net.sf.hibernate.collection that throw CacheException

OneToManyPersister(Collection collection, Configuration cfg, SessionFactoryImplementor factory)


BasicCollectionPersister(Collection collection, Configuration cfg, SessionFactoryImplementor factory)


AbstractCollectionPersister(Collection collection, Configuration cfg, SessionFactoryImplementor factory)