Package io.micronaut.configuration.lettuce.cache

Class AbstractRedisCache<C>

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

    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      protected <T> T get​(byte[] key, io.micronaut.core.type.Argument<T> requiredType, java.util.function.Supplier<T> supplier, io.lettuce.core.api.sync.RedisStringCommands<byte[],​byte[]> commands)  
      <T> java.util.Optional<T> get​(java.lang.Object key, io.micronaut.core.type.Argument<T> requiredType)  
      protected java.lang.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> java.util.Optional<T> getValue​(io.micronaut.core.type.Argument<T> requiredType, byte[] serializedKey)  
      void put​(java.lang.Object key, java.lang.Object value)  
      <T> java.util.Optional<T> putIfAbsent​(java.lang.Object key, T value)  
      protected <T> void putValue​(byte[] serializedKey, java.util.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 byte[] serializeKey​(java.lang.Object key)
      Serialize the key.

      • Methods inherited from class java.lang.Object

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

      • Methods inherited from interface java.lang.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 Detail

      • INVALID_REDIS_CONNECTION_MESSAGE

        public static final java.lang.String INVALID_REDIS_CONNECTION_MESSAGE
        See Also:
        Constant Field Values

      • keySerializer

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

      • valueSerializer

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

      • expireAfterAccess

        protected final java.lang.Long expireAfterAccess

    • Constructor Detail

      • AbstractRedisCache

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

    • Method Detail

      • get

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

      • put

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

      • putIfAbsent

        public <T> java.util.Optional<T> putIfAbsent​(java.lang.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,
                    java.util.function.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> java.util.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,
                            java.util.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 java.lang.String getKeysPattern()
        Returns:
        The default keys pattern.

      • serializeKey

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