public class RemoteCacheImpl<K,V> extends RemoteCacheSupport<K,V>
defaultLifespan, defaultMaxIdleTime| Constructor and Description |
|---|
RemoteCacheImpl(RemoteCacheManager rcm,
String name) |
| Modifier and Type | Method and Description |
|---|---|
void |
clear() |
NotifyingFuture<Void> |
clearAsync()
Asynchronous version of
#clear(). |
boolean |
containsKey(Object key) |
V |
get(Object key) |
NotifyingFuture<V> |
getAsync(K key)
Asynchronous version of
#get(Object) that allows user code to
retrieve the value associated with a key at a later stage, hence allowing
multiple parallel get requests to be sent. |
Map<K,V> |
getBulk()
Bulk get operations, returns all the entries within the remote cache.
|
Map<K,V> |
getBulk(int size)
Same as
RemoteCache.getBulk(), but limits the returned set of values to the specified size. |
String |
getName()
Retrieves the name of the cache
|
OperationsFactory |
getOperationsFactory() |
String |
getProtocolVersion()
Returns the HotRod protocol version supported by this RemoteCache implementation
|
RemoteCacheManager |
getRemoteCacheManager()
Returns the
RemoteCacheManager that created this cache. |
String |
getVersion()
Retrieves the version of Infinispan
|
VersionedValue<V> |
getVersioned(K key)
Returns the
VersionedValue associated to the supplied key param, or null if it doesn't exist. |
MetadataValue<V> |
getWithMetadata(K key)
Returns the
MetadataValue associated to the supplied key param, or null if it doesn't exist. |
void |
init(Marshaller marshaller,
ExecutorService executorService,
OperationsFactory operationsFactory,
int estimateKeySize,
int estimateValueSize) |
boolean |
isEmpty() |
Set<K> |
keySet()
Returns all keys in the remote server.
|
PingOperation.PingResult |
ping() |
V |
put(K key,
V value,
long lifespan,
TimeUnit lifespanUnit,
long maxIdleTime,
TimeUnit maxIdleTimeUnit)
An overloaded form of
BasicCache.put(Object, Object), which takes in lifespan parameters. |
void |
putAll(Map<? extends K,? extends V> map,
long lifespan,
TimeUnit lifespanUnit,
long maxIdleTime,
TimeUnit maxIdleTimeUnit)
Synthetic operation.
|
NotifyingFuture<Void> |
putAllAsync(Map<? extends K,? extends V> data,
long lifespan,
TimeUnit lifespanUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Synthetic operation.
|
NotifyingFuture<V> |
putAsync(K key,
V value,
long lifespan,
TimeUnit lifespanUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Asynchronous version of
#put(Object, Object, long, TimeUnit, long, TimeUnit). |
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. |
NotifyingFuture<V> |
putIfAbsentAsync(K key,
V value,
long lifespan,
TimeUnit lifespanUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Asynchronous version of
#putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit). |
V |
remove(Object key)
If the return value of this operation will be ignored by the application,
the user is strongly encouraged to use the
Flag.IGNORE_RETURN_VALUES
flag when invoking this method in order to make it behave as efficiently
as possible (i.e. |
NotifyingFuture<V> |
removeAsync(Object key)
Asynchronous version of
#remove(Object). |
boolean |
removeWithVersion(K key,
long version)
Removes the given entry only if its version matches the supplied version.
|
NotifyingFuture<Boolean> |
removeWithVersionAsync(K key,
long version) |
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. |
NotifyingFuture<V> |
replaceAsync(K key,
V value,
long lifespan,
TimeUnit lifespanUnit,
long maxIdle,
TimeUnit maxIdleUnit)
Asynchronous version of
#replace(Object, Object, long, TimeUnit, long, TimeUnit). |
boolean |
replaceWithVersion(K key,
V newValue,
long version,
int lifespanSeconds,
int maxIdleTimeSeconds)
A overloaded form of
RemoteCache.replaceWithVersion(Object, Object, long)
which takes in lifespan and maximum idle time parameters. |
NotifyingFuture<Boolean> |
replaceWithVersionAsync(K key,
V newValue,
long version,
int lifespanSeconds,
int maxIdleSeconds) |
protected void |
set(K key,
V value)
This is intentionally a non-public method meant as an integration point for bytecode manipulation.
|
int |
size() |
void |
start() |
ServerStatistics |
stats() |
void |
stop() |
RemoteCache<K,V> |
withFlags(Flag... flags)
Applies one or more
Flags to the scope of a single invocation. |
containsValue, entrySet, put, put, putAll, putAll, putAllAsync, putAllAsync, putAsync, putAsync, putIfAbsent, putIfAbsent, putIfAbsentAsync, putIfAbsentAsync, remove, removeAsync, replace, replace, replace, replace, replace, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceAsync, replaceWithVersion, replaceWithVersion, replaceWithVersionAsync, replaceWithVersionAsync, valuespublic RemoteCacheImpl(RemoteCacheManager rcm, String name)
public void init(Marshaller marshaller, ExecutorService executorService, OperationsFactory operationsFactory, int estimateKeySize, int estimateValueSize)
public OperationsFactory getOperationsFactory()
public RemoteCacheManager getRemoteCacheManager()
RemoteCacheRemoteCacheManager that created this cache.public boolean removeWithVersion(K key, long version)
RemoteCacheVersionedEntry ve = remoteCache.getVersioned(key); //some processing remoteCache.removeWithVersion(key, ve.getVersion();Lat call (removeWithVersion) will make sure that the entry will only be removed if it hasn't been changed in between.
VersionedValue,
RemoteCache.getVersioned(Object)public NotifyingFuture<Boolean> removeWithVersionAsync(K key, long version)
ConcurrentMap.remove(Object, Object)public boolean replaceWithVersion(K key, V newValue, long version, int lifespanSeconds, int maxIdleTimeSeconds)
RemoteCacheRemoteCache.replaceWithVersion(Object, Object, long)
which takes in lifespan and maximum idle time parameters.key - key to usenewValue - new value to be associated with the keyversion - numeric version that should match the one in the server
for the operation to succeedlifespanSeconds - lifespan of the entrymaxIdleTimeSeconds - the maximum amount of time this key is allowed
to be idle for before it is considered as expiredpublic NotifyingFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)
public VersionedValue<V> getVersioned(K key)
RemoteCacheVersionedValue associated to the supplied key param, or null if it doesn't exist.public MetadataValue<V> getWithMetadata(K key)
RemoteCacheMetadataValue associated to the supplied key param, or null if it doesn't exist.public void putAll(Map<? extends K,? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
RemoteCachemap - map containing mappings to enterlifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.lifespanUnit - time unit for lifespanmaxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleTimeUnit - time unit for max idle timeRemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)public NotifyingFuture<Void> putAllAsync(Map<? extends K,? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
RemoteCachedata - to storelifespan - lifespan of entrylifespanUnit - time unit for lifespanmaxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleUnit - time unit for max idle timeRemoteCache.putAll(java.util.Map, long, java.util.concurrent.TimeUnit)public int size()
public boolean isEmpty()
public ServerStatistics stats()
public V put(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
BasicCacheBasicCache.put(Object, Object), which takes in lifespan parameters.key - key to usevalue - value to storelifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.lifespanUnit - time unit for lifespanmaxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleTimeUnit - time unit for max idle timepublic V putIfAbsent(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
BasicCacheConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.key - key to usevalue - value to storelifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.lifespanUnit - time unit for lifespanmaxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleTimeUnit - time unit for max idle timepublic V replace(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
BasicCacheConcurrentMap.replace(Object, Object), which takes in lifespan parameters.key - key to usevalue - value to storelifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.lifespanUnit - time unit for lifespanmaxIdleTime - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleTimeUnit - time unit for max idle timepublic NotifyingFuture<V> putAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
AsyncCache#put(Object, Object, long, TimeUnit, long, TimeUnit). This method does not block
on remote calls, even if your cache mode is synchronous. Has no benefit over #put(Object, Object, long,
TimeUnit, long, TimeUnit) if used in LOCAL mode.key - key to usevalue - value to storelifespan - lifespan of entrylifespanUnit - time unit for lifespanmaxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleUnit - time unit for max idle timepublic NotifyingFuture<Void> clearAsync()
AsyncCache#clear(). This method does not block on remote calls, even if your cache mode is
synchronous. Has no benefit over #clear() if used in LOCAL mode.public NotifyingFuture<V> putIfAbsentAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
AsyncCache#putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit). This method does
not block on remote calls, even if your cache mode is synchronous. Has no benefit over #putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.key - key to usevalue - value to storelifespan - lifespan of entrylifespanUnit - time unit for lifespanmaxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleUnit - time unit for max idle timepublic NotifyingFuture<V> removeAsync(Object key)
AsyncCache#remove(Object). This method does not block on remote calls, even if your cache
mode is synchronous. Has no benefit over #remove(Object) if used in LOCAL mode.key - key to removepublic NotifyingFuture<V> replaceAsync(K key, V value, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
AsyncCache#replace(Object, Object, long, TimeUnit, long, TimeUnit). This method does not
block on remote calls, even if your cache mode is synchronous. Has no benefit over #replace(Object,
Object, long, TimeUnit, long, TimeUnit) if used in LOCAL mode.key - key to removevalue - value to storelifespan - lifespan of entrylifespanUnit - time unit for lifespanmaxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as
expiredmaxIdleUnit - time unit for max idle timepublic boolean containsKey(Object key)
public Map<K,V> getBulk()
RemoteCachepublic Map<K,V> getBulk(int size)
RemoteCacheRemoteCache.getBulk(), but limits the returned set of values to the specified size. No ordering is guaranteed, and there is no
guarantee that "size" elements are returned( e.g. if the number of elements in the back-end server is smaller that "size")public V remove(Object key)
BasicCacheFlag.IGNORE_RETURN_VALUES
flag when invoking this method in order to make it behave as efficiently
as possible (i.e. avoiding needless remote or network calls).public void clear()
public void start()
public void stop()
public String getName()
BasicCachepublic String getVersion()
BasicCachepublic String getProtocolVersion()
RemoteCachepublic RemoteCache<K,V> withFlags(Flag... flags)
RemoteCacheFlags to the scope of a single invocation. See the Flag enumeration to for
information on available flags.
Sample usage:
remoteCache.withFlags(Flag.FORCE_RETURN_VALUE).put("hello", "world");
public NotifyingFuture<V> getAsync(K key)
AsyncCache#get(Object) that allows user code to
retrieve the value associated with a key at a later stage, hence allowing
multiple parallel get requests to be sent. Normally, when this method
detects that the value is likely to be retrieved from from a remote
entity, it will span a different thread in order to allow the
asynchronous get call to return immediately. If the call will definitely
resolve locally, for example when the cache is configured with LOCAL mode
and no stores are configured, the get asynchronous call will act
sequentially and will have no different to #get(Object).key - key to retrieve#get(Object)public PingOperation.PingResult ping()
protected void set(K key, V value)
RemoteCacheSupportset in class RemoteCacheSupport<K,V>public Set<K> keySet()
RemoteCacheCopyright © 2014 JBoss, a division of Red Hat. All Rights Reserved.