io.micronaut.configuration.lettuce.cache

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[]>>, java.lang.AutoCloseable

@EachBean(value=RedisCacheConfiguration.class)
 @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

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	RedisCache.RedisAsyncCache Redis Async cache implementation.

Field Summary

Fields inherited from class io.micronaut.configuration.lettuce.cache.AbstractRedisCache

expireAfterAccess, expireAfterWritePolicy, INVALID_REDIS_CONNECTION_MESSAGE, keySerializer, redisCacheConfiguration, valueSerializer

Constructor Summary

Constructors

Constructor and Description
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.

Method Summary

Modifier and Type	Method and Description
io.micronaut.cache.AsyncCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>	async()
void	close()
<T> java.util.Optional<T>	get(java.lang.Object key, io.micronaut.core.type.Argument<T> requiredType)
<T> T	get(java.lang.Object key, io.micronaut.core.type.Argument<T> requiredType, java.util.function.Supplier<T> supplier)
protected java.lang.String	getKeysPattern()
java.lang.String	getName()
io.lettuce.core.api.StatefulConnection<byte[],byte[]>	getNativeCache()
protected <T> java.util.Optional<T>	getValue(io.micronaut.core.type.Argument<T> requiredType, byte[] serializedKey) Get the value based on the parameters.
void	invalidate(java.lang.Object key)
void	invalidateAll()
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, T value) Place the value in the cache.
protected byte[]	serializeKey(java.lang.Object key) Serialize the key.

Methods inherited from class io.micronaut.configuration.lettuce.cache.AbstractRedisCache

get, getRedisKeyAsyncCommands, getRedisKeyCommands, getRedisStringAsyncCommands, getRedisStringCommands, putValue

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.micronaut.cache.SyncCache

get, get, getExecutorService, putIfAbsent

Methods inherited from interface io.micronaut.cache.Cache

getCacheInfo

Constructor Detail

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 Detail

getName

public java.lang.String getName()

getNativeCache

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

get

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

invalidate

public void invalidate(java.lang.Object key)

invalidateAll

public void invalidateAll()

async

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

getValue

protected <T> java.util.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

@NonNull
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<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

Overrides:

get in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

put

public void put(java.lang.Object key,
                java.lang.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

@NonNull
public <T> java.util.Optional<T> putIfAbsent(java.lang.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 java.lang.String getKeysPattern()

Overrides:

getKeysPattern in class AbstractRedisCache<io.lettuce.core.api.StatefulConnection<byte[],byte[]>>

Returns:

The default keys pattern.

serializeKey

protected byte[] serializeKey(java.lang.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()