## org.hibernate.cache.ehcache.internal.strategy
Class TransactionalEhcacheEntityRegionAccessStrategy

    java.lang.Object
      org.hibernate.cache.ehcache.internal.strategy.TransactionalEhcacheEntityRegionAccessStrategy

All Implemented Interfaces:
  EntityRegionAccessStrategy, RegionAccessStrategy

    public class TransactionalEhcacheEntityRegionAccessStrategy

extends Object
implements EntityRegionAccessStrategy

JTA EntityRegionAccessStrategy.

Field Summary
`protected T` `region` The wrapped Hibernate cache region.
`protected Settings` `settings` The settings for this persistence unit.

Constructor Summary
`TransactionalEhcacheEntityRegionAccessStrategy(EhcacheEntityRegion region, net.sf.ehcache.Ehcache ehcache, Settings settings)` Construct a new entity region access strategy.

Method Summary
`boolean` `afterInsert(Object key, Object value, Object version)` Called after an item has been inserted (after the transaction completes), instead of calling release().
`boolean` `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` `evict(Object key)` Remove the given mapping without regard to transactional safety
`void` `evictAll()` Remove all mappings without regard to transactional safety
`Object` `get(Object key, long txTimestamp)` Attempt to retrieve an object from the cache.
`EntityRegion` `getRegion()` Get the wrapped entity cache region
`boolean` `insert(Object key, Object value, Object version)` Called after an item has been inserted (before the transaction completes), instead of calling evict().
`SoftLock` `lockItem(Object key, Object version)` We are going to attempt to update/delete the keyed object.
`SoftLock` `lockRegion()` Region locks are not supported.
`boolean` `putFromLoad(Object key, Object value, long txTimestamp, Object version)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`boolean` `putFromLoad(Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride)` This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.
`void` `remove(Object key)` A no-op since this is an asynchronous cache access strategy.
`void` `removeAll()` Called to evict data from the entire region
`void` `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` `unlockRegion(SoftLock lock)` Region locks are not supported - perform a cache clear as a precaution.
`boolean` `update(Object key, Object value, Object currentVersion, Object previousVersion)` Called after an item has been updated (before the transaction completes), instead of calling evict().

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.hibernate.cache.spi.access.RegionAccessStrategy
`evict, evictAll, lockRegion, putFromLoad, removeAll, unlockRegion`

Field Detail

### region

    protected final T extends EhcacheTransactionalDataRegion region

  The wrapped Hibernate cache region.

### settings

    protected final Settings settings

  The settings for this persistence unit.

Constructor Detail

### TransactionalEhcacheEntityRegionAccessStrategy

    public TransactionalEhcacheEntityRegionAccessStrategy(EhcacheEntityRegion region,
                                                          net.sf.ehcache.Ehcache ehcache,
                                                          Settings settings)

  Construct a new entity region access strategy.

  Parameters:
    `region` - the Hibernate region.
    `ehcache` - the cache.
    `settings` - the Hibernate settings.

Method Detail

### afterInsert

    public boolean afterInsert(Object key,
                               Object value,
                               Object version)

  Called after an item has been inserted (after the transaction completes), instead of calling release(). This method is used by "asynchronous" concurrency strategies.

  Specified by:
    `afterInsert` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `version` - The item's version value
  Returns:
    Were the contents of the cache actual changed by this operation?

### afterUpdate

    public boolean 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(). This method is used by "asynchronous" concurrency strategies.

  Specified by:
    `afterUpdate` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `currentVersion` - The item's current version value
    `previousVersion` - The item's previous version value
    `lock` - The lock previously obtained from `RegionAccessStrategy.lockItem(java.lang.Object, java.lang.Object)`
  Returns:
    Were the contents of the cache actual changed by this operation?

### get

    public Object get(Object key,
                      long txTimestamp)
               throws CacheException

  Attempt to retrieve an object from the cache. Mainly used in attempting to resolve entities/collections from the second level cache.

  Specified by:
    `get` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to be retrieved.
    `txTimestamp` - a timestamp prior to the transaction start time
  Returns:
    the cached object or `null`
  Throws:
    `CacheException` - Propogated from underlying `Region`

### getRegion

    public EntityRegion getRegion()

  Get the wrapped entity cache region

  Specified by:
    `getRegion` in interface `EntityRegionAccessStrategy`
  Returns:
    The underlying region

### insert

    public boolean insert(Object key,
                          Object value,
                          Object version)
                   throws CacheException

  Called after an item has been inserted (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

  Specified by:
    `insert` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `version` - The item's version value
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### lockItem

    public SoftLock lockItem(Object key,
                             Object version)
                      throws CacheException

  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 `RegionAccessStrategy.unlockItem(java.lang.Object, org.hibernate.cache.spi.access.SoftLock)`, to release the lock. Concurrency strategies which do not support client-visible locks may silently return null.

  Specified by:
    `lockItem` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to lock
    `version` - The item's current version value
  Returns:
    A representation of our lock on the item; or null.
  Throws:
    `CacheException` - Propogated from underlying `Region`

### putFromLoad

    public boolean putFromLoad(Object key,
                               Object value,
                               long txTimestamp,
                               Object version,
                               boolean minimalPutOverride)
                        throws CacheException

  This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.

  Specified by:
    `putFromLoad` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `txTimestamp` - a timestamp prior to the transaction start time
    `version` - the item version number
    `minimalPutOverride` - Explicit minimalPut flag
  Returns:
    `true` if the object was successfully cached
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object, boolean)`, `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object, boolean)`

### remove

    public void remove(Object key)
                throws CacheException

  A no-op since this is an asynchronous cache access strategy.

  Specified by:
    `remove` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The key of the item to remove
  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.remove(java.lang.Object)`, `RegionAccessStrategy.remove(java.lang.Object)`

### unlockItem

    public void unlockItem(Object key,
                           SoftLock lock)
                    throws CacheException

  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.

  Specified by:
    `unlockItem` in interface `RegionAccessStrategy`
  Parameters:
    `key` - The item key
    `lock` - The lock previously obtained from `RegionAccessStrategy.lockItem(java.lang.Object, java.lang.Object)`
  Throws:
    `CacheException` - Propogated from underlying `Region`

### update

    public boolean update(Object key,
                          Object value,
                          Object currentVersion,
                          Object previousVersion)
                   throws CacheException

  Called after an item has been updated (before the transaction completes), instead of calling evict(). This method is used by "synchronous" concurrency strategies.

  Specified by:
    `update` in interface `EntityRegionAccessStrategy`
  Parameters:
    `key` - The item key
    `value` - The item
    `currentVersion` - The item's current version value
    `previousVersion` - The item's previous version value
  Returns:
    Were the contents of the cache actual changed by this operation?
  Throws:
    `CacheException` - Propogated from underlying `Region`

### putFromLoad

    public final boolean putFromLoad(Object key,
                                     Object value,
                                     long txTimestamp,
                                     Object version)
                              throws CacheException

  This method is a placeholder for method signatures supplied by interfaces pulled in further down the class hierarchy.

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object)`, `RegionAccessStrategy.putFromLoad(java.lang.Object, java.lang.Object, long, java.lang.Object)`

### lockRegion

    public final SoftLock lockRegion()

  Region locks are not supported.

  Returns:
    `null`
  See Also:
    `RegionAccessStrategy.lockRegion()`, `RegionAccessStrategy.lockRegion()`

### unlockRegion

    public final void unlockRegion(SoftLock lock)
                            throws CacheException

  Region locks are not supported - perform a cache clear as a precaution.

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.unlockRegion(org.hibernate.cache.spi.access.SoftLock)`, `RegionAccessStrategy.unlockRegion(org.hibernate.cache.spi.access.SoftLock)`

### removeAll

    public final void removeAll()
                         throws CacheException

  Called to evict data from the entire region

  Throws:
    `CacheException` - Propogated from underlying `Region`
  See Also:
    `RegionAccessStrategy.removeAll()`, `RegionAccessStrategy.removeAll()`

### evict

    public final void evict(Object key)
                     throws CacheException

  Remove the given mapping without regard to transactional safety

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.evict(java.lang.Object)`, `RegionAccessStrategy.evict(java.lang.Object)`

### evictAll

    public final void evictAll()
                        throws CacheException

  Remove all mappings without regard to transactional safety

  Throws:
    `CacheException`
  See Also:
    `RegionAccessStrategy.evictAll()`, `RegionAccessStrategy.evictAll()`

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