javax.cache

Interface Cache<K,V>

Type Parameters:

K - the type of key

V - the type of value

All Superinterfaces:

AutoCloseable, Closeable, Iterable<Cache.Entry<K,V>>

public interface Cache<K,V>
extends Iterable<Cache.Entry<K,V>>, Closeable

A Cache is a Map-like data structure that provides temporary storage of application data.

Like Maps, Caches

1. store key-value pairs, each referred to as an Cache.Entry
2. allow use Java Generics to improve application type-safety
3. are Iterable

Unlike Maps, Caches

1. do not allow null keys or values. Attempts to use null will result in a NullPointerException
2. provide the ability to read values from a CacheLoader (read-through-caching) when a value being requested is not in a cache
3. provide the ability to write values to a CacheWriter (write-through-caching) when a value being created/updated/removed from a cache
4. provide the ability to observe cache entry changes
5. may capture and measure operational statistics
6. may be transactional

A simple example of how to use a cache is: String cacheName = "sampleCache"; CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getCacheManager(); Cache<Integer, Date> cache = manager.getCache(cacheName, Integer.class, Date.class); Date value1 = new Date(); Integer key = 1; cache.put(key, value1); Date value2 = cache.get(key);

Since:

1.0

Author:

Greg Luck, Yannis Cosmadopoulos, Brian Oliver

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	Cache.Entry<K,V> A cache entry (key-value pair).
static interface	Cache.EntryProcessor<K,V,T> An invocable function that allows applications to perform compound operations on a Cache.Entry atomically, according the the defined consistency of a Cache.
static interface	Cache.MutableEntry<K,V> A mutable representation of a Cache Cache.Entry.

Method Summary

Methods

Modifier and Type	Method and Description
void	clear() Clears the contents of the cache, without notifying listeners or CacheWriters.
void	close() Signals to the CacheManager that the Cache should no longer be managed.
boolean	containsKey(K key) Determines if the Cache contains an entry for the specified key.
V	get(K key) Gets an entry from the cache.
Map<K,V>	getAll(Set<? extends K> keys) Gets a collection of entries from the Cache, returning them as Map of the values associated with the set of keys requested.
V	getAndPut(K key, V value) Associates the specified value with the specified key in this cache, returning an existing value if one existed.
V	getAndRemove(K key) Atomically removes the entry for a key only if currently mapped to a given value.
V	getAndReplace(K key, V value) Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
CacheManager	getCacheManager() Gets the CacheManager that owns and manages the Cache.
Configuration<K,V>	getConfiguration() Obtains an immutable representation of the Configuration that was used to configure the Cache.
String	getName() Return the name of the cache.
<T> T	invoke(K key, Cache.EntryProcessor<K,V,T> entryProcessor, Object... arguments) Invokes an Cache.EntryProcessor against the Cache.Entry specified by the provided key.
<T> Map<K,T>	invokeAll(Set<? extends K> keys, Cache.EntryProcessor<K,V,T> entryProcessor, Object... arguments) Invokes an Cache.EntryProcessor against the set of Cache.Entrys specified by the set of keys.
boolean	isClosed() Determines whether this Cache instance has been closed.
Iterator<Cache.Entry<K,V>>	iterator() The ordering of iteration over entries is undefined.
void	loadAll(Set<? extends K> keys, boolean replaceExistingValues, CompletionListener completionListener) Asynchronously loads the specified entries into the cache using the configured CacheLoader for the given keys.
void	put(K key, V value) Associates the specified value with the specified key in the cache.
void	putAll(Map<? extends K,? extends V> map) Copies all of the entries from the specified map to the Cache.
boolean	putIfAbsent(K key, V value) Atomically associates the specified key with the given value if it is not already associated with a value.
boolean	remove(K key) Removes the mapping for a key from this cache if it is present.
boolean	remove(K key, V oldValue) Atomically removes the mapping for a key only if currently mapped to the given value.
void	removeAll() Removes all of the mappings from this cache.
void	removeAll(Set<? extends K> keys) Removes entries for the specified keys.
boolean	replace(K key, V value) Atomically replaces the entry for a key only if currently mapped to some value.
boolean	replace(K key, V oldValue, V newValue) Atomically replaces the entry for a key only if currently mapped to a given value.
<T> T	unwrap(Class<T> clazz) Provides a standard way to access the underlying concrete caching implementation to provide access to further, proprietary features.

Method Detail

get

V get(K key)

Gets an entry from the cache.

If the cache is configured read-through, and get would return null because the entry is missing from the cache, the Cache's CacheLoader is called which will attempt to load the entry.

Parameters:

key - the key whose associated value is to be returned

Returns:

the element, or null, if it does not exist.

Throws:

IllegalStateException - if the cache is isClosed()

NullPointerException - if the key is null

CacheException - if there is a problem fetching the value

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key type is incompatible with that which has been configured for the Cache

getAll

Map<K,V> getAll(Set<? extends K> keys)

Gets a collection of entries from the Cache, returning them as Map of the values associated with the set of keys requested.

If the cache is configured read-through, and a get would return null because an entry is missing from the cache, the Cache's CacheLoader is called which will attempt to load the entry. This is done for each key in the set for which this is the case. If an entry cannot be loaded for a given key, the key will not be present in the returned Map.

Parameters:

keys - The keys whose associated values are to be returned.

Returns:

A map of entries that were found for the given keys. Keys not found in the cache are not in the returned map.

Throws:

NullPointerException - if keys is null or if keys contains a null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem fetching the values

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and any key type is incompatible with that which has been configured for the Cache

containsKey

boolean containsKey(K key)

Determines if the Cache contains an entry for the specified key.

More formally, returns true if and only if this cache contains a mapping for a key k such that key.equals(k). (There can be at most one such mapping.)

Parameters:

key - key whose presence in this cache is to be tested.

Returns:

true if this map contains a mapping for the specified key

Throws:

NullPointerException - if key is null

IllegalStateException - if the cache is isClosed()

CacheException - it there is a problem checking the mapping

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key type is incompatible with that which has been configured for the Cache

See Also:

Map.containsKey(Object)

loadAll

void loadAll(Set<? extends K> keys,
           boolean replaceExistingValues,
           CompletionListener completionListener)

Asynchronously loads the specified entries into the cache using the configured CacheLoader for the given keys.

If an entry for a key already exists in the Cache, a value will be loaded if and only if replaceExistingValues is true. If no loader is configured for the cache, no objects will be loaded. If a problem is encountered during the retrieving or loading of the objects, an exception is provided to the CompletionListener. Once the operation has completed, the specified CompletionListener is notified.

Implementations may choose to load multiple keys from the provided Set in parallel. Iteration however must not occur in parallel, thus allow for non-thread-safe Sets to be used.

The thread on which the completion listener is called is implementation dependent. An implementation may also choose to serialize calls to different CompletionListeners rather than use a thread per CompletionListener.

Parameters:

keys - the keys to load

replaceExistingValues - when true existing values in the Cache will be replaced by those loaded from a CacheLoader

completionListener - the CompletionListener (may be null)

Throws:

NullPointerException - if keys is null or if keys contains a null.

IllegalStateException - if the cache is isClosed()

CacheException - thrown if there is a problem performing the load. This may also be thrown on calling if their are insufficient threads available to perform the load.

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and any key type is incompatible with that which has been configured for the Cache

put

void put(K key,
       V value)

Associates the specified value with the specified key in the cache.

If the Cache previously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only if c.containsKey(k) would return true.)

Parameters:

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

value - value to be associated with the specified key

Throws:

NullPointerException - if key is null or if value is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those which have been configured for the Cache

See Also:

Map.put(Object, Object), getAndPut(Object, Object), getAndReplace(Object, Object)

getAndPut

V getAndPut(K key,
          V value)

Associates the specified value with the specified key in this cache, returning an existing value if one existed.

If the cache previously contained a mapping for the key, the old value is replaced by the specified value. (A cache c is said to contain a mapping for a key k if and only if c.containsKey(k) would return true.)

The the previous value is returned, or null if there was no value associated with the key previously.

Parameters:

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

value - value to be associated with the specified key

Returns:

the value associated with the key at the start of the operation or null if none was associated

Throws:

NullPointerException - if key is null or if value is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those which have been configured for the Cache

See Also:

put(Object, Object), getAndReplace(Object, Object)

putAll

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

Copies all of the entries from the specified map to the Cache.

The effect of this call is equivalent to that of calling put(k, v) on this cache once for each mapping from key k to value v in the specified map.

The order in which the individual puts occur is undefined.

The behavior of this operation is undefined if entries in the cache corresponding to entries in the map are modified or removed while this operation is in progress. or if map is modified while the operation is in progress.

In Default Consistency mode, individual puts occur atomically but not the entire putAll. Listeners may observe individual updates.

Parameters:

map - mappings to be stored in this cache

Throws:

NullPointerException - if map is null or if map contains null keys or values.

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put.

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and any of the key or value types are incompatible with those that have been configured for the Cache

putIfAbsent

boolean putIfAbsent(K key,
                  V value)

Atomically associates the specified key with the given value if it is not already associated with a value.

This is equivalent to: if (!cache.containsKey(key)) {} cache.put(key, value); return true; } else { return false; } except that the action is performed atomically.

Parameters:

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

value - value to be associated with the specified key

Returns:

true if a value was set.

Throws:

NullPointerException - if key is null or value is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

remove

boolean remove(K key)

Removes the mapping for a key from this cache if it is present.

More formally, if this cache contains a mapping from key k to value v such that (key==null ? k==null : key.equals(k)), that mapping is removed. (The cache can contain at most one such mapping.)

Returns true if this cache previously associated the key, or false if the cache contained no mapping for the key.

The cache will not contain a mapping for the specified key once the call returns.

Parameters:

key - key whose mapping is to be removed from the cache

Returns:

returns false if there was no matching key

Throws:

NullPointerException - if key is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key type is incompatible with that which has been configured for the Cache

remove

boolean remove(K key,
             V oldValue)

Atomically removes the mapping for a key only if currently mapped to the given value.

This is equivalent to: if (cache.containsKey(key) && cache.get(key).equals(oldValue)) { cache.remove(key); return true; } else { return false; } except that the action is performed atomically.

Parameters:

key - key whose mapping is to be removed from the cache

oldValue - value expected to be associated with the specified key

Returns:

returns false if there was no matching key

Throws:

NullPointerException - if key is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem doing the put

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

getAndRemove

V getAndRemove(K key)

Atomically removes the entry for a key only if currently mapped to a given value.

This is equivalent to: if (cache.containsKey(key)) { V oldValue = cache.get(key); cache.remove(key); return oldValue; } else { return null; } except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated

Returns:

the value if one existed or null if no mapping existed for this key

Throws:

NullPointerException - if the specified key or value is null.

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the remove

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key type is incompatible with that which has been configured for the Cache

replace

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

Atomically replaces the entry for a key only if currently mapped to a given value.

This is equivalent to: if (cache.containsKey(key) && cache.get(key).equals(oldValue)) { cache.put(key, newValue); return true; } else { return false; } except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated

oldValue - value expected to be associated with the specified key

newValue - value to be associated with the specified key

Returns:

true if the value was replaced

Throws:

NullPointerException - if key is null or if the values are null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the replace

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those which have been configured for the Cache

replace

boolean replace(K key,
              V value)

Atomically replaces the entry for a key only if currently mapped to some value.

This is equivalent to if (cache.containsKey(key)) { cache.put(key, value); return true; } else { return false; } except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated

value - value to be associated with the specified key

Returns:

true if the value was replaced

Throws:

NullPointerException - if key is null or if value is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the replace

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

See Also:

getAndReplace(Object, Object)

getAndReplace

V getAndReplace(K key,
              V value)

Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.

This is equivalent to if (cache.containsKey(key)) { V oldValue = cache.get(key); cache.put(key, value); return oldValue; } else { return null; } except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated

value - value to be associated with the specified key

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key.

Throws:

NullPointerException - if key is null or if value is null

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the replace

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

See Also:

ConcurrentMap.replace(Object, Object)

removeAll

void removeAll(Set<? extends K> keys)

Removes entries for the specified keys.

The order in which the individual removes will occur is undefined.

Parameters:

keys - the keys to remove

Throws:

NullPointerException - if keys is null or if it contains a null key

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the remove

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and any key type is incompatible with that which has been configured for the Cache

removeAll

void removeAll()

Removes all of the mappings from this cache.

The order in which the individual removes will occur is undefined.

This is potentially an expensive operation as listeners are invoked. Use clear() to avoid this.

Throws:

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the remove

See Also:

clear()

clear

void clear()

Clears the contents of the cache, without notifying listeners or CacheWriters.

Throws:

IllegalStateException - if the cache is isClosed()

CacheException - if there is a problem during the remove

getConfiguration

Configuration<K,V> getConfiguration()

Obtains an immutable representation of the Configuration that was used to configure the Cache.

Returns:

the Configuration

invoke

<T> T invoke(K key,
           Cache.EntryProcessor<K,V,T> entryProcessor,
           Object... arguments)

Invokes an Cache.EntryProcessor against the Cache.Entry specified by the provided key. If an Cache.Entry does not exist for the specified key, an attempt is made to loaded it (if a loader is configured) or an empty Cache.Entry is created and used instead.

Parameters:

key - the key to the entry

entryProcessor - the Cache.EntryProcessor to invoke

arguments - additional arguments to pass to the Cache.EntryProcessor

Returns:

the result of the processing, if any, defined by the Cache.EntryProcessor implementation

Throws:

NullPointerException - if key or Cache.EntryProcessor are null

IllegalStateException - if the cache is isClosed()

CacheException - if an exception occurred while executing the Cache.EntryProcessor (the causing exception will be wrapped by the CacheException)

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

See Also:

Cache.EntryProcessor

invokeAll

<T> Map<K,T> invokeAll(Set<? extends K> keys,
                     Cache.EntryProcessor<K,V,T> entryProcessor,
                     Object... arguments)

Invokes an Cache.EntryProcessor against the set of Cache.Entrys specified by the set of keys. If an Cache.Entry does not exist for a specified key, an attempt is made to loaded it (if a loader is configured) or an empty Cache.Entry is created and used instead.

The order in which the entries for the keys are processed is undefined. Implementations may choose to process the entries in any order, including concurrently. Furthermore there is no guarantee implementations will use the same Cache.EntryProcessor instance to process each entry, as the case may be in a non-local cache topology.

Parameters:

keys - the set of keys for entries to process

entryProcessor - the Cache.EntryProcessor to invoke

arguments - additional arguments to pass to the Cache.EntryProcessor

Returns:

the map of results of the processing per key, if any, defined by the Cache.EntryProcessor implementation. No mappings will be returned for Cache.EntryProcessors that return a null value for a key

Throws:

NullPointerException - if keys or Cache.EntryProcessor are null

IllegalStateException - if the cache is isClosed()

CacheException - if an exception occurred while executing the Cache.EntryProcessor (the causing exception will be wrapped by the CacheException)

ClassCastException - if the implementation supports and is configured to perform runtime-type-checking, and the key or value types are incompatible with those that have been configured for the Cache

See Also:

Cache.EntryProcessor

getName

String getName()

Return the name of the cache.

Returns:

the name of the cache.

getCacheManager

CacheManager getCacheManager()

Gets the CacheManager that owns and manages the Cache.

Returns:

the manager or null if the Cache is not managed

close

void close()

Signals to the CacheManager that the Cache should no longer be managed.

After calling this method the following conditions will be met;

isClosed() will return true

attempting to use operational methods on the Cache will throw an IllegalStateException.

the getName() no longer appear in the list of cache names returned by CacheManager.getCacheNames().

any .CacheLoader, CacheWriter, CacheEntryListeners or ExpiryPolicy configured to the Cache that implement Closeable will be closed.

all resources allocated to the Cache by the CacheManager will be freed.

A closed Cache instance cannot be reused.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

isClosed

boolean isClosed()

Determines whether this Cache instance has been closed. A Cache is considered closed if;

1. the close() method has been called
2. the associated getCacheManager() has been closed, or
3. the Cache has been removed from the associated getCacheManager()

This method generally cannot be called to determine whether a Cache instance is valid or invalid. A typical client can determine that a Cache is invalid by catching any exceptions that might be thrown when an operation is attempted.

Returns:

true if this Cache instance is closed; false if it is still open

unwrap

<T> T unwrap(Class<T> clazz)

Provides a standard way to access the underlying concrete caching implementation to provide access to further, proprietary features.

If the provider's implementation does not support the specified class, the IllegalArgumentException is thrown.

Parameters:

clazz - the proprietary class or interface of the underlying concrete cache. It is this type which is returned.

Returns:

an instance of the underlying concrete cache

Throws:

IllegalArgumentException - if the caching provider doesn't support the specified class.

iterator

Iterator<Cache.Entry<K,V>> iterator()

The ordering of iteration over entries is undefined.

During iteration, any entries that are a). read will have their appropriate CacheEntryReadListeners notified and b). removed will have their appropriate CacheEntryRemoveListeners notified.

Iterator.next() may return null if the entry is no longer present, has expired or has been evicted.

Specified by:

iterator in interface Iterable<Cache.Entry<K,V>>