Interface RemoteCache<K,V>

All Superinterfaces:
AsyncCache<K,V>, BasicCache<K,V>, ConcurrentMap<K,V>, Lifecycle, Map<K,V>, TransactionalCache
All Known Subinterfaces:
InternalRemoteCache<K,V>
All Known Implementing Classes:
DelegatingRemoteCache, InvalidatedNearRemoteCache, RemoteCacheImpl, RemoteCacheSupport
public interface RemoteCache<K,V> extends BasicCache<K,V>, TransactionalCache
Provides remote reference to a Hot Rod server/cluster. It implements BasicCache, but given its nature (remote) some operations are not supported. All these unsupported operations are being overridden within this interface and documented as such. New operations: besides the operations inherited from BasicCache, RemoteCache also adds new operations to optimize/reduce network traffic: e.g. versioned put operation. Concurrency: implementors of this interface will support multi-threaded access, similar to the way BasicCache supports it. Return values: previously existing values for certain Map operations are not returned, null is returned instead. E.g. Map.put(Object, Object) returns the previous value associated to the supplied key. In case of RemoteCache, this returns null. Changing default behavior through Flags: it is possible to change the default cache behaviour by using flags on an per invocation basis. E.g. 
      RemoteCache cache = getRemoteCache();
      Object oldValue = cache.withFlags(Flag.FORCE_RETURN_VALUE).put(aKey, aValue);
In the previous example, using Flag.FORCE_RETURN_VALUE will make the client to also return previously existing value associated with aKey. If this flag would not be present, Infinispan would return (by default) null. This is in order to avoid fetching a possibly large object from the remote server, which might not be needed. The flags as set by the withFlags(Flag...) operation only apply for the very next operation executed by the same thread on the RemoteCache. Note on default expiration values: Due to limitations on the first version of the protocol, it's not possible for clients to rely on default lifespan and maxIdle values set on the server. This is because the protocol does not support a way to tell the server that no expiration lifespan and/or maxIdle were provided and that default values should be used. This will be resolved in a future revision of the protocol. In the meantime, the workaround is to explicitly provide the desired expiry lifespan/maxIdle values in each remote cache operation.
Since:
4.1
Author:
Mircea.Markus@jboss.com

  • Method Details

    • removeWithVersion

      boolean removeWithVersion(K key, long version)
      Removes the given entry only if its version matches the supplied version. A typical use case looks like this: 
       VersionedEntry 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.
      Returns:
      true if the entry has been removed
      See Also:

    • remove

      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 org.infinispan.context.Flag#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).

      The returned value is only sent back if Flag.FORCE_RETURN_VALUE is enabled.

      Specified by:
      remove in interface BasicCache<K,V>
      Specified by:
      remove in interface Map<K,V>

    • remove

      boolean remove(Object key, Object value)

      This method requires 2 round trips to the server. The first to retrieve the value and version and a second to remove the key with the version if the value matches. If possible user should use getWithMetadata(Object) and removeWithVersion(Object, long).

      Specified by:
      remove in interface ConcurrentMap<K,V>
      Specified by:
      remove in interface Map<K,V>

    • replace

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

      This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use getWithMetadata(Object) and replaceWithVersion(Object, Object, long).

      Specified by:
      replace in interface ConcurrentMap<K,V>
      Specified by:
      replace in interface Map<K,V>

    • replace

      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.

      This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use getWithMetadata(Object) and replaceWithVersion(Object, Object, long, long, TimeUnit, long, TimeUnit).

      Specified by:
      replace in interface BasicCache<K,V>
      Parameters:
      key - key to use
      oldValue - value to replace
      value - value to store
      lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
      unit - unit of measurement for the lifespan
      Returns:
      true if the value was replaced, false otherwise

    • replace

      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.

      This method requires 2 round trips to the server. The first to retrieve the value and version and a second to replace the key with the version if the value matches. If possible user should use getWithMetadata(Object) and replaceWithVersion(Object, Object, long, long, TimeUnit, long, TimeUnit) if possible.

      Specified by:
      replace in interface BasicCache<K,V>
      Parameters:
      key - key to use
      oldValue - value to replace
      value - value to store
      lifespan - lifespan of the entry. Negative values are interpreted 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

    • removeWithVersionAsync

      CompletableFuture<Boolean> removeWithVersionAsync(K key, long version)
      See Also:

    • replaceWithVersion

      boolean replaceWithVersion(K key, V newValue, long version)
      Replaces the given value only if its version matches the supplied version. See removeWithVersion(Object, long) for a sample usage of the version-based methods.
      Parameters:
      version - numeric version that should match the one in the server for the operation to succeed
      Returns:
      true if the value has been replaced
      See Also:

    • replaceWithVersion

      boolean replaceWithVersion(K key, V newValue, long version, int lifespanSeconds)
      A overloaded form of replaceWithVersion(Object, Object, long) which takes in lifespan parameters.
      Parameters:
      key - key to use
      newValue - new value to be associated with the key
      version - numeric version that should match the one in the server for the operation to succeed
      lifespanSeconds - lifespan of the entry
      Returns:
      true if the value was replaced

    • replaceWithVersion

      boolean replaceWithVersion(K key, V newValue, long version, int lifespanSeconds, int maxIdleTimeSeconds)
      A overloaded form of replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
      Parameters:
      key - key to use
      newValue - new value to be associated with the key
      version - numeric version that should match the one in the server for the operation to succeed
      lifespanSeconds - lifespan of the entry
      maxIdleTimeSeconds - the maximum amount of time this key is allowed to be idle for before it is considered as expired
      Returns:
      true if the value was replaced

    • replaceWithVersion

      boolean replaceWithVersion(K key, V newValue, long version, long lifespan, TimeUnit lifespanTimeUnit, long maxIdle, TimeUnit maxIdleTimeUnit)
      A overloaded form of replaceWithVersion(Object, Object, long) which takes in lifespan and maximum idle time parameters.
      Parameters:
      key - key to use
      newValue - new value to be associated with the key
      version - numeric version that should match the one in the server for the operation to succeed
      lifespan - lifespan of the entry
      lifespanTimeUnit - TimeUnit for lifespan
      maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
      maxIdleTimeUnit - TimeUnit for maxIdle
      Returns:
      true if the value was replaced

    • replaceWithVersionAsync

      CompletableFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version)
      See Also:

    • replaceWithVersionAsync

      CompletableFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds)
      See Also:

    • replaceWithVersionAsync

      CompletableFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version, int lifespanSeconds, int maxIdleSeconds)
      See Also:

    • replaceWithVersionAsync

      CompletableFuture<Boolean> replaceWithVersionAsync(K key, V newValue, long version, long lifespanSeconds, TimeUnit lifespanTimeUnit, long maxIdle, TimeUnit maxIdleTimeUnit)
      See Also:

    • retrieveEntries

      default CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory, Set<Integer> segments, int batchSize)
      See Also:

    • retrieveEntries

      CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory, Object[] filterConverterParams, Set<Integer> segments, int batchSize)
      Retrieve entries from the server.
      Parameters:
      filterConverterFactory - Factory name for the KeyValueFilterConverter or null for no filtering.
      filterConverterParams - Parameters to the KeyValueFilterConverter
      segments - The segments to iterate. If null all segments will be iterated. An empty set will filter out all entries.
      batchSize - The number of entries transferred from the server at a time.
      Returns:
      Iterator for the entries

    • publishEntries

      <E> org.reactivestreams.Publisher<Map.Entry<K,E>> publishEntries(String filterConverterFactory, Object[] filterConverterParams, Set<Integer> segments, int batchSize)
      Publishes the entries from the server in a non blocking fashion.

      Any subscriber that subscribes to the returned Publisher must not block. It is therefore recommended to offload any blocking or long running operations to a different thread and not use the invoking one. Failure to do so may cause concurrent operations to stall.

      Parameters:
      filterConverterFactory - Factory name for the KeyValueFilterConverter or null for no filtering.
      filterConverterParams - Parameters to the KeyValueFilterConverter
      segments - The segments to utilize. If null all segments will be utilized. An empty set will filter out all entries.
      batchSize - The number of entries transferred from the server at a time.
      Returns:
      Publisher for the entries

    • retrieveEntries

      default CloseableIterator<Map.Entry<Object,Object>> retrieveEntries(String filterConverterFactory, int batchSize)
      See Also:

    • retrieveEntriesByQuery

      CloseableIterator<Map.Entry<Object,Object>> retrieveEntriesByQuery(Query<?> filterQuery, Set<Integer> segments, int batchSize)
      Retrieve entries from the server matching a query.
      Parameters:
      filterQuery - Query
      segments - The segments to iterate. If null all segments will be iterated. An empty set will filter out all entries.
      batchSize - The number of entries transferred from the server at a time.
      Returns:
      CloseableIterator

    • publishEntriesByQuery

      <E> org.reactivestreams.Publisher<Map.Entry<K,E>> publishEntriesByQuery(Query<?> filterQuery, Set<Integer> segments, int batchSize)
      Publish entries from the server matching a query.

      Any subscriber that subscribes to the returned Publisher must not block. It is therefore recommended to offload any blocking or long running operations to a different thread and not use the invoking one. Failure to do so may cause concurrent operations to stall.

      Parameters:
      filterQuery - Query
      segments - The segments to utilize. If null all segments will be utilized. An empty set will filter out all entries.
      batchSize - The number of entries transferred from the server at a time.
      Returns:
      Publisher containing matching entries

    • retrieveEntriesWithMetadata

      CloseableIterator<Map.Entry<Object, MetadataValue<Object>>> retrieveEntriesWithMetadata(Set<Integer> segments, int batchSize)
      Retrieve entries with metadata information

    • publishEntriesWithMetadata

      org.reactivestreams.Publisher<Map.Entry<K, MetadataValue<V>>> publishEntriesWithMetadata(Set<Integer> segments, int batchSize)
      Publish entries with metadata information

      Any subscriber that subscribes to the returned Publisher must not block. It is therefore recommended to offload any blocking or long running operations to a different thread and not use the invoking one. Failure to do so may cause concurrent operations to stall.

      Parameters:
      segments - The segments to utilize. If null all segments will be utilized. An empty set will filter out all entries.
      batchSize - The number of entries transferred from the server at a time.
      Returns:
      Publisher containing entries along with metadata

    • getWithMetadata

      MetadataValue<V> getWithMetadata(K key)
      Returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.

    • getWithMetadataAsync

      CompletableFuture<MetadataValue<V>> getWithMetadataAsync(K key)
      Asynchronously returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.

    • keySet

      default CloseableIteratorSet<K> keySet()

      Due to this set being backed by the remote cache, each invocation on this set may require remote invocations to retrieve or update the remote cache. The main benefit of this set being backed by the remote cache is that this set internally does not require having to store any keys locally in memory and allows for the user to iteratively retrieve keys from the cache which is more memory conservative.

      If you do wish to create a copy of this set (requires all entries in memory), the user may invoke keySet().stream().collect(Collectors.toSet()) to copy the data locally. Then all operations on the resulting set will not require remote access, however updates will not be reflected from the remote cache.

      NOTE: this method returns a CloseableIteratorSet which requires the iterator, spliterator or stream returned from it to be closed. Failure to do so may cause additional resources to not be freed.

      Specified by:
      keySet in interface Map<K,V>

    • keySet

      CloseableIteratorSet<K> keySet(IntSet segments)
      This method is identical to keySet() except that it will only return keys that map to the given segments. Note that these segments will be determined by the remote server. Thus you should be aware of how many segments it has configured and hashing algorithm it is using. If the segments and hashing algorithm are not the same this method may return unexpected keys.
      Parameters:
      segments - the segments of keys to return - null means all available
      Returns:
      set containing keys that map to the given segments
      Since:
      9.4
      See Also:

    • values

      default CloseableIteratorCollection<V> values()

      Due to this collection being backed by the remote cache, each invocation on this collection may require remote invocations to retrieve or update the remote cache. The main benefit of this collection being backed by the remote cache is that this collection internally does not require having to store any values locally in memory and allows for the user to iteratively retrieve values from the cache which is more memory conservative.

      If you do wish to create a copy of this collection (requires all entries in memory), the user may invoke values().stream().collect(Collectors.toList()) to copy the data locally. Then all operations on the resulting list will not require remote access, however updates will not be reflected from the remote cache.

      NOTE: this method returns a CloseableIteratorCollection which requires the iterator, spliterator or stream returned from it to be closed. Failure to do so may cause additional resources to not be freed.

      Specified by:
      values in interface Map<K,V>

    • values

      CloseableIteratorCollection<V> values(IntSet segments)
      This method is identical to values() except that it will only return values that map to the given segments. Note that these segments will be determined by the remote server. Thus you should be aware of how many segments it has configured and hashing algorithm it is using. If the segments and hashing algorithm are not the same this method may return unexpected values.
      Parameters:
      segments - the segments of values to return - null means all available
      Returns:
      collection containing values that map to the given segments
      Since:
      9.4
      See Also:

    • entrySet

      default CloseableIteratorSet<Map.Entry<K,V>> entrySet()

      Due to this set being backed by the remote cache, each invocation on this set may require remote invocations to retrieve or update the remote cache. The main benefit of this set being backed by the remote cache is that this set internally does not require having to store any entries locally in memory and allows for the user to iteratively retrieve entries from the cache which is more memory conservative.

      The Set.remove(Object) method requires two round trips to the server to properly remove an entry. This is because they first must retrieve the value and version to see if it matches and if it does remove it using it's version.

      If you do wish to create a copy of this set (requires all entries in memory), the user may invoke entrySet().stream().collect(Collectors.toSet()) to copy the data locally. Then all operations on the resulting set will not require remote access, however updates will not be reflected from the remote cache.

      NOTE: this method returns a CloseableIteratorSet which requires the iterator, spliterator or stream returned from it to be closed. Failure to do so may cause additional resources to not be freed.

      Specified by:
      entrySet in interface Map<K,V>

    • entrySet

      CloseableIteratorSet<Map.Entry<K,V>> entrySet(IntSet segments)
      This method is identical to entrySet() except that it will only return entries that map to the given segments. Note that these segments will be determined by the remote server. Thus you should be aware of how many segments it has configured and hashing algorithm it is using. If the segments and hashing algorithm are not the same this method may return unexpected entries.
      Parameters:
      segments - the segments of entries to return - null means all available
      Returns:
      set containing entries that map to the given segments
      Since:
      9.4
      See Also:

    • putAll

      void putAll(Map<? extends K, ? extends V> map, long lifespan, TimeUnit unit)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAll in interface BasicCache<K,V>
      Parameters:
      map - map containing mappings to enter
      lifespan - lifespan of the entry. Negative values are interpreted as unlimited lifespan.
      unit - unit of measurement for the lifespan

    • putAll

      void putAll(Map<? extends K, ? extends V> map, long lifespan, TimeUnit lifespanUnit, long maxIdleTime, TimeUnit maxIdleTimeUnit)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAll in interface BasicCache<K,V>
      Parameters:
      map - map containing mappings to enter
      lifespan - lifespan of the entry. Negative values are interpreted 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
      See Also:

    • putAllAsync

      CompletableFuture<Void> putAllAsync(Map<? extends K, ? extends V> data)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAllAsync in interface AsyncCache<K,V>
      Parameters:
      data - to store
      Returns:
      a future containing a void return type
      See Also:

    • putAllAsync

      CompletableFuture<Void> putAllAsync(Map<? extends K, ? extends V> data, long lifespan, TimeUnit unit)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAllAsync in interface AsyncCache<K,V>
      Parameters:
      data - to store
      lifespan - lifespan of entry
      unit - time unit for lifespan
      Returns:
      a future containing a void return type
      See Also:

    • putAllAsync

      CompletableFuture<Void> putAllAsync(Map<? extends K, ? extends V> data, long lifespan, TimeUnit lifespanUnit, long maxIdle, TimeUnit maxIdleUnit)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAllAsync in interface AsyncCache<K,V>
      Parameters:
      data - to store
      lifespan - lifespan of entry
      lifespanUnit - time unit for lifespan
      maxIdle - the maximum amount of time this key is allowed to be idle for before it is considered as expired
      maxIdleUnit - time unit for max idle time
      Returns:
      a future containing a void return type
      See Also:

    • putAll

      void putAll(Map<? extends K, ? extends V> m)
      Adds or overrides each specified entry in the remote cache. This operation provides better performance than calling put() for each entry.
      Specified by:
      putAll in interface Map<K,V>
      See Also:

    • clientStatistics

      RemoteCacheClientStatisticsMXBean clientStatistics()
      Returns client-side statistics for this cache.

    • serverStatistics

      ServerStatistics serverStatistics()
      Returns server-side statistics for this cache.

    • serverStatisticsAsync

      CompletionStage<ServerStatistics> serverStatisticsAsync()
      Returns server-side statistics for this cache.

    • withFlags

      RemoteCache<K,V> withFlags(Flag... flags)
      Applies one or more Flags 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");
      Parameters:
      flags -
      Returns:
      a RemoteCache instance with the flag added if necessary

    • noFlags

      RemoteCache<K,V> noFlags()
      Resets all applied flags back to the defaults. Note that Flag.FORCE_RETURN_VALUE will be cleared as well even if it was set via configuration.
      Returns:
      a RemoteCache instance with no flags applied to it

    • flags

      Set<Flag> flags()
      Returns the flags set for this RemoteCache instance.
      Returns:
      set containing all Flag enum instances that are set for operations on this cache instance

    • getRemoteCacheContainer

      RemoteCacheContainer getRemoteCacheContainer()
      Returns the RemoteCacheContainer that created this cache.

    • getRemoteCacheManager

      @Deprecated(forRemoval=true) default RemoteCacheManager getRemoteCacheManager()
      Deprecated, for removal: This API element is subject to removal in a future version.
      Since 14.0. Use getRemoteCacheContainer() instead.
      Returns the RemoteCacheManager that created this cache.

    • getAll

      Map<K,V> getAll(Set<? extends K> keys)
      Retrieves all of the entries for the provided keys. A key will not be present in the resulting map if the entry was not found in the cache.
      Parameters:
      keys - The keys to find values for
      Returns:
      The entries that were present for the given keys

    • getProtocolVersion

      String getProtocolVersion()
      Returns the HotRod protocol version supported by this RemoteCache implementation

    • addClientListener

      void addClientListener(Object listener)
      Add a client listener to receive events that happen in the remote cache. The listener object must be annotated with @ClientListener annotation.

    • addClientListener

      void addClientListener(Object listener, Object[] filterFactoryParams, Object[] converterFactoryParams)
      Add a client listener to receive events that happen in the remote cache. The listener object must be annotated with @ClientListener annotation.

    • removeClientListener

      void removeClientListener(Object listener)
      Remove a previously added client listener. If the listener was not added before, this operation is a no-op.

    • execute

      default <T> T execute(String taskName)
      Executes a remote task without passing any parameters

    • execute

      <T> T execute(String taskName, Map<String,?> params)
      Executes a remote task passing a set of named parameters

    • execute

      default <T> T execute(String taskName, Map<String,?> params, Object key)
      Executes a remote task passing a set of named parameters, hinting that the task should be executed on the server that is expected to store given key. The key itself is not transferred to the server.

    • getCacheTopologyInfo

      CacheTopologyInfo getCacheTopologyInfo()
      Returns CacheTopologyInfo for this cache.

    • streaming

      StreamingRemoteCache<K> streaming()
      Returns a cache where values are manipulated using InputStream and OutputStream

    • withDataFormat

      <T,U> RemoteCache<T,U> withDataFormat(DataFormat dataFormat)
      Return a new instance of RemoteCache using the supplied DataFormat.

    • getDataFormat

      DataFormat getDataFormat()
      Return the currently DataFormat being used.

    • isTransactional

      boolean isTransactional()
      Returns:
      true if the cache can participate in a transaction, false otherwise.