Package com.axelor.cache

Interface AxelorCache<K,V>

Type Parameters:
K - the type of keys maintained by this cache
V - the type of mapped values
All Superinterfaces:
AutoCloseable, Closeable, Iterable<Map.Entry<K,V>>
All Known Implementing Classes:
AbstractRedissonCache, CaffeineCache, CaffeineLoadingCache, RedissonCache, RedissonCacheNative
public interface AxelorCache<K,V> extends Iterable<Map.Entry<K,V>>, Closeable
Cache interface for wrapping different cache implementations

This interface provides fast and simple operations. For full map capabilities, use asMap().

  • Method Summary

    Modifier and Type
    Method
    Description
    ConcurrentMap<K,V>
    asMap()
    Returns a view of the entries stored in this cache as a thread-safe map.
    default void
    cleanUp()
    Performs any pending maintenance operations needed by the cache.
    default void
    close()
    Signals that the cache is no longer in use and releases any resources.
    long
    estimatedSize()
    Returns the approximate number of entries in this cache.
    V
    get(K key)
    Returns the value associated with the key in this cache, obtaining that value from the CacheLoader if defined and if necessary, otherwise returns null if there is no cached value for the key.
    default V
    get(K key, Function<? super K,? extends V> mappingFunction)
    Returns the value associated with the key in this cache, obtaining that value from the mappingFunction if necessary.
    default Map<K,V>
    getAll(Set<K> keys)
    Returns a map of the values associated with the keys in this cache, using CacheLoader if defined and if necessary.
    Lock
    getLock(K key)
    Returns key-specific lock for this cache.
    void
    invalidate(K key)
    Discards any cached value for the key.
    void
    invalidateAll()
    Discards all cached values.
    default Iterator<Map.Entry<K,V>>
    iterator()
    Returns an iterator over the entries in this cache.
    void
    put(K key, V value)
    Associates the value with the key.
    default void
    putAll(Map<? extends K,? extends V> map)
    Copies all of the mappings from the specified map to the cache.

    Methods inherited from interface java.lang.Iterable

    forEach, spliterator

  • Method Details

    • get

      @Nullable V get(K key)
      Returns the value associated with the key in this cache, obtaining that value from the CacheLoader if defined and if necessary, otherwise returns null if there is no cached value for the key.
      Parameters:
      key - the key whose associated value is to be returned
      Returns:
      the value to which the specified key is mapped, or null if this map contains no mapping for the key

    • get

      @Nullable default V get(K key, Function<? super K,? extends V> mappingFunction)
      Returns the value associated with the key in this cache, obtaining that value from the mappingFunction if necessary.

      Note that the mappingFunction is called only if there is no cached value after calling the cache loader if defined.

      Parameters:
      key - the key with which the specified value is to be associated
      mappingFunction - the function to compute a value
      Returns:
      the current (existing or computed) value associated with the specified key, or null if the computed value is null

    • getAll

      default Map<K,V> getAll(Set<K> keys)
      Returns a map of the values associated with the keys in this cache, using CacheLoader if defined and if necessary.
      Parameters:
      keys - the keys whose associated values are to be returned
      Returns:
      an unmodifiable mapping of keys to values for the specified keys in this cache

    • put

      void put(K key, V value)
      Associates the value with the key.
      Parameters:
      key - key with which the specified value is to be associated
      value - value to be associated with the specified key

    • putAll

      default void putAll(Map<? extends K,? extends V> map)
      Copies all of the mappings from the specified map to the cache.

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

      Parameters:
      map - the mappings to be stored in this cache

    • invalidate

      void invalidate(K key)
      Discards any cached value for the key.
      Parameters:
      key - the key whose mapping is to be removed from the cache

    • invalidateAll

      void invalidateAll()
      Discards all cached values.

    • estimatedSize

      long estimatedSize()
      Returns the approximate number of entries in this cache. The actual count may differ because of concurrent updates and pending invalidations.
      Returns:
      the estimated size of the cache

    • asMap

      ConcurrentMap<K,V> asMap()
      Returns a view of the entries stored in this cache as a thread-safe map. Modifications made to the map directly affect the cache.

      Note that if the cache has a cache loader, it will be used. This differs from Caffeine's Cache#asMap() and is designed to match Redisson RMap behavior.

      Returns:
      a thread-safe view of this cache supporting ConcurrentMap operations

    • iterator

      default Iterator<Map.Entry<K,V>> iterator()
      Returns an iterator over the entries in this cache.
      Specified by:
      iterator in interface Iterable<K>
      Returns:
      an iterator over the entries in this cache

    • close

      default void close()
      Signals that the cache is no longer in use and releases any resources.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable

    • cleanUp

      default void cleanUp()
      Performs any pending maintenance operations needed by the cache. Exactly which activities are performed -- if any -- is implementation-dependent.

    • getLock

      Lock getLock(K key)
      Returns key-specific lock for this cache.
      Parameters:
      key -
      Returns:
      reentrant lock