Interface RemoteCache<K,​V>

  • All Superinterfaces:
    AsyncCache<K,​V>, BasicCache<K,​V>, java.util.concurrent.ConcurrentMap<K,​V>, Lifecycle, java.util.Map<K,​V>, TransactionalCache

    public interface RemoteCache<K,​V>
    extends BasicCache<K,​V>, TransactionalCache
    Provides remote reference to a Hot Rod server/cluster. It implements Cache, 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 Cache, 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 Cache 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 mean time, 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 Detail

      • 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:
        VersionedValue, getVersioned(Object)
      • remove

        V remove​(java.lang.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. 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>
      • remove

        boolean remove​(java.lang.Object key,
                       java.lang.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).

      • replace

        boolean replace​(K key,
                        V oldValue,
                        V value,
                        long lifespan,
                        java.util.concurrent.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,
                        java.util.concurrent.TimeUnit lifespanUnit,
                        long maxIdleTime,
                        java.util.concurrent.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

        java.util.concurrent.CompletableFuture<java.lang.Boolean> removeWithVersionAsync​(K key,
                                                                                         long version)
        See Also:
        remove(Object, Object)
      • 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:
        getVersioned(Object), VersionedValue
      • 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,
                                   java.util.concurrent.TimeUnit lifespanTimeUnit,
                                   long maxIdle,
                                   java.util.concurrent.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

        java.util.concurrent.CompletableFuture<java.lang.Boolean> replaceWithVersionAsync​(K key,
                                                                                          V newValue,
                                                                                          long version,
                                                                                          int lifespanSeconds)
        See Also:
        replaceWithVersion(Object, Object, long)
      • replaceWithVersionAsync

        java.util.concurrent.CompletableFuture<java.lang.Boolean> replaceWithVersionAsync​(K key,
                                                                                          V newValue,
                                                                                          long version,
                                                                                          int lifespanSeconds,
                                                                                          int maxIdleSeconds)
        See Also:
        replaceWithVersion(Object, Object, long)
      • retrieveEntries

        CloseableIterator<java.util.Map.Entry<java.lang.Object,​java.lang.Object>> retrieveEntries​(java.lang.String filterConverterFactory,
                                                                                                        java.lang.Object[] filterConverterParams,
                                                                                                        java.util.Set<java.lang.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
      • retrieveEntriesByQuery

        CloseableIterator<java.util.Map.Entry<java.lang.Object,​java.lang.Object>> retrieveEntriesByQuery​(Query filterQuery,
                                                                                                               java.util.Set<java.lang.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
      • retrieveEntriesWithMetadata

        CloseableIterator<java.util.Map.Entry<java.lang.Object,​MetadataValue<java.lang.Object>>> retrieveEntriesWithMetadata​(java.util.Set<java.lang.Integer> segments,
                                                                                                                                   int batchSize)
        Retrieve entries with metadata information
      • getWithMetadata

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

        java.util.concurrent.CompletableFuture<MetadataValue<V>> getWithMetadataAsync​(K key)
        Asynchronously returns the MetadataValue associated to the supplied key param, or null if it doesn't exist.
      • 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:
        keySet()
      • 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:
        values()
      • entrySet

        CloseableIteratorSet<java.util.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:
        entrySet()
      • putAll

        void putAll​(java.util.Map<? extends K,​? extends V> map,
                    long lifespan,
                    java.util.concurrent.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​(java.util.Map<? extends K,​? extends V> map,
                    long lifespan,
                    java.util.concurrent.TimeUnit lifespanUnit,
                    long maxIdleTime,
                    java.util.concurrent.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:
        putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
      • putAllAsync

        java.util.concurrent.CompletableFuture<java.lang.Void> putAllAsync​(java.util.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:
        putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
      • putAllAsync

        java.util.concurrent.CompletableFuture<java.lang.Void> putAllAsync​(java.util.Map<? extends K,​? extends V> data,
                                                                           long lifespan,
                                                                           java.util.concurrent.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:
        putAll(java.util.Map, long, java.util.concurrent.TimeUnit)
      • putAllAsync

        java.util.concurrent.CompletableFuture<java.lang.Void> putAllAsync​(java.util.Map<? extends K,​? extends V> data,
                                                                           long lifespan,
                                                                           java.util.concurrent.TimeUnit lifespanUnit,
                                                                           long maxIdle,
                                                                           java.util.concurrent.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(java.util.Map, long, java.util.concurrent.TimeUnit)
      • clientStatistics

        org.infinispan.client.hotrod.jmx.RemoteCacheClientStatisticsMXBean clientStatistics()
        Returns client-side statistics for this cache.
      • serverStatistics

        ServerStatistics serverStatistics()
        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:
        the current RemoteCache instance to continue running operations on.
      • getAll

        java.util.Map<K,​V> getAll​(java.util.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

        java.lang.String getProtocolVersion()
        Returns the HotRod protocol version supported by this RemoteCache implementation
      • addClientListener

        void addClientListener​(java.lang.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​(java.lang.Object listener,
                               java.lang.Object[] filterFactoryParams,
                               java.lang.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​(java.lang.Object listener)
        Remove a previously added client listener. If the listener was not added before, this operation is a no-op.
      • getListeners

        @Deprecated
        java.util.Set<java.lang.Object> getListeners()
        Deprecated.
        Since 10.0, with no replacement
        Returns a set with all the listeners registered by this client for the given cache.
      • execute

        <T> T execute​(java.lang.String taskName,
                      java.util.Map<java.lang.String,​?> params)
        Executes a remote task passing a set of named parameters
      • execute

        default <T> T execute​(java.lang.String taskName,
                              java.util.Map<java.lang.String,​?> params,
                              java.lang.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.
      • streaming

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

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