|
| ||||
| |||||
public interface ClientCache<K,V>
| Modifier and Type | Method and Description |
|---|---|
void |
clear()
Clears the contents of the cache.
|
void |
clear(K key)
Clears entry with specified key from the cache.
|
void |
clearAll(Set<? extends K> keys)
Clears entries with specified keys from the cache.
|
IgniteClientFuture<Void> |
clearAllAsync(Set<? extends K> keys)
Clears entries with specified keys from the cache asynchronously.
|
IgniteClientFuture<Void> |
clearAsync()
Clears the contents of the cache asynchronously.
|
IgniteClientFuture<Void> |
clearAsync(K key)
Clears entry with specified key from the cache asynchronously.
|
boolean |
containsKey(K key)
Determines if the
ClientCache contains an entry for the specified key. |
IgniteClientFuture<Boolean> |
containsKeyAsync(K key)
Determines if the
ClientCache contains an entry for the specified key asynchronously. |
boolean |
containsKeys(Set<? extends K> keys)
Determines if the
ClientCache contains entries for the specified keys. |
IgniteClientFuture<Boolean> |
containsKeysAsync(Set<? extends K> keys)
Determines if the
ClientCache contains entries for the specified keys asynchronously. |
void |
deregisterCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
Deregisters a listener, using the
CacheEntryListenerConfiguration that was used to register it. |
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
ClientCache, returning them as
Map of the values associated with the set of keys requested. |
IgniteClientFuture<Map<K,V>> |
getAllAsync(Set<? extends K> keys)
Gets a collection of entries from the
ClientCache, returning them as
Map of the values associated with the set of keys requested. |
V |
getAndPut(K key,
V val)
Associates the specified value with the specified key in this cache, returning an existing value if one existed.
|
IgniteClientFuture<V> |
getAndPutAsync(K key,
V val)
Associates the specified value with the specified key in this cache, returning an existing value if one existed.
|
V |
getAndPutIfAbsent(K key,
V val)
Atomically associates the specified key with the given value if it is not already associated with a value.
|
IgniteClientFuture<V> |
getAndPutIfAbsentAsync(K key,
V val)
Atomically associates the specified key with the given value if it is not already associated with a value.
|
V |
getAndRemove(K key)
Atomically removes the entry for a key only if currently mapped to some value.
|
IgniteClientFuture<V> |
getAndRemoveAsync(K key)
Atomically removes the entry for a key only if currently mapped to some value.
|
V |
getAndReplace(K key,
V val)
Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
|
IgniteClientFuture<V> |
getAndReplaceAsync(K key,
V val)
Atomically replaces the value for a given key if and only if there is a value currently mapped by the key.
|
IgniteClientFuture<V> |
getAsync(K key)
Gets an entry from the cache asynchronously.
|
ClientCacheConfiguration |
getConfiguration() |
IgniteClientFuture<ClientCacheConfiguration> |
getConfigurationAsync()
Gets the cache configuration asynchronously.
|
String |
getName() |
<T> T |
invoke(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProc,
Object... arguments)
Invokes an
EntryProcessor against the Cache.Entry specified by
the provided key. |
<T> Map<K,javax.cache.processor.EntryProcessorResult<T>> |
invokeAll(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProc,
Object... args)
Invokes each
EntryProcessor against the set of Cache.Entrys specified by
the set of keys. |
<T> IgniteClientFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProc,
Object... args)
Asynchronously invokes each
EntryProcessor against the set of Cache.Entrys
specified by the set of keys. |
<T> IgniteClientFuture<T> |
invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProc,
Object... arguments)
Asynchronously invokes an
EntryProcessor against the Cache.Entry specified by
the provided key. |
void |
put(K key,
V val)
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
ClientCache. |
IgniteClientFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map)
Copies all of the entries from the specified map to the
ClientCache. |
IgniteClientFuture<Void> |
putAsync(K key,
V val)
Associates the specified value with the specified key in the cache asynchronously.
|
boolean |
putIfAbsent(K key,
V val)
Atomically associates the specified key with the given value if it is not already associated with a value.
|
IgniteClientFuture<Boolean> |
putIfAbsentAsync(K key,
V val)
Atomically associates the specified key with the given value if it is not already associated with a value.
|
<R> QueryCursor<R> |
query(ContinuousQuery<K,V> qry,
ClientDisconnectListener disconnectListener)
Start
ContinuousQuery on the cache. |
<R> QueryCursor<R> |
query(Query<R> qry)
Queries cache.
|
FieldsQueryCursor<List<?>> |
query(SqlFieldsQuery qry)
Convenience method to execute
SqlFieldsQuery. |
void |
registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration)
Registers a
CacheEntryListener. |
void |
registerCacheEntryListener(javax.cache.configuration.CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration,
ClientDisconnectListener disconnectListener)
Registers a
CacheEntryListener. |
boolean |
remove(K key)
Removes the mapping for a key from this cache if it is present.
|
boolean |
remove(K key,
V oldVal)
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.
|
IgniteClientFuture<Void> |
removeAllAsync()
Removes all of the mappings from this cache.
|
IgniteClientFuture<Void> |
removeAllAsync(Set<? extends K> keys)
Removes entries for the specified keys.
|
IgniteClientFuture<Boolean> |
removeAsync(K key)
Removes the mapping for a key from this cache if it is present.
|
IgniteClientFuture<Boolean> |
removeAsync(K key,
V oldVal)
Atomically removes the mapping for a key only if currently mapped to the given value.
|
boolean |
replace(K key,
V val)
Atomically replaces the entry for a key only if currently mapped to some
value.
|
boolean |
replace(K key,
V oldVal,
V newVal)
Atomically replaces the entry for a key only if currently mapped to a given value.
|
IgniteClientFuture<Boolean> |
replaceAsync(K key,
V val)
Atomically replaces the entry for a key only if currently mapped to some
value.
|
IgniteClientFuture<Boolean> |
replaceAsync(K key,
V oldVal,
V newVal)
Atomically replaces the entry for a key only if currently mapped to a given value.
|
int |
size(CachePeekMode... peekModes)
Gets the number of all entries cached across all nodes.
|
IgniteClientFuture<Integer> |
sizeAsync(CachePeekMode... peekModes)
Gets the number of all entries cached across all nodes.
|
<K1,V1> ClientCache<K1,V1> |
withExpirePolicy(javax.cache.expiry.ExpiryPolicy expiryPlc)
Deprecated.
Please use
withExpiryPolicy(javax.cache.expiry.ExpiryPolicy) instead. |
<K1,V1> ClientCache<K1,V1> |
withExpiryPolicy(javax.cache.expiry.ExpiryPolicy expiryPlc)
Returns cache with the specified expiry policy set.
|
<K1,V1> ClientCache<K1,V1> |
withKeepBinary()
Returns cache that will operate with binary objects.
|
V get(K key) throws ClientException
key - the key whose associated value is to be returnedNullPointerException - if the key is null.ClientExceptionIgniteClientFuture<V> getAsync(K key)
key - Key.void put(K key, V val) throws ClientException
If the ClientCache previously contained a mapping for the key, the old
value is replaced by the specified value.
key - key with which the specified value is to be associatedval - value to be associated with the specified key.NullPointerException - if key is null or if value is null.ClientExceptionIgniteClientFuture<Void> putAsync(K key, V val) throws ClientException
If the ClientCache previously contained a mapping for the key, the old
value is replaced by the specified value.
key - key with which the specified value is to be associatedval - value to be associated with the specified key.NullPointerException - if key is null or if value is null.ClientExceptionboolean containsKey(K key) throws ClientException
ClientCache 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)
key - key whose presence in this cache is to be tested.ClientExceptionIgniteClientFuture<Boolean> containsKeyAsync(K key) throws ClientException
ClientCache contains an entry for the specified key asynchronously.
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)
key - key whose presence in this cache is to be tested.ClientExceptionboolean containsKeys(Set<? extends K> keys) throws ClientException
ClientCache contains entries for the specified keys.keys - Keys whose presence in this cache is to be tested.True if this cache contains a mapping for the specified keys.ClientExceptionIgniteClientFuture<Boolean> containsKeysAsync(Set<? extends K> keys) throws ClientException
ClientCache contains entries for the specified keys asynchronously.keys - Keys whose presence in this cache is to be tested.true if this map contains a mapping for the specified keys.ClientExceptionString getName()
ClientCacheConfiguration getConfiguration() throws ClientException
ClientExceptionIgniteClientFuture<ClientCacheConfiguration> getConfigurationAsync() throws ClientException
ClientExceptionint size(CachePeekMode... peekModes) throws ClientException
peekModes value isn't provided,
only size of primary copies across all nodes will be returned. This behavior is identical to calling
this method with CachePeekMode.PRIMARY peek mode.
NOTE: this operation is distributed and will query all participating nodes for their cache sizes.
peekModes - Optional peek modes. If not provided, then total cache size is returned.ClientExceptionIgniteClientFuture<Integer> sizeAsync(CachePeekMode... peekModes) throws ClientException
peekModes value isn't provided,
only size of primary copies across all nodes will be returned. This behavior is identical to calling
this method with CachePeekMode.PRIMARY peek mode.
NOTE: this operation is distributed and will query all participating nodes for their cache sizes.
peekModes - Optional peek modes. If not provided, then total cache size is returned.ClientExceptionMap<K,V> getAll(Set<? extends K> keys) throws ClientException
ClientCache, returning them as
Map of the values associated with the set of keys requested.keys - The keys whose associated values are to be returned.ClientExceptionIgniteClientFuture<Map<K,V>> getAllAsync(Set<? extends K> keys) throws ClientException
ClientCache, returning them as
Map of the values associated with the set of keys requested.keys - The keys whose associated values are to be returned.ClientExceptionvoid putAll(Map<? extends K,? extends V> map) throws ClientException
ClientCache.
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.
map - Mappings to be stored in this cache.ClientExceptionIgniteClientFuture<Void> putAllAsync(Map<? extends K,? extends V> map) throws ClientException
ClientCache.
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.
map - Mappings to be stored in this cache.ClientExceptionboolean replace(K key, V oldVal, V newVal) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key) && equals(cache.get(key), oldValue)) {
cache.put(key, newValue);
return true;
} else {
return false;
}
key - Key with which the specified value is associated.oldVal - Value expected to be associated with the specified key.newVal - Value to be associated with the specified key.ClientExceptionIgniteClientFuture<Boolean> replaceAsync(K key, V oldVal, V newVal) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key) && equals(cache.get(key), oldValue)) {
cache.put(key, newValue);
return true;
} else {
return false;
}
key - Key with which the specified value is associated.oldVal - Value expected to be associated with the specified key.newVal - Value to be associated with the specified key.ClientExceptionboolean replace(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
cache.put(key, value);
return true;
} else {
return false;
}key - The key with which the specified value is associated.val - The value to be associated with the specified key.ClientExceptionIgniteClientFuture<Boolean> replaceAsync(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
cache.put(key, value);
return true;
} else {
return false;
}key - The key with which the specified value is associated.val - The value to be associated with the specified key.ClientExceptionboolean remove(K key) throws ClientException
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.
key - Key whose mapping is to be removed from the cache.ClientExceptionIgniteClientFuture<Boolean> removeAsync(K key) throws ClientException
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.
key - Key whose mapping is to be removed from the cache.ClientExceptionboolean remove(K key, V oldVal) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
cache.remove(key);
return true;
} else {
return false;
}
key - Key whose mapping is to be removed from the cache.oldVal - Value expected to be associated with the specified key.ClientExceptionIgniteClientFuture<Boolean> removeAsync(K key, V oldVal) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key) && equals(cache.get(key), oldValue) {
cache.remove(key);
return true;
} else {
return false;
}
key - Key whose mapping is to be removed from the cache.oldVal - Value expected to be associated with the specified key.ClientExceptionvoid removeAll(Set<? extends K> keys) throws ClientException
The order in which the individual entries are removed is undefined.
keys - The keys to remove.ClientExceptionIgniteClientFuture<Void> removeAllAsync(Set<? extends K> keys) throws ClientException
The order in which the individual entries are removed is undefined.
keys - The keys to remove.ClientExceptionvoid removeAll()
throws ClientException
The order that the individual entries are removed is undefined.
This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.
This is potentially an expensive operation as listeners are invoked.
Use clear() to avoid this.
ClientExceptionIgniteClientFuture<Void> removeAllAsync() throws ClientException
The order that the individual entries are removed is undefined.
This operation is not transactional. It calls broadcast closure that deletes all primary keys from remote nodes.
This is potentially an expensive operation as listeners are invoked.
Use clear() to avoid this.
ClientExceptionV getAndPut(K key, V val) throws ClientException
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 previous value is returned, or null if there was no value associated with the key previously.
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.ClientExceptionIgniteClientFuture<V> getAndPutAsync(K key, V val) throws ClientException
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 previous value is returned, or null if there was no value associated with the key previously.
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.ClientExceptionV getAndRemove(K key) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
V oldValue = cache.get(key);
cache.remove(key);
return oldValue;
} else {
return null;
}
key - Key with which the specified value is associated.ClientExceptionIgniteClientFuture<V> getAndRemoveAsync(K key) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
V oldValue = cache.get(key);
cache.remove(key);
return oldValue;
} else {
return null;
}
key - Key with which the specified value is associated.ClientExceptionV getAndReplace(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
V oldValue = cache.get(key);
cache.put(key, value);
return oldValue;
} else {
return null;
}
key - Key with which the specified value is associated.val - Value to be associated with the specified key.ClientExceptionIgniteClientFuture<V> getAndReplaceAsync(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (cache.containsKey(key)) {
V oldValue = cache.get(key);
cache.put(key, value);
return oldValue;
} else {
return null;
}
key - Key with which the specified value is associated.val - Value to be associated with the specified key.ClientExceptionboolean putIfAbsent(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (!cache.containsKey(key)) {
cache.put(key, value);
return true;
} else {
return false;
}
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.ClientExceptionIgniteClientFuture<Boolean> putIfAbsentAsync(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (!cache.containsKey(key)) {
cache.put(key, value);
return true;
} else {
return false;
}
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.ClientExceptionV getAndPutIfAbsent(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (!cache.containsKey(key)) {
cache.put(key, value);
return null;
} else {
return cache.get(key);
}
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.null if no value was associated
with the specified key and a value was set.ClientExceptionIgniteClientFuture<V> getAndPutIfAbsentAsync(K key, V val) throws ClientException
This is equivalent to performing the following operations as a single atomic action:
if (!cache.containsKey(key)) {
cache.put(key, value);
return null;
} else {
return cache.get(key);
}
key - Key with which the specified value is to be associated.val - Value to be associated with the specified key.null if no value was associated with the specified key and a
value was set.ClientExceptionvoid clear()
throws ClientException
removeAll(), this method does not notify event listeners and cache writers.ClientExceptionIgniteClientFuture<Void> clearAsync() throws ClientException
removeAll(), this method does not notify event listeners and cache writers.ClientExceptionvoid clear(K key) throws ClientException
remove(Object), this method does not notify event listeners and cache writers.ClientExceptionIgniteClientFuture<Void> clearAsync(K key) throws ClientException
removeAsync(Object), this method does not notify event listeners and cache writers.ClientExceptionvoid clearAll(Set<? extends K> keys) throws ClientException
removeAll(Set), this method does not notify event listeners and cache writers.ClientExceptionIgniteClientFuture<Void> clearAllAsync(Set<? extends K> keys) throws ClientException
removeAllAsync(Set), this method does not notify event listeners and cache writers.ClientException<T> T invoke(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments) throws javax.cache.processor.EntryProcessorException, ClientException
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 load it (if a loader is configured) or a surrogate
Cache.Entry, consisting of the key with a null value is used instead.
An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same.
T - Type of the cache entry processing result.key - The key to the entry.entryProc - The EntryProcessor to invoke.arguments - Additional arguments to pass to the EntryProcessor.EntryProcessor implementation.NullPointerException - If key or EntryProcessor is null.javax.cache.processor.EntryProcessorException - If an exception is thrown by the EntryProcessor, a Caching Implementation
must wrap any Exception thrown
wrapped in an EntryProcessorException.ClientException - If operation is failed.<T> IgniteClientFuture<T> invokeAsync(K key, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... arguments) throws ClientException
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 load it (if a loader is configured) or a surrogate
Cache.Entry, consisting of the key with a null value is used instead.
An instance of entry processor must be stateless as it may be invoked multiple times on primary and backup nodes in the cache. It is guaranteed that the value passed to the entry processor will be always the same.
T - Type of the cache entry processing result.key - The key to the entry.entryProc - The EntryProcessor to invoke.arguments - Additional arguments to pass to the EntryProcessor.NullPointerException - If key or EntryProcessor is null.ClientException - If operation is failed.<T> Map<K,javax.cache.processor.EntryProcessorResult<T>> invokeAll(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... args) throws ClientException
EntryProcessor against the set of Cache.Entrys specified by
the set of keys.
If an Cache.Entry does not exist for the specified key, an attempt is made
to load it (if a loader is configured) or a surrogate Cache.Entry,
consisting of the key and a value of null is provided.
The order that 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 EntryProcessor instance to process each entry, as
the case may be in a non-local cache topology.
The result of executing the EntryProcessor is returned as a
Map of EntryProcessorResults, one result per key. Should the
EntryProcessor or Caching implementation throw an exception, the
exception is wrapped and re-thrown when a call to
EntryProcessorResult.get() is made.
Keys are locked in the order in which they appear in key set. It is caller's responsibility to
make sure keys always follow same order, such as by using TreeSet. Using unordered map,
such as HashSet, while calling this method in parallel will lead to deadlock.
T - Type of the cache entry processing result.keys - The set of keys for entries to proces.entryProc - The EntryProcessor to invoke.args - Additional arguments to pass to the EntryProcessor.EntryProcessorResults of the processing per key,
if any, defined by the EntryProcessor implementation. No mappings
will be returned for EntryProcessors that return a
null value for a key.NullPointerException - If keys or EntryProcessor is null.ClientException - If operation is failed.<T> IgniteClientFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> invokeAllAsync(Set<? extends K> keys, javax.cache.processor.EntryProcessor<K,V,T> entryProc, Object... args) throws ClientException
EntryProcessor against the set of Cache.Entrys
specified by the set of keys.
If an Cache.Entry does not exist for the specified key, an attempt is made
to load it (if a loader is configured) or a surrogate Cache.Entry,
consisting of the key and a value of null is provided.
The order that 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 EntryProcessor instance to process each entry, as
the case may be in a non-local cache topology.
The result of executing the EntryProcessor is returned in the future as a
Map of EntryProcessorResults, one result per key. Should the
EntryProcessor or Caching implementation throw an exception, the
exception is wrapped and re-thrown when a call to
EntryProcessorResult.get() is made.
Keys are locked in the order in which they appear in key set. It is caller's responsibility to
make sure keys always follow same order, such as by using TreeSet. Using unordered map,
such as HashSet, while calling this method in parallel will lead to deadlock.
T - Type of the cache entry processing result.keys - The set of keys for entries to proces.entryProc - The EntryProcessor to invoke.args - Additional arguments to pass to the EntryProcessor.NullPointerException - If keys or EntryProcessor is null.ClientException - If operation is failed.<K1,V1> ClientCache<K1,V1> withKeepBinary()
Cache returned by this method will not be forced to deserialize binary objects, so keys and values will be returned from cache API methods without changes. Therefore, signature of the cache can contain only following types:
org.apache.ignite.binary.BinaryObject for binary classesString and array of StringsUUID and array of UUIDsDate and array of DatesTimestamp and array of Timestamps
For example, if you use Integer as a key and Value class as a value
(which will be stored in binary format), you should acquire following projection
to avoid deserialization:
