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 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
  • 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 -
      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
    • getValue

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

      protected abstract <T> void putValue(byte[] serializedKey, T value)
      Type Parameters:
      T -
      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 -
      Parameters:
      serializedKey -
      serialized -
      policy -
      redisStringCommands -
      redisKeyCommands -
      value -
    • 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