Class RedisCache

java.lang.Object
io.micronaut.configuration.lettuce.cache.AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
io.micronaut.configuration.lettuce.cache.RedisCache
All Implemented Interfaces:
io.micronaut.cache.Cache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>, io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>, AutoCloseable
@EachBean(RedisCacheConfiguration.class) @Requires(property="redis.enabled",notEquals="false") @Requires(classes=io.micronaut.cache.SyncCache.class,property="redis.pool.enabled",defaultValue="false",notEquals="true") public class RedisCache extends AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
An implementation of SyncCache for Lettuce / Redis.
Since:
1.0
Author:
Graeme Rocher

  • Constructor Details

    • RedisCache

      public RedisCache(DefaultRedisCacheConfiguration defaultRedisCacheConfiguration, RedisCacheConfiguration redisCacheConfiguration, io.micronaut.core.convert.ConversionService conversionService, io.micronaut.context.BeanLocator beanLocator)
      Creates a new redis cache for the given arguments.
      Parameters:
      defaultRedisCacheConfiguration - The default configuration
      redisCacheConfiguration - The configuration
      conversionService - The conversion service
      beanLocator - The bean locator used to discover the redis connection from the configuration

  • Method Details

    • getName

      public String getName()

    • getNativeCache

      public io.lettuce.core.api.StatefulConnection<byte[],byte[]> getNativeCache()

    • get

      public <T> T get(Object key, io.micronaut.core.type.Argument<T> requiredType, Supplier<T> supplier)

    • getAll

      public <K> @NonNull Map<K,Object> getAll(@NonNull Collection<K> keys)
      Resolve the values for the given keys.
      Type Parameters:
      K - The key type
      Parameters:
      keys - The cache keys
      Returns:
      An ordered map containing all requested keys

    • getAll

      public <K,T> @NonNull Map<K,T> getAll(@NonNull Collection<K> keys, @NonNull io.micronaut.core.type.Argument<T> requiredType)
      Resolve the values for the given keys.
      Type Parameters:
      K - The key type
      T - The value type
      Parameters:
      keys - The cache keys
      requiredType - The required type
      Returns:
      An ordered map containing all requested keys

    • putAll

      public void putAll(@NonNull Map<?,?> values)
      Cache the specified values in bulk.
      Parameters:
      values - The values to cache

    • invalidate

      public void invalidate(Object key)

    • invalidateAllKeys

      public void invalidateAllKeys(@NonNull Collection<?> keys)
      Invalidate the values for the given keys.
      Parameters:
      keys - The keys to invalidate

    • invalidateAll

      public void invalidateAll()

    • async

      public io.micronaut.cache.AsyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>> async()

    • getValue

      protected <T> Optional<T> getValue(io.micronaut.core.type.Argument<T> requiredType, byte[] serializedKey)
      Get the value based on the parameters.
      Specified by:
      getValue in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Type Parameters:
      T - type of the argument
      Parameters:
      requiredType - requiredType
      serializedKey - serializedKey
      Returns:
      value

    • putValue

      protected <T> void putValue(byte[] serializedKey, T value)
      Place the value in the cache.
      Specified by:
      putValue in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Type Parameters:
      T - type of the value
      Parameters:
      serializedKey - serializedKey
      value - value

    • get

      public <T> @NonNull Optional<T> get(Object key, io.micronaut.core.type.Argument<T> requiredType)
      Specified by:
      get in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Overrides:
      get in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

    • put

      public void put(Object key, Object value)
      Specified by:
      put in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Overrides:
      put in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

    • putIfAbsent

      public <T> @NonNull Optional<T> putIfAbsent(Object key, T value)
      Specified by:
      putIfAbsent in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Overrides:
      putIfAbsent in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

    • getKeysPattern

      protected String getKeysPattern()
      Overrides:
      getKeysPattern in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Returns:
      The default keys pattern.

    • serializeKey

      protected byte[] serializeKey(Object key)
      Description copied from class: AbstractRedisCache
      Serialize the key.
      Overrides:
      serializeKey in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>
      Parameters:
      key - The key
      Returns:
      bytes of the object

    • close

      @PreDestroy public void close()