io.micronaut.configuration.lettuce.cache

Class RedisCache

java.lang.Object

io.micronaut.configuration.lettuce.cache.RedisCache

All Implemented Interfaces:

io.micronaut.cache.Cache<io.lettuce.core.api.StatefulConnection<?,?>>, io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

@EachBean(value=RedisCacheConfiguration.class)
public class RedisCache
extends Object
implements io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

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.

Constructor Summary

Constructors

Constructor and Description
RedisCache(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<?,?>>	async()
protected AsyncCacheCommands	asyncCommands(io.lettuce.core.api.StatefulConnection<String,String> connection) Get the asynchronous commands for the stateful connection.
<T> Optional<T>	get(Object key, io.micronaut.core.type.Argument<T> requiredType)
<T> T	get(Object key, io.micronaut.core.type.Argument<T> requiredType, Supplier<T> supplier)
protected String	getKeysPattern()
String	getName()
io.lettuce.core.api.StatefulConnection<?,?>	getNativeCache()
protected <T> Optional<T>	getValue(io.micronaut.core.type.Argument<T> requiredType, SyncCacheCommands commands, byte[] serializedKey) Get the value based on the parameters.
void	invalidate(Object key)
void	invalidateAll()
void	put(Object key, Object value)
<T> Optional<T>	putIfAbsent(Object key, T value)
protected <T> void	putValue(SyncCacheCommands commands, byte[] serializedKey, T value) Place the value in the cache.
protected byte[]	serializeKey(Object key) Serialize the key.
protected SyncCacheCommands	syncCommands(io.lettuce.core.api.StatefulConnection<String,String> connection) Get the synchronous commands for the stateful connection.

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

Constructor Detail

RedisCache

public RedisCache(RedisCacheConfiguration redisCacheConfiguration,
                  io.micronaut.core.convert.ConversionService<?> conversionService,
                  io.micronaut.context.BeanLocator beanLocator)

Creates a new redis cache for the given arguments.

Parameters:

redisCacheConfiguration - The configuration

conversionService - The conversion service

beanLocator - The bean locator used to discover the redis connection from the configuration

Method Detail

getName

public String getName()

Specified by:

getName in interface io.micronaut.cache.Cache<io.lettuce.core.api.StatefulConnection<?,?>>

getNativeCache

public io.lettuce.core.api.StatefulConnection<?,?> getNativeCache()

Specified by:

getNativeCache in interface io.micronaut.cache.Cache<io.lettuce.core.api.StatefulConnection<?,?>>

get

public <T> 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<?,?>>

get

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

Specified by:

get in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

putIfAbsent

public <T> Optional<T> putIfAbsent(Object key,
                                   T value)

Specified by:

putIfAbsent in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

put

public void put(Object key,
                Object value)

Specified by:

put in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

invalidate

public void invalidate(Object key)

Specified by:

invalidate in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

invalidateAll

public void invalidateAll()

Specified by:

invalidateAll in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

async

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

Specified by:

async in interface io.micronaut.cache.SyncCache<io.lettuce.core.api.StatefulConnection<?,?>>

getValue

protected <T> Optional<T> getValue(io.micronaut.core.type.Argument<T> requiredType,
                                   SyncCacheCommands commands,
                                   byte[] serializedKey)

Get the value based on the parameters.

Type Parameters:

T - type of the argument

Parameters:

requiredType - requiredType

commands - commands

serializedKey - serializedKey

Returns:

value

getKeysPattern

protected String getKeysPattern()

Returns:

The default keys pattern.

putValue

protected <T> void putValue(SyncCacheCommands commands,
                            byte[] serializedKey,
                            T value)

Place the value in the cache.

Type Parameters:

T - type of the value

Parameters:

commands - commands

serializedKey - serializedKey

value - value

serializeKey

protected byte[] serializeKey(Object key)

Serialize the key.

Parameters:

key - The key

Returns:

bytes of the object

syncCommands

protected SyncCacheCommands syncCommands(io.lettuce.core.api.StatefulConnection<String,String> connection)

Get the synchronous commands for the stateful connection.

Parameters:

connection - stateful connection

Returns:

commands

asyncCommands

protected AsyncCacheCommands asyncCommands(io.lettuce.core.api.StatefulConnection<String,String> connection)

Get the asynchronous commands for the stateful connection.

Parameters:

connection - stateful connection

Returns:

commands