org.infinispan
Class AbstractDelegatingCache<K,V>

java.lang.Object
  org.infinispan.AbstractDelegatingCache<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, Cache<K,V>, Lifecycle, Listenable

Direct Known Subclasses:

AbstractDelegatingAdvancedCache

public abstract class AbstractDelegatingCache<K,V>
extends Object
implements Cache<K,V>

This is a convenient base class for implementing a cache delegate. The only constructor takes a Cache argument, to which each method call is delegated. One can extend this class and override the method sub-set it is interested in. There is also an similar implmentation for AdvancedCache: AbstractDelegatingAdvancedCache.

Author:

Mircea.Markus@jboss.com

See Also:

AbstractDelegatingAdvancedCache

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Map.Entry<K,V>

Constructor Summary

AbstractDelegatingCache(Cache<K,V> cache)

Method Summary

void	addListener(Object listener) Adds a listener to the component.
void	clear()
void	compact() Method that releases object references of cached objects held in the cache by serializing them to byte buffers.
boolean	containsKey(Object key)
boolean	containsValue(Object value)
void	endBatch(boolean successful)
Set<Map.Entry<K,V>>	entrySet()
void	evict(K key)
V	get(Object key)
AdvancedCache<K,V>	getAdvancedCache()
CacheManager	getCacheManager() Retrieves the cache manager responsible for creating this cache instance.
Configuration	getConfiguration()
Set<Object>	getListeners()
String	getName()
ComponentStatus	getStatus()
String	getVersion()
boolean	isEmpty()
Set<K>	keySet()
V	put(K key, V value)
V	put(K key, V value, long lifespan, TimeUnit unit) An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.
V	put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit) An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.
void	putAll(Map<? extends K,? extends V> t)
void	putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit unit) An overloaded form of Map.putAll(java.util.Map), which takes in lifespan parameters.
void	putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit) An overloaded form of Map.putAll(java.util.Map), which takes in lifespan parameters.
void	putForExternalRead(K key, V value) Under special operating behavior, associates the value with the specified key.
V	putIfAbsent(K key, V value)
V	putIfAbsent(K key, V value, long lifespan, TimeUnit unit) An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
V	putIfAbsent(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit) An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
V	remove(Object key)
boolean	remove(Object key, Object value)
void	removeListener(Object listener) Removes a listener from the component.
V	replace(K key, V value)
V	replace(K key, V value, long lifespan, TimeUnit unit) An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
V	replace(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit) An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
boolean	replace(K key, V oldValue, V newValue)
boolean	replace(K key, V oldValue, V value, long lifespan, TimeUnit unit) An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
boolean	replace(K key, V oldValue, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit) An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
int	size()
void	start()
boolean	startBatch()
void	stop()
Collection<V>	values()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Map

equals, hashCode

Constructor Detail

AbstractDelegatingCache

public AbstractDelegatingCache(Cache<K,V> cache)

Method Detail

putForExternalRead

public void putForExternalRead(K key,
                               V value)

Description copied from interface: Cache

Under special operating behavior, associates the value with the specified key.

• Only goes through if the key specified does not exist; no-op otherwise (similar to ConcurrentMap.putIfAbsent(Object, Object))
• Force asynchronous mode for replication to prevent any blocking.
• invalidation does not take place.
• 0ms lock timeout to prevent any blocking here either. If the lock is not acquired, this method is a no-op, and swallows the timeout exception.
• Ongoing transactions are suspended before this call, so failures here will not affect any ongoing transactions.
• Errors and exceptions are 'silent' - logged at a much lower level than normal, and this method does not throw exceptions

This method is for caching data that has an external representation in storage, where, concurrent modification and transactions are not a consideration, and failure to put the data in the cache should be treated as a 'suboptimal outcome' rather than a 'failing outcome'.

An example of when this method is useful is when data is read from, for example, a legacy datastore, and is cached before returning the data to the caller. Subsequent calls would prefer to get the data from the cache and if the data doesn't exist in the cache, fetch again from the legacy datastore.

See JBCACHE-848 for details around this feature.

Specified by:

putForExternalRead in interface Cache<K,V>

Parameters:

key - key with which the specified value is to be associated.

value - value to be associated with the specified key.

evict

public void evict(K key)

Specified by:

evict in interface Cache<K,V>

getConfiguration

public Configuration getConfiguration()

Specified by:

getConfiguration in interface Cache<K,V>

startBatch

public boolean startBatch()

Specified by:

startBatch in interface Cache<K,V>

Returns:

true if a batch was successfully started; false if one was available and already running.

endBatch

public void endBatch(boolean successful)

Specified by:

endBatch in interface Cache<K,V>

getName

public String getName()

Specified by:

getName in interface Cache<K,V>

getVersion

public String getVersion()

Specified by:

getVersion in interface Cache<K,V>

getCacheManager

public CacheManager getCacheManager()

Description copied from interface: Cache

Retrieves the cache manager responsible for creating this cache instance.

Specified by:

getCacheManager in interface Cache<K,V>

Returns:

a cache manager

put

public V put(K key,
             V value,
             long lifespan,
             TimeUnit unit)

Description copied from interface: Cache

An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.

Specified by:

put in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

unit - unit of measurement for the lifespan

Returns:

the value being replaced, or null if nothing is being replaced.

putIfAbsent

public V putIfAbsent(K key,
                     V value,
                     long lifespan,
                     TimeUnit unit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.

Specified by:

putIfAbsent in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

unit - unit of measurement for the lifespan

Returns:

the value being replaced, or null if nothing is being replaced.

putAll

public void putAll(Map<? extends K,? extends V> map,
                   long lifespan,
                   TimeUnit unit)

Description copied from interface: Cache

An overloaded form of Map.putAll(java.util.Map), which takes in lifespan parameters. Note that the lifespan is applied to all mappings in the map passed in.

Specified by:

putAll in interface Cache<K,V>

Parameters:

map - map containing mappings to enter

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

unit - unit of measurement for the lifespan

replace

public V replace(K key,
                 V value,
                 long lifespan,
                 TimeUnit unit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.

Specified by:

replace in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

unit - unit of measurement for the lifespan

Returns:

the value being replaced, or null if nothing is being replaced.

replace

public boolean replace(K key,
                       V oldValue,
                       V value,
                       long lifespan,
                       TimeUnit unit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.

Specified by:

replace in interface Cache<K,V>

Parameters:

key - key to use

oldValue - value to replace

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

unit - unit of measurement for the lifespan

Returns:

true if the value was replaced, false otherwise

put

public V put(K key,
             V value,
             long lifespan,
             TimeUnit lifespanUnit,
             long maxIdleTime,
             TimeUnit maxIdleTimeUnit)

Description copied from interface: Cache

An overloaded form of Map.put(Object, Object), which takes in lifespan parameters.

Specified by:

put in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

Returns:

the value being replaced, or null if nothing is being replaced.

putIfAbsent

public V putIfAbsent(K key,
                     V value,
                     long lifespan,
                     TimeUnit lifespanUnit,
                     long maxIdleTime,
                     TimeUnit maxIdleTimeUnit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.

Specified by:

putIfAbsent in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

Returns:

the value being replaced, or null if nothing is being replaced.

putAll

public void putAll(Map<? extends K,? extends V> map,
                   long lifespan,
                   TimeUnit lifespanUnit,
                   long maxIdleTime,
                   TimeUnit maxIdleTimeUnit)

Description copied from interface: Cache

An overloaded form of Map.putAll(java.util.Map), which takes in lifespan parameters. Note that the lifespan is applied to all mappings in the map passed in.

Specified by:

putAll in interface Cache<K,V>

Parameters:

map - map containing mappings to enter

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

replace

public V replace(K key,
                 V value,
                 long lifespan,
                 TimeUnit lifespanUnit,
                 long maxIdleTime,
                 TimeUnit maxIdleTimeUnit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.

Specified by:

replace in interface Cache<K,V>

Parameters:

key - key to use

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

Returns:

the value being replaced, or null if nothing is being replaced.

replace

public boolean replace(K key,
                       V oldValue,
                       V value,
                       long lifespan,
                       TimeUnit lifespanUnit,
                       long maxIdleTime,
                       TimeUnit maxIdleTimeUnit)

Description copied from interface: Cache

An overloaded form of ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.

Specified by:

replace in interface Cache<K,V>

Parameters:

key - key to use

oldValue - value to replace

value - value to store

lifespan - lifespan of the entry. Negative values are intepreted as unlimited lifespan.

lifespanUnit - time unit for lifespan

maxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as expired

maxIdleTimeUnit - time unit for max idle time

Returns:

true if the value was replaced, false otherwise

getAdvancedCache

public AdvancedCache<K,V> getAdvancedCache()

Specified by:

getAdvancedCache in interface Cache<K,V>

compact

public void compact()

Description copied from interface: Cache

Method that releases object references of cached objects held in the cache by serializing them to byte buffers. Cached objects are lazily deserialized when accessed again, based on the calling thread's context class loader.

This can be expensive, based on the effort required to serialize cached objects.

Specified by:

compact in interface Cache<K,V>

getStatus

public ComponentStatus getStatus()

Specified by:

getStatus in interface Cache<K,V>

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

remove

public boolean remove(Object key,
                      Object value)

Specified by:

remove in interface ConcurrentMap<K,V>

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Specified by:

replace in interface ConcurrentMap<K,V>

replace

public V replace(K key,
                 V value)

Specified by:

replace in interface ConcurrentMap<K,V>

size

public int size()

Specified by:

size in interface Map<K,V>

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

containsKey

public boolean containsKey(Object key)

Specified by:

containsKey in interface Map<K,V>

containsValue

public boolean containsValue(Object value)

Specified by:

containsValue in interface Map<K,V>

get

public V get(Object key)

Specified by:

get in interface Map<K,V>

put

public V put(K key,
             V value)

Specified by:

put in interface Map<K,V>

remove

public V remove(Object key)

Specified by:

remove in interface Map<K,V>

putAll

public void putAll(Map<? extends K,? extends V> t)

Specified by:

putAll in interface Map<K,V>

clear

public void clear()

Specified by:

clear in interface Map<K,V>

keySet

public Set<K> keySet()

Specified by:

keySet in interface Map<K,V>

entrySet

public Set<Map.Entry<K,V>> entrySet()

Specified by:

entrySet in interface Map<K,V>

values

public Collection<V> values()

Specified by:

values in interface Map<K,V>

start

public void start()

Specified by:

start in interface Lifecycle

stop

public void stop()

Specified by:

stop in interface Lifecycle

addListener

public void addListener(Object listener)

Description copied from interface: Listenable

Adds a listener to the component. Typically, listeners would need to be annotated with Listener and further to that, contain methods annotated appropriately, otherwise the listener will not be registered.

See the Listener annotation for more information.

Specified by:

addListener in interface Listenable

Parameters:

listener - must not be null.

removeListener

public void removeListener(Object listener)

Description copied from interface: Listenable

Removes a listener from the component.

Specified by:

removeListener in interface Listenable

Parameters:

listener - listener to remove. Must not be null.

getListeners

public Set<Object> getListeners()

Specified by:

getListeners in interface Listenable

Returns:

a set of all listeners registered on this component.