org.springframework.data.redis.connection.lettuce

Class LettuceConnection

java.lang.Object

org.springframework.data.redis.connection.AbstractRedisConnection

org.springframework.data.redis.connection.lettuce.LettuceConnection

All Implemented Interfaces:

AutoCloseable, DefaultedRedisConnection, RedisCommands, RedisConnection, RedisConnectionCommands, RedisGeoCommands, RedisHashCommands, RedisHyperLogLogCommands, RedisKeyCommands, RedisListCommands, RedisPubSubCommands, RedisScriptingCommands, RedisServerCommands, RedisSetCommands, RedisStreamCommands, RedisStringCommands, RedisTxCommands, RedisZSetCommands

Direct Known Subclasses:

LettuceClusterConnection

public class LettuceConnection
extends AbstractRedisConnection

RedisConnection implementation on top of Lettuce Redis client.

Author:

Costin Leau, Jennifer Hickey, Christoph Strobl, Thomas Darimont, David Liu, Mark Paluch, Ninad Divadkar, Tamil Selvan

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	LettuceConnection.PipeliningFlushPolicy Strategy interface to control pipelining flush behavior.
static interface	LettuceConnection.PipeliningFlushState State object associated with flushing of the currently ongoing pipeline.

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands

RedisStringCommands.BitOperation, RedisStringCommands.SetOption

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands

RedisListCommands.Position

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

RedisZSetCommands.Aggregate, RedisZSetCommands.Limit, RedisZSetCommands.Range, RedisZSetCommands.Tuple, RedisZSetCommands.Weights

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands

RedisServerCommands.MigrateOption, RedisServerCommands.ShutdownOption

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

RedisStreamCommands.XAddOptions, RedisStreamCommands.XClaimOptions, RedisStreamCommands.XPendingOptions

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands

RedisGeoCommands.DistanceUnit, RedisGeoCommands.GeoLocation<T>, RedisGeoCommands.GeoRadiusCommandArgs

Constructor Summary

Constructors

Constructor and Description
LettuceConnection(long timeout, io.lettuce.core.RedisClient client) Instantiates a new lettuce connection.
LettuceConnection(long timeout, io.lettuce.core.RedisClient client, LettucePool pool) Deprecated. since 2.0, use pooling via LettucePoolingClientConfiguration.
LettuceConnection(io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection, LettuceConnectionProvider connectionProvider, long timeout, int defaultDbIndex)
LettuceConnection(io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection, long timeout, io.lettuce.core.AbstractRedisClient client, LettucePool pool, int defaultDbIndex) Deprecated. since 2.0, use LettuceConnection(StatefulRedisConnection, LettuceConnectionProvider, long, int)
LettuceConnection(io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection, long timeout, io.lettuce.core.RedisClient client) Instantiates a new lettuce connection.
LettuceConnection(io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection, long timeout, io.lettuce.core.RedisClient client, LettucePool pool) Deprecated. since 2.0, use LettuceConnection(StatefulRedisConnection, LettuceConnectionProvider, long, int)

Method Summary

Modifier and Type	Method and Description
void	close() Closes (or quits) the connection.
List<Object>	closePipeline() Executes the commands in the pipeline and returns their result.
protected DataAccessException	convertLettuceAccessException(Exception ex)
void	discard() Discard all commands issued after RedisTxCommands.multi().
protected LettuceSubscription	doCreateSubscription(MessageListener listener, io.lettuce.core.pubsub.StatefulRedisPubSubConnection<byte[],byte[]> connection, LettuceConnectionProvider connectionProvider) Customization hook to create a LettuceSubscription.
protected io.lettuce.core.api.StatefulConnection<byte[],byte[]>	doGetAsyncDedicatedConnection()
byte[]	echo(byte[] message) Returns message via server roundtrip.
List<Object>	exec() Executes all queued commands in a transaction started with RedisTxCommands.multi().
Object	execute(String command, byte[]... args) 'Native' or 'raw' execution of the given command along-side the given arguments.
Object	execute(String command, io.lettuce.core.output.CommandOutput commandOutputTypeHint, byte[]... args) 'Native' or 'raw' execution of the given command along-side the given arguments.
RedisGeoCommands	geoCommands() Get RedisGeoCommands.
protected io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands<byte[],byte[]>	getAsyncDedicatedConnection()
protected io.lettuce.core.cluster.api.sync.RedisClusterCommands<byte[],byte[]>	getConnection()
io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands<byte[],byte[]>	getNativeConnection() Returns the native connection (the underlying library/driver object).
protected RedisSentinelConnection	getSentinelConnection(RedisNode sentinel) Get RedisSentinelCommands connected to given node.
Subscription	getSubscription() Returns the current subscription for this connection or null if the connection is not subscribed.
RedisHashCommands	hashCommands() Get RedisHashCommands.
RedisHyperLogLogCommands	hyperLogLogCommands() Get RedisHyperLogLogCommands.
protected boolean	isActive(RedisNode node) Check if node is active by sending ping.
boolean	isClosed() Indicates whether the underlying connection is closed or not.
boolean	isPipelined() Indicates whether the connection is currently pipelined or not.
boolean	isQueueing() Indicates whether the connection is in "queue"(or "MULTI") mode or not.
boolean	isSubscribed() Indicates whether the current connection is subscribed (to at least one channel) or not.
RedisKeyCommands	keyCommands() Get RedisKeyCommands.
RedisListCommands	listCommands() Get RedisListCommands.
void	multi() Mark the start of a transaction block.
void	openPipeline() Activates the pipeline mode for this connection.
String	ping() Test connection.
void	pSubscribe(MessageListener listener, byte[]... patterns) Subscribes the connection to all channels matching the given patterns.
Long	publish(byte[] channel, byte[] message) Publishes the given message to the given channel.
RedisScriptingCommands	scriptingCommands() Get RedisScriptingCommands.
void	select(int dbIndex) Select the DB with given positive dbIndex.
RedisServerCommands	serverCommands() Get RedisServerCommands.
RedisSetCommands	setCommands() Get RedisSetCommands.
void	setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults) Specifies if pipelined and transaction results should be converted to the expected data type.
void	setPipeliningFlushPolicy(LettuceConnection.PipeliningFlushPolicy pipeliningFlushPolicy) Configures the flushing policy when using pipelining.
RedisStreamCommands	streamCommands() Get RedisStreamCommands.
RedisStringCommands	stringCommands() Get RedisStringCommands.
void	subscribe(MessageListener listener, byte[]... channels) Subscribes the connection to the given channels.
protected io.lettuce.core.pubsub.StatefulRedisPubSubConnection<byte[],byte[]>	switchToPubSub() close() the current connection and open a new pub/sub connection to the Redis server.
void	unwatch() Flushes all the previously #watch(byte[]...) keys.
void	watch(byte[]... keys) Watch given keys for modifications during transaction started with RedisTxCommands.multi().
RedisZSetCommands	zSetCommands() Get RedisZSetCommands.

Methods inherited from class org.springframework.data.redis.connection.AbstractRedisConnection

getSentinelConnection, hasRedisSentinelConfigured, setSentinelConfiguration

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.springframework.data.redis.connection.DefaultedRedisConnection

append, bgReWriteAof, bgSave, bgWriteAof, bitCount, bitCount, bitField, bitOp, bitPos, bLPop, bRPop, bRPopLPush, dbSize, decr, decrBy, del, dump, encodingOf, eval, evalSha, evalSha, exists, exists, expire, expireAt, flushAll, flushDb, geoAdd, geoAdd, geoAdd, geoDist, geoDist, geoHash, geoPos, geoRadius, geoRadius, geoRadiusByMember, geoRadiusByMember, geoRemove, get, getBit, getClientList, getClientName, getConfig, getRange, getSet, hDel, hExists, hGet, hGetAll, hIncrBy, hIncrBy, hKeys, hLen, hMGet, hMSet, hScan, hSet, hSetNX, hStrLen, hVals, idletime, incr, incrBy, incrBy, info, info, keys, killClient, lastSave, lIndex, lInsert, lLen, lPop, lPush, lPushX, lRange, lRem, lSet, lTrim, mGet, migrate, migrate, move, mSet, mSetNX, persist, pExpire, pExpireAt, pfAdd, pfCount, pfMerge, pSetEx, pTtl, pTtl, randomKey, refcount, rename, renameNX, resetConfigStats, restore, rPop, rPopLPush, rPush, rPushX, sAdd, save, scan, sCard, scriptExists, scriptFlush, scriptKill, scriptLoad, sDiff, sDiffStore, set, set, setBit, setClientName, setConfig, setEx, setNX, setRange, shutdown, shutdown, sInter, sInterStore, sIsMember, slaveOf, slaveOfNoOne, sMembers, sMove, sort, sort, sPop, sPop, sRandMember, sRandMember, sRem, sScan, strLen, sUnion, sUnionStore, time, touch, ttl, ttl, type, unlink, xAck, xAdd, xClaim, xClaimJustId, xDel, xGroupCreate, xGroupCreate, xGroupDelConsumer, xGroupDestroy, xInfo, xInfoConsumers, xInfoGroups, xLen, xPending, xPending, xRange, xRange, xRead, xRead, xReadGroup, xReadGroup, xRevRange, xRevRange, xTrim, zAdd, zAdd, zCard, zCount, zCount, zIncrBy, zInterStore, zInterStore, zInterStore, zRange, zRangeByLex, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScoreWithScores, zRangeWithScores, zRank, zRem, zRemRange, zRemRangeByScore, zRemRangeByScore, zRevRange, zRevRangeByScore, zRevRangeByScoreWithScores, zRevRangeWithScores, zRevRank, zScan, zScore, zUnionStore, zUnionStore, zUnionStore

Methods inherited from interface org.springframework.data.redis.connection.RedisKeyCommands

restore

Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands

bitPos

Methods inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByLex, zRangeByLex, zRangeByScore, zRangeByScore, zRangeByScore, zRangeByScoreWithScores, zRangeByScoreWithScores, zRangeByScoreWithScores, zRevRangeByScore, zRevRangeByScore, zRevRangeByScore, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores, zRevRangeByScoreWithScores

Methods inherited from interface org.springframework.data.redis.connection.RedisStreamCommands

xAck, xAdd, xAdd, xClaim, xDel, xGroupDelConsumer, xPending, xPending, xPending, xPending, xPending

Methods inherited from interface org.springframework.data.redis.connection.RedisGeoCommands

geoAdd, geoRadiusByMember

Constructor Detail

LettuceConnection

public LettuceConnection(long timeout,
                         io.lettuce.core.RedisClient client)

Instantiates a new lettuce connection.

Parameters:

timeout - The connection timeout (in milliseconds)

client - The RedisClient to use when instantiating a native connection

LettuceConnection

@Deprecated
public LettuceConnection(long timeout,
                                     io.lettuce.core.RedisClient client,
                                     LettucePool pool)

Deprecated. since 2.0, use pooling via LettucePoolingClientConfiguration.

Instantiates a new lettuce connection.

Parameters:

timeout - The connection timeout (in milliseconds) * @param client The RedisClient to use when instantiating a pub/sub connection

pool - The connection pool to use for all other native connections

LettuceConnection

public LettuceConnection(@Nullable
                         io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection,
                         long timeout,
                         io.lettuce.core.RedisClient client)

Instantiates a new lettuce connection.

Parameters:

sharedConnection - A native connection that is shared with other LettuceConnections. Will not be used for transactions or blocking operations

timeout - The connection timeout (in milliseconds)

client - The RedisClient to use when making pub/sub, blocking, and tx connections

LettuceConnection

@Deprecated
public LettuceConnection(@Nullable
                                     io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection,
                                     long timeout,
                                     io.lettuce.core.RedisClient client,
                                     @Nullable
                                     LettucePool pool)

Deprecated. since 2.0, use LettuceConnection(StatefulRedisConnection, LettuceConnectionProvider, long, int)

Instantiates a new lettuce connection.

Parameters:

sharedConnection - A native connection that is shared with other LettuceConnections. Should not be used for transactions or blocking operations

timeout - The connection timeout (in milliseconds)

client - The RedisClient to use when making pub/sub connections

pool - The connection pool to use for blocking and tx operations

LettuceConnection

@Deprecated
public LettuceConnection(@Nullable
                                     io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection,
                                     long timeout,
                                     @Nullable
                                     io.lettuce.core.AbstractRedisClient client,
                                     @Nullable
                                     LettucePool pool,
                                     int defaultDbIndex)

Deprecated. since 2.0, use LettuceConnection(StatefulRedisConnection, LettuceConnectionProvider, long, int)

Parameters:

sharedConnection - A native connection that is shared with other LettuceConnections. Should not be used for transactions or blocking operations.

timeout - The connection timeout (in milliseconds)

client - The RedisClient to use when making pub/sub connections.

pool - The connection pool to use for blocking and tx operations.

defaultDbIndex - The db index to use along with RedisClient when establishing a dedicated connection.

Since:

1.7

LettuceConnection

public LettuceConnection(@Nullable
                         io.lettuce.core.api.StatefulRedisConnection<byte[],byte[]> sharedConnection,
                         LettuceConnectionProvider connectionProvider,
                         long timeout,
                         int defaultDbIndex)

Parameters:

sharedConnection - A native connection that is shared with other LettuceConnections. Should not be used for transactions or blocking operations.

connectionProvider - connection provider to obtain and release native connections.

timeout - The connection timeout (in milliseconds)

defaultDbIndex - The db index to use along with RedisClient when establishing a dedicated connection.

Since:

2.0

Method Detail

convertLettuceAccessException

protected DataAccessException convertLettuceAccessException(Exception ex)

geoCommands

public RedisGeoCommands geoCommands()

Description copied from interface: RedisConnection

Get RedisGeoCommands.

Returns:

never null.

hashCommands

public RedisHashCommands hashCommands()

Description copied from interface: RedisConnection

Get RedisHashCommands.

Returns:

never null.

hyperLogLogCommands

public RedisHyperLogLogCommands hyperLogLogCommands()

Description copied from interface: RedisConnection

Get RedisHyperLogLogCommands.

Returns:

never null.

keyCommands

public RedisKeyCommands keyCommands()

Description copied from interface: RedisConnection

Get RedisKeyCommands.

Returns:

never null.

listCommands

public RedisListCommands listCommands()

Description copied from interface: RedisConnection

Get RedisListCommands.

Returns:

never null.

setCommands

public RedisSetCommands setCommands()

Description copied from interface: RedisConnection

Get RedisSetCommands.

Returns:

never null.

scriptingCommands

public RedisScriptingCommands scriptingCommands()

Description copied from interface: RedisConnection

Get RedisScriptingCommands.

Returns:

never null.

streamCommands

public RedisStreamCommands streamCommands()

Description copied from interface: RedisConnection

Get RedisStreamCommands.

Returns:

never null.

stringCommands

public RedisStringCommands stringCommands()

Description copied from interface: RedisConnection

Get RedisStringCommands.

Returns:

never null.

serverCommands

public RedisServerCommands serverCommands()

Description copied from interface: RedisConnection

Get RedisServerCommands.

Returns:

never null.

zSetCommands

public RedisZSetCommands zSetCommands()

Description copied from interface: RedisConnection

Get RedisZSetCommands.

Returns:

never null.

execute

public Object execute(String command,
                      byte[]... args)

Description copied from interface: RedisCommands

'Native' or 'raw' execution of the given command along-side the given arguments. The command is executed as is, with as little 'interpretation' as possible - it is up to the caller to take care of any processing of arguments or the result.

Parameters:

command - Command to execute. must not be null.

args - Possible command arguments (may be empty).

Returns:

execution result. Can be null.

execute

@Nullable
public Object execute(String command,
                                @Nullable
                                io.lettuce.core.output.CommandOutput commandOutputTypeHint,
                                byte[]... args)

'Native' or 'raw' execution of the given command along-side the given arguments.

Parameters:

command - Command to execute

commandOutputTypeHint - Type of Output to use, may be (may be null).

args - Possible command arguments (may be null)

Returns:

execution result.

See Also:

RedisConnection#execute(String, byte[]...)

close

public void close()
           throws DataAccessException

Description copied from interface: RedisConnection

Closes (or quits) the connection.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface RedisConnection

Overrides:

close in class AbstractRedisConnection

Throws:

DataAccessException

isClosed

public boolean isClosed()

Description copied from interface: RedisConnection

Indicates whether the underlying connection is closed or not.

Returns:

true if the connection is closed, false otherwise.

getNativeConnection

public io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands<byte[],byte[]> getNativeConnection()

Description copied from interface: RedisConnection

Returns the native connection (the underlying library/driver object).

Returns:

underlying, native object

isQueueing

public boolean isQueueing()

Description copied from interface: RedisConnection

Indicates whether the connection is in "queue"(or "MULTI") mode or not. When queueing, all commands are postponed until EXEC or DISCARD commands are issued. Since in queueing no results are returned, the connection will return NULL on all operations that interact with the data.

Returns:

true if the connection is in queue/MULTI mode, false otherwise

isPipelined

public boolean isPipelined()

Description copied from interface: RedisConnection

Indicates whether the connection is currently pipelined or not.

Returns:

true if the connection is pipelined, false otherwise

See Also:

RedisConnection.openPipeline(), RedisConnection.isQueueing()

openPipeline

public void openPipeline()

Description copied from interface: RedisConnection

Activates the pipeline mode for this connection. When pipelined, all commands return null (the reply is read at the end through RedisConnection.closePipeline(). Calling this method when the connection is already pipelined has no effect. Pipelining is used for issuing commands without requesting the response right away but rather at the end of the batch. While somewhat similar to MULTI, pipelining does not guarantee atomicity - it only tries to improve performance when issuing a lot of commands (such as in batching scenarios).

Note:

Consider doing some performance testing before using this feature since in many cases the performance benefits are minimal yet the impact on usage are not.

See Also:

RedisTxCommands.multi()

closePipeline

public List<Object> closePipeline()

Description copied from interface: RedisConnection

Executes the commands in the pipeline and returns their result. If the connection is not pipelined, an empty collection is returned.

Returns:

the result of the executed commands.

echo

public byte[] echo(byte[] message)

Description copied from interface: RedisConnectionCommands

Returns message via server roundtrip.

Parameters:

message - the message to echo.

Returns:

the message or null when used in pipeline / transaction.

See Also:

Redis Documentation: ECHO

ping

public String ping()

Description copied from interface: RedisConnectionCommands

Test connection.

Returns:

Server response message - usually PONG. null when used in pipeline / transaction.

See Also:

Redis Documentation: PING

discard

public void discard()

Description copied from interface: RedisTxCommands

Discard all commands issued after RedisTxCommands.multi().

See Also:

Redis Documentation: DISCARD

exec

public List<Object> exec()

Description copied from interface: RedisTxCommands

Executes all queued commands in a transaction started with RedisTxCommands.multi().
If used along with #watch(byte[]...) the operation will fail if any of watched keys has been modified.

Returns:

List of replies for each executed command.

See Also:

Redis Documentation: EXEC

multi

public void multi()

Description copied from interface: RedisTxCommands

Mark the start of a transaction block.
Commands will be queued and can then be executed by calling RedisTxCommands.exec() or rolled back using RedisTxCommands.discard()

See Also:

Redis Documentation: MULTI

select

public void select(int dbIndex)

Description copied from interface: RedisConnectionCommands

Select the DB with given positive dbIndex.

Parameters:

dbIndex - the database index.

See Also:

Redis Documentation: SELECT

unwatch

public void unwatch()

Description copied from interface: RedisTxCommands

Flushes all the previously #watch(byte[]...) keys.

See Also:

Redis Documentation: UNWATCH

watch

public void watch(byte[]... keys)

Description copied from interface: RedisTxCommands

Watch given keys for modifications during transaction started with RedisTxCommands.multi().

Parameters:

keys - must not be null.

See Also:

Redis Documentation: WATCH

publish

public Long publish(byte[] channel,
                    byte[] message)

Description copied from interface: RedisPubSubCommands

Publishes the given message to the given channel.

Parameters:

channel - the channel to publish to. Must not be null.

message - message to publish. Must not be null.

Returns:

the number of clients that received the message or null when used in pipeline / transaction.

See Also:

Redis Documentation: PUBLISH

getSubscription

public Subscription getSubscription()

Description copied from interface: RedisPubSubCommands

Returns the current subscription for this connection or null if the connection is not subscribed.

Returns:

the current subscription, null if none is available.

isSubscribed

public boolean isSubscribed()

Description copied from interface: RedisPubSubCommands

Indicates whether the current connection is subscribed (to at least one channel) or not.

Returns:

true if the connection is subscribed, false otherwise

pSubscribe

public void pSubscribe(MessageListener listener,
                       byte[]... patterns)

Description copied from interface: RedisPubSubCommands

Subscribes the connection to all channels matching the given patterns. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.

Note that this operation is blocking and the current thread starts waiting for new messages immediately.

Parameters:

listener - message listener, must not be null.

patterns - channel name patterns, must not be null.

See Also:

Redis Documentation: PSUBSCRIBE

subscribe

public void subscribe(MessageListener listener,
                      byte[]... channels)

Description copied from interface: RedisPubSubCommands

Subscribes the connection to the given channels. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.

Note that this operation is blocking and the current thread starts waiting for new messages immediately.

Parameters:

listener - message listener, must not be null.

channels - channel names, must not be null.

See Also:

Redis Documentation: SUBSCRIBE

setConvertPipelineAndTxResults

public void setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults)

Specifies if pipelined and transaction results should be converted to the expected data type. If false, results of closePipeline() and exec() will be of the type returned by the Lettuce driver

Parameters:

convertPipelineAndTxResults - Whether or not to convert pipeline and tx results

setPipeliningFlushPolicy

public void setPipeliningFlushPolicy(LettuceConnection.PipeliningFlushPolicy pipeliningFlushPolicy)

Configures the flushing policy when using pipelining.

Parameters:

pipeliningFlushPolicy - the flushing policy to control when commands get written to the Redis connection.

Since:

2.3

See Also:

LettuceConnection.PipeliningFlushPolicy.flushEachCommand(), openPipeline(), StatefulConnection.flushCommands()

switchToPubSub

protected io.lettuce.core.pubsub.StatefulRedisPubSubConnection<byte[],byte[]> switchToPubSub()

close() the current connection and open a new pub/sub connection to the Redis server.

Returns:

never null.

doCreateSubscription

protected LettuceSubscription doCreateSubscription(MessageListener listener,
                                                   io.lettuce.core.pubsub.StatefulRedisPubSubConnection<byte[],byte[]> connection,
                                                   LettuceConnectionProvider connectionProvider)

Customization hook to create a LettuceSubscription.

Parameters:

listener - the MessageListener to notify.

connection - Pub/Sub connection.

connectionProvider - the LettuceConnectionProvider for connection release.

Returns:

a LettuceSubscription.

Since:

2.2

getConnection

protected io.lettuce.core.cluster.api.sync.RedisClusterCommands<byte[],byte[]> getConnection()

getAsyncDedicatedConnection

protected io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands<byte[],byte[]> getAsyncDedicatedConnection()

doGetAsyncDedicatedConnection

protected io.lettuce.core.api.StatefulConnection<byte[],byte[]> doGetAsyncDedicatedConnection()

isActive

protected boolean isActive(RedisNode node)

Description copied from class: AbstractRedisConnection

Check if node is active by sending ping.

Overrides:

isActive in class AbstractRedisConnection

Returns:

getSentinelConnection

protected RedisSentinelConnection getSentinelConnection(RedisNode sentinel)

Description copied from class: AbstractRedisConnection

Get RedisSentinelCommands connected to given node.

Overrides:

getSentinelConnection in class AbstractRedisConnection

Returns: