Class AbstractRedisCache<C>

java.lang.Object
io.micronaut.configuration.lettuce.cache.AbstractRedisCache<C>
Type Parameters:
C - – The native cache implementation
All Implemented Interfaces:
io.micronaut.cache.Cache<C>, io.micronaut.cache.SyncCache<C>, AutoCloseable
Direct Known Subclasses:
RedisCache, RedisConnectionPoolCache
public abstract class AbstractRedisCache<C> extends Object implements io.micronaut.cache.SyncCache<C>, AutoCloseable
An abstract class implementing SyncCache for the redis.
Since:
5.3.0
Author:
Graeme Rocher, Kovalov Illia

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    protected final Long
    expireAfterAccess
     
    protected final ExpirationAfterWritePolicy
    expireAfterWritePolicy
     
    static final String
    INVALID_REDIS_CONNECTION_MESSAGE
     
    protected final Long
    invalidateScanCount
     
    protected final String
    keyPrefix
     
    protected final io.micronaut.core.serialize.ObjectSerializer
    keySerializer
     
    protected final RedisCacheConfiguration
    redisCacheConfiguration
     
    protected final io.micronaut.core.serialize.ObjectSerializer
    valueSerializer
     

  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    AbstractRedisCache(DefaultRedisCacheConfiguration defaultRedisCacheConfiguration, RedisCacheConfiguration redisCacheConfiguration, io.micronaut.core.convert.ConversionService conversionService, io.micronaut.context.BeanLocator beanLocator)
     

  • Method Summary

    Modifier and Type
    Method
    Description
    protected CompletionStage<List<byte[]>>
    allKeys(io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]> redisKeyCommands, io.lettuce.core.ScanCursor initialCursor, io.lettuce.core.ScanArgs args)
    Collect the keys matching the given pattern using the provided async commands.
    protected CompletionStage<List<byte[]>>
    allKeys(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection, io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
    Collect the keys matching the given pattern for the current connection.
    protected List<byte[]>
    allKeys(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
    Collect the keys matching the given pattern for the current connection.
    protected List<byte[]>
    allKeys(io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
    Collect the keys matching the given pattern using the provided sync commands.
    protected final <T> T
    executeInsert(Supplier<T> supplier)
    Execute a cache insert with the configured retry count.
    protected final <T> CompletionStage<T>
    executeInsertAsync(Supplier<? extends CompletionStage<T>> supplier)
    Execute an asynchronous cache insert with the configured retry count.
    protected final <T> T
    executeRead(Supplier<T> supplier)
    Execute a cache read with the configured retry count.
    protected final <T> CompletionStage<T>
    executeReadAsync(Supplier<? extends CompletionStage<T>> supplier)
    Execute an asynchronous cache read with the configured retry count.
    protected <T> T
    get(byte[] key, io.micronaut.core.type.Argument<T> requiredType, Supplier<T> supplier, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> commands)
     
    <T> Optional<T>
    get(Object key, io.micronaut.core.type.Argument<T> requiredType)
     
    protected String
    getKeysPattern()
     
    protected io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]>
    getRedisKeyAsyncCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
     
    protected io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]>
    getRedisKeyCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
     
    protected io.lettuce.core.api.async.RedisStringAsyncCommands<byte[],byte[]>
    getRedisStringAsyncCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
     
    protected io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]>
    getRedisStringCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
     
    protected abstract <T> Optional<T>
    getValue(io.micronaut.core.type.Argument<T> requiredType, byte[] serializedKey)
     
    protected <K,T> Map<K,T>
    getValues(@NonNull Collection<K> keys, @NonNull io.micronaut.core.type.Argument<T> requiredType, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
    Resolve the values for the given keys and convert them to the required type.
    protected void
    invalidateValues(@NonNull Collection<?> keys, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
    Invalidate the values for the given keys.
    void
    put(Object key, Object value)
     
    <T> Optional<T>
    putIfAbsent(Object key, T value)
     
    protected <T> void
    putValue(byte[] serializedKey, Optional<byte[]> serialized, ExpirationAfterWritePolicy policy, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, T value)
     
    protected abstract <T> void
    putValue(byte[] serializedKey, T value)
     
    protected void
    putValues(@NonNull Map<?,?> values, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
    Cache the specified values in bulk.
    protected byte[]
    serializeKey(Object key)
    Serialize the key.

    Methods inherited from class Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    Methods inherited from interface AutoCloseable

    close

    Methods inherited from interface io.micronaut.cache.Cache

    getCacheInfo, getName, getNativeCache

    Methods inherited from interface io.micronaut.cache.SyncCache

    async, get, get, get, getExecutorService, invalidate, invalidateAll, putIfAbsent

  • Field Details

    • INVALID_REDIS_CONNECTION_MESSAGE

      public static final String INVALID_REDIS_CONNECTION_MESSAGE
      See Also:

    • keySerializer

      protected final io.micronaut.core.serialize.ObjectSerializer keySerializer

    • valueSerializer

      protected final io.micronaut.core.serialize.ObjectSerializer valueSerializer

    • redisCacheConfiguration

      protected final RedisCacheConfiguration redisCacheConfiguration

    • expireAfterWritePolicy

      protected final ExpirationAfterWritePolicy expireAfterWritePolicy

    • expireAfterAccess

      protected final Long expireAfterAccess

    • invalidateScanCount

      protected final Long invalidateScanCount

    • keyPrefix

      protected final String keyPrefix

  • Constructor Details

    • AbstractRedisCache

      protected AbstractRedisCache(DefaultRedisCacheConfiguration defaultRedisCacheConfiguration, RedisCacheConfiguration redisCacheConfiguration, io.micronaut.core.convert.ConversionService conversionService, io.micronaut.context.BeanLocator beanLocator)

  • Method Details

    • get

      public <T> Optional<T> get(Object key, io.micronaut.core.type.Argument<T> requiredType)
      Specified by:
      get in interface io.micronaut.cache.SyncCache<C>

    • put

      public void put(Object key, Object value)
      Specified by:
      put in interface io.micronaut.cache.SyncCache<C>

    • putIfAbsent

      public <T> Optional<T> putIfAbsent(Object key, T value)
      Specified by:
      putIfAbsent in interface io.micronaut.cache.SyncCache<C>

    • get

      protected <T> T get(byte[] key, io.micronaut.core.type.Argument<T> requiredType, Supplier<T> supplier, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> commands)
      Type Parameters:
      T - concrete type
      Parameters:
      key -
      requiredType -
      supplier -
      commands -
      Returns:
      value from the cache

    • getRedisStringAsyncCommands

      protected io.lettuce.core.api.async.RedisStringAsyncCommands<byte[],byte[]> getRedisStringAsyncCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
      Parameters:
      connection -
      Returns:
      RedisStringAsyncCommands

    • getRedisKeyAsyncCommands

      protected io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]> getRedisKeyAsyncCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
      Parameters:
      connection -
      Returns:
      RedisKeyAsyncCommands

    • getRedisStringCommands

      protected io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> getRedisStringCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
      Parameters:
      connection -
      Returns:
      RedisStringCommands

    • getRedisKeyCommands

      protected io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> getRedisKeyCommands(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection)
      Parameters:
      connection -
      Returns:
      RedisKeyCommands

    • allKeys

      protected List<byte[]> allKeys(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
      Collect the keys matching the given pattern for the current connection.
      Parameters:
      connection - The connection
      redisKeyCommands - The redis key commands
      pattern - The pattern to match
      Returns:
      A list of matching keys

    • allKeys

      protected CompletionStage<List<byte[]>> allKeys(io.lettuce.core.api.StatefulConnection<byte[],byte[]> connection, io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
      Collect the keys matching the given pattern for the current connection.
      Parameters:
      connection - The connection
      redisKeyCommands - The redis key commands
      pattern - The pattern to match
      Returns:
      A stage that completes with the matching keys

    • allKeys

      protected List<byte[]> allKeys(io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, byte[] pattern)
      Collect the keys matching the given pattern using the provided sync commands.
      Parameters:
      redisKeyCommands - The redis key commands
      pattern - The pattern to match
      Returns:
      A list of matching keys

    • allKeys

      protected CompletionStage<List<byte[]>> allKeys(io.lettuce.core.api.async.RedisKeyAsyncCommands<byte[],byte[]> redisKeyCommands, io.lettuce.core.ScanCursor initialCursor, io.lettuce.core.ScanArgs args)
      Collect the keys matching the given pattern using the provided async commands.
      Parameters:
      redisKeyCommands - The redis key commands
      initialCursor - The initial cursor
      args - The scan arguments
      Returns:
      A stage that completes with the matching keys

    • getValue

      protected abstract <T> Optional<T> getValue(io.micronaut.core.type.Argument<T> requiredType, byte[] serializedKey)
      Type Parameters:
      T - concrete type
      Parameters:
      requiredType -
      serializedKey -
      Returns:
      An Optional Value

    • putValue

      protected abstract <T> void putValue(byte[] serializedKey, T value)
      Type Parameters:
      T - concrete type
      Parameters:
      serializedKey -
      value -

    • putValue

      protected <T> void putValue(byte[] serializedKey, Optional<byte[]> serialized, ExpirationAfterWritePolicy policy, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands, T value)
      Type Parameters:
      T - concrete type
      Parameters:
      serializedKey -
      serialized -
      policy -
      redisStringCommands -
      redisKeyCommands -
      value -

    • getValues

      protected <K,T> Map<K,T> getValues(@NonNull Collection<K> keys, @NonNull io.micronaut.core.type.Argument<T> requiredType, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
      Resolve the values for the given keys and convert them to the required type.
      Type Parameters:
      K - The type of the unserialized key
      T - The concrete type
      Parameters:
      keys - The cache keys
      requiredType - The required type
      redisStringCommands - The redis string commands
      redisKeyCommands - The redis key commands
      Returns:
      An ordered map containing all requested keys in the original order

    • putValues

      protected void putValues(@NonNull Map<?,?> values, io.lettuce.core.api.sync.RedisStringCommands<byte[],byte[]> redisStringCommands, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
      Cache the specified values in bulk.
      Parameters:
      values - The values to store
      redisStringCommands - The redis string commands
      redisKeyCommands - The redis key commands

    • invalidateValues

      protected void invalidateValues(@NonNull Collection<?> keys, io.lettuce.core.api.sync.RedisKeyCommands<byte[],byte[]> redisKeyCommands)
      Invalidate the values for the given keys.
      Parameters:
      keys - The keys to invalidate
      redisKeyCommands - The redis key commands

    • getKeysPattern

      protected String getKeysPattern()
      Returns:
      The default keys pattern.

    • serializeKey

      protected byte[] serializeKey(Object key)
      Serialize the key.
      Parameters:
      key - The key
      Returns:
      bytes of the object

    • executeRead

      protected final <T> T executeRead(Supplier<T> supplier)
      Execute a cache read with the configured retry count.
      Type Parameters:
      T - The result type
      Parameters:
      supplier - The read operation
      Returns:
      The operation result

    • executeInsert

      protected final <T> T executeInsert(Supplier<T> supplier)
      Execute a cache insert with the configured retry count.
      Type Parameters:
      T - The result type
      Parameters:
      supplier - The insert operation
      Returns:
      The operation result

    • executeReadAsync

      protected final <T> CompletionStage<T> executeReadAsync(Supplier<? extends CompletionStage<T>> supplier)
      Execute an asynchronous cache read with the configured retry count.
      Type Parameters:
      T - The result type
      Parameters:
      supplier - The read operation
      Returns:
      The operation stage

    • executeInsertAsync

      protected final <T> CompletionStage<T> executeInsertAsync(Supplier<? extends CompletionStage<T>> supplier)
      Execute an asynchronous cache insert with the configured retry count.
      Type Parameters:
      T - The result type
      Parameters:
      supplier - The insert operation
      Returns:
      The operation stage