io.micronaut.configuration.lettuce.cache

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>, 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

Author:

Graeme Rocher, Kovalov Illia

Field Summary

Fields

Modifier and Type	Field and Description
protected java.lang.Long	expireAfterAccess
protected ExpirationAfterWritePolicy	expireAfterWritePolicy
static java.lang.String	INVALID_REDIS_CONNECTION_MESSAGE
protected io.micronaut.core.serialize.ObjectSerializer	keySerializer
protected RedisCacheConfiguration	redisCacheConfiguration
protected io.micronaut.core.serialize.ObjectSerializer	valueSerializer

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and 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 io.micronaut.cache.SyncCache

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

Methods inherited from interface io.micronaut.cache.Cache

getCacheInfo, getName, getNativeCache

Methods inherited from interface java.lang.AutoCloseable

close

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

redisCacheConfiguration

protected final RedisCacheConfiguration redisCacheConfiguration

expireAfterWritePolicy

protected final ExpirationAfterWritePolicy expireAfterWritePolicy

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