StatefulRedisMultiDbConnectionImpl (Lettuce 7.4.0.BETA1 API)

java.lang.Object
- io.lettuce.core.failover.StatefulRedisMultiDbConnectionImpl<C,K,V>

All Implemented Interfaces:

StatefulConnection<K,V>, StatefulRedisConnection<K,V>, BaseRedisMultiDbConnection, StatefulRedisMultiDbConnection<K,V>, AsyncCloseable, AutoCloseable

Direct Known Subclasses:

StatefulRedisMultiDbPubSubConnectionImpl
```
@Experimental
public class StatefulRedisMultiDbConnectionImpl<C extends StatefulRedisConnection<K,V>,K,V>
extends Object
implements StatefulRedisMultiDbConnection<K,V>
```
Stateful connection wrapper that holds multiple underlying connections and delegates to the currently active one. Command interfaces (sync/async/reactive) are dynamic proxies that always target the current active connection at invocation time so they remain valid across switches.

Since:

7.4

Author:

Ali Takavci

Field Summary

Fields
Modifier and Type	Field and Description
`protected RedisAsyncCommandsImpl<K,V>`	`async`
`protected RedisCodec<K,V>`	`codec`
`protected io.lettuce.core.failover.DatabaseConnectionFactory<C,K,V>`	`connectionFactory`
`protected Set<RedisConnectionStateListener>`	`connectionStateListeners`
`protected RedisDatabase<C>`	`current`
`protected Map<RedisURI,RedisDatabase<C>>`	`databases`
`protected HealthStatusManager`	`healthStatusManager`
`protected Supplier<JsonParser>`	`parser`
`protected Set<PushListener>`	`pushListeners`
`protected RedisReactiveCommandsImpl<K,V>`	`reactive`
`protected RedisCommands<K,V>`	`sync`

Constructor Summary

Constructors
Constructor and Description
`StatefulRedisMultiDbConnectionImpl(Map<RedisURI,RedisDatabase<C>> connections, ClientResources resources, RedisCodec<K,V> codec, Supplier<JsonParser> parser, io.lettuce.core.failover.DatabaseConnectionFactory<C,K,V> connectionFactory, HealthStatusManager healthStatusManager)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDatabase(DatabaseConfig databaseConfig)` Add a new database to the multi-database connection.
`void`	`addDatabase(RedisURI redisURI, float weight)` Add a new database to the multi-database connection.
`void`	`addListener(PushListener listener)` Add a new `listener` to consume push messages.
`void`	`addListener(RedisConnectionStateListener listener)` Add a listener for the `RedisConnectionStateListener`.
`RedisAsyncCommands<K,V>`	`async()` Returns the `RedisAsyncCommands` API for the current connection.
`void`	`close()` Close the connection.
`CompletableFuture<Void>`	`closeAsync()` Request to close the connection and return the `CompletableFuture` that is notified about its progress.
`Collection<RedisCommand<K,V,?>>`	`dispatch(Collection<? extends RedisCommand<K,V,?>> commands)` Dispatch multiple command in a single write on the channel.
`<T> RedisCommand<K,V,T>`	`dispatch(RedisCommand<K,V,T> command)` Dispatch a command.
`protected void`	`doByExclusiveLock(Runnable operation)`
`protected void`	`doBySharedLock(Runnable operation)`
`void`	`flushCommands()` Flush pending commands.
`CircuitBreaker`	`getCircuitBreaker(RedisURI endpoint)` Get the circuit breaker for a specific endpoint.
`RedisCodec<K,V>`	`getCodec()`
`RedisURI`	`getCurrentEndpoint()` Get the current database endpoint.
`Iterable<RedisURI>`	`getEndpoints()` Get all available database endpoints.
`ClientOptions`	`getOptions()`
`ClientResources`	`getResources()`
`Duration`	`getTimeout()`
`boolean`	`isHealthy(RedisURI endpoint)` Check if an endpoint is healthy (health status is HEALTHY and circuit breaker is CLOSED).
`boolean`	`isMulti()`
`boolean`	`isOpen()`
`protected RedisAsyncCommandsImpl<K,V>`	`newRedisAsyncCommandsImpl()` Create a new instance of `RedisAsyncCommandsImpl`.
`protected RedisReactiveCommandsImpl<K,V>`	`newRedisReactiveCommandsImpl()` Create a new instance of `RedisReactiveCommandsImpl`.
`protected RedisCommands<K,V>`	`newRedisSyncCommandsImpl()` Create a new instance of `RedisCommands`.
`RedisReactiveCommands<K,V>`	`reactive()` Returns the `RedisReactiveCommands` API for the current connection.
`void`	`removeDatabase(RedisURI redisURI)` Remove a database from the multi-database connection.
`void`	`removeListener(PushListener listener)` Remove an existing `listener`.
`void`	`removeListener(RedisConnectionStateListener listener)` Removes a listener.
`void`	`setAutoFlushCommands(boolean autoFlush)` Disable or enable auto-flush behavior.
`void`	`setTimeout(Duration timeout)` Set the default command timeout for this connection.
`void`	`switchToDatabase(RedisURI redisURI)` Switch to a different database.
`RedisCommands<K,V>`	`sync()` Returns the `RedisCommands` API for the current connection.
`protected <T> T`	`syncHandler(Object asyncApi, Class<?>... interfaces)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - databases
```
protected final Map<RedisURI,RedisDatabase<C extends StatefulRedisConnection<K,V>>> databases
```
  - healthStatusManager
```
protected final HealthStatusManager healthStatusManager
```
  - current
```
protected RedisDatabase<C extends StatefulRedisConnection<K,V>> current
```
  - sync
```
protected final RedisCommands<K,V> sync
```
  - async
```
protected final RedisAsyncCommandsImpl<K,V> async
```
  - reactive
```
protected final RedisReactiveCommandsImpl<K,V> reactive
```
  - codec
```
protected final RedisCodec<K,V> codec
```
  - parser
```
protected final Supplier<JsonParser> parser
```
  - pushListeners
```
protected final Set<PushListener> pushListeners
```
  - connectionStateListeners
```
protected final Set<RedisConnectionStateListener> connectionStateListeners
```
  - connectionFactory
```
protected final io.lettuce.core.failover.DatabaseConnectionFactory<C extends StatefulRedisConnection<K,V>,K,V> connectionFactory
```
- Constructor Detail
  - StatefulRedisMultiDbConnectionImpl
```
public StatefulRedisMultiDbConnectionImpl(Map<RedisURI,RedisDatabase<C>> connections,
                                          ClientResources resources,
                                          RedisCodec<K,V> codec,
                                          Supplier<JsonParser> parser,
                                          io.lettuce.core.failover.DatabaseConnectionFactory<C,K,V> connectionFactory,
                                          HealthStatusManager healthStatusManager)
```
- Method Detail
  - async
```
public RedisAsyncCommands<K,V> async()
```
    Description copied from interface: StatefulRedisConnection
    
    Returns the RedisAsyncCommands API for the current connection. Does not create a new connection.
    
    Specified by:
    
    async in interface StatefulRedisConnection<K,V>
    
    Returns:
    
    the asynchronous API for the underlying connection.
  - newRedisSyncCommandsImpl
```
protected RedisCommands<K,V> newRedisSyncCommandsImpl()
```
    Create a new instance of RedisCommands. Can be overriden to extend.
    
    Returns:
    
    a new instance
  - syncHandler
```
protected <T> T syncHandler(Object asyncApi,
                            Class<?>... interfaces)
```
  - newRedisAsyncCommandsImpl
```
protected RedisAsyncCommandsImpl<K,V> newRedisAsyncCommandsImpl()
```
    Create a new instance of RedisAsyncCommandsImpl. Can be overriden to extend.
    
    Returns:
    
    a new instance
  - reactive
```
public RedisReactiveCommands<K,V> reactive()
```
    Description copied from interface: StatefulRedisConnection
    
    Returns the RedisReactiveCommands API for the current connection. Does not create a new connection.
    
    Specified by:
    
    reactive in interface StatefulRedisConnection<K,V>
    
    Returns:
    
    the reactive API for the underlying connection.
  - newRedisReactiveCommandsImpl
```
protected RedisReactiveCommandsImpl<K,V> newRedisReactiveCommandsImpl()
```
    Create a new instance of RedisReactiveCommandsImpl. Can be overriden to extend.
    
    Returns:
    
    a new instance
  - sync
```
public RedisCommands<K,V> sync()
```
    Description copied from interface: StatefulRedisConnection
    
    Returns the RedisCommands API for the current connection. Does not create a new connection.
    
    Specified by:
    
    sync in interface StatefulRedisConnection<K,V>
    
    Returns:
    
    the synchronous API for the underlying connection.
  - addListener
```
public void addListener(RedisConnectionStateListener listener)
```
    Description copied from interface: StatefulConnection
    
    Add a listener for the RedisConnectionStateListener. The listener is notified every time a connect/disconnect/IO exception happens. The listener is called on the event loop thread so code within the listener methods must not block.
    
    Specified by:
    
    addListener in interface StatefulConnection<K,V>
    
    Parameters:
    
    listener - must not be null.
  - removeListener
```
public void removeListener(RedisConnectionStateListener listener)
```
    Description copied from interface: StatefulConnection
    
    Removes a listener.
    
    Specified by:
    
    removeListener in interface StatefulConnection<K,V>
    
    Parameters:
    
    listener - must not be null.
  - setTimeout
```
public void setTimeout(Duration timeout)
```
    Description copied from interface: StatefulConnection
    
    Set the default command timeout for this connection. A zero timeout value indicates to not time out.
    
    Specified by:
    
    setTimeout in interface StatefulConnection<K,V>
    
    Parameters:
    
    timeout - Command timeout.
  - getTimeout
```
public Duration getTimeout()
```
    Specified by:
    
    getTimeout in interface StatefulConnection<K,V>
    
    Returns:
    
    the timeout.
  - dispatch
```
public <T> RedisCommand<K,V,T> dispatch(RedisCommand<K,V,T> command)
```
    Description copied from interface: StatefulConnection
    
    Dispatch a command. Write a command on the channel. The command may be changed/wrapped during write and the written instance is returned after the call. This command does not wait until the command completes and does not guarantee whether the command is executed successfully.
    
    Specified by:
    
    dispatch in interface StatefulConnection<K,V>
    
    Type Parameters:
    
    T - result type
    
    Parameters:
    
    command - the Redis command.
    
    Returns:
    
    the written Redis command.
  - dispatch
```
public Collection<RedisCommand<K,V,?>> dispatch(Collection<? extends RedisCommand<K,V,?>> commands)
```
    Description copied from interface: StatefulConnection
    
    Dispatch multiple command in a single write on the channel. The commands may be changed/wrapped during write and the written instance is returned after the call. This command does not wait until the command completes and does not guarantee whether the command is executed successfully.
    
    Specified by:
    
    dispatch in interface StatefulConnection<K,V>
    
    Parameters:
    
    commands - the Redis commands.
    
    Returns:
    
    the written Redis commands.
  - close
```
public void close()
```
    Description copied from interface: StatefulConnection
    
    Close the connection. The connection will become not usable anymore as soon as this method was called.
    
    Specified by:
    
    close in interface StatefulConnection<K,V>
    
    Specified by:
    
    close in interface AutoCloseable
  - closeAsync
```
public CompletableFuture<Void> closeAsync()
```
    Description copied from interface: StatefulConnection
    
    Request to close the connection and return the CompletableFuture that is notified about its progress. The connection will become not usable anymore as soon as this method was called.
    
    Specified by:
    
    closeAsync in interface StatefulConnection<K,V>
    
    Specified by:
    
    closeAsync in interface AsyncCloseable
    
    Returns:
    
    a CompletableFuture that is notified once the operation completes, either because the operation was successful or because of an error.
  - isOpen
```
public boolean isOpen()
```
    Specified by:
    
    isOpen in interface StatefulConnection<K,V>
    
    Returns:
    
    true if the connection is open (connected and not closed).
  - getOptions
```
public ClientOptions getOptions()
```
    Specified by:
    
    getOptions in interface StatefulConnection<K,V>
    
    Returns:
    
    the client options valid for this connection.
  - getResources
```
public ClientResources getResources()
```
    Specified by:
    
    getResources in interface StatefulConnection<K,V>
    
    Returns:
    
    the client resources used for this connection.
  - setAutoFlushCommands
```
public void setAutoFlushCommands(boolean autoFlush)
```
    Description copied from interface: StatefulConnection
    
    Disable or enable auto-flush behavior. Default is true. If autoFlushCommands is disabled, multiple commands can be issued without writing them actually to the transport. Commands are buffered until a StatefulConnection.flushCommands() is issued. After calling StatefulConnection.flushCommands() commands are sent to the transport and executed by Redis.
    
    Specified by:
    
    setAutoFlushCommands in interface StatefulConnection<K,V>
    
    Parameters:
    
    autoFlush - state of autoFlush.
  - flushCommands
```
public void flushCommands()
```
    Description copied from interface: StatefulConnection
    
    Flush pending commands. This commands forces a flush on the channel and can be used to buffer ("pipeline") commands to achieve batching. No-op if channel is not connected.
    
    Specified by:
    
    flushCommands in interface StatefulConnection<K,V>
  - isMulti
```
public boolean isMulti()
```
    Specified by:
    
    isMulti in interface StatefulRedisConnection<K,V>
    
    Returns:
    
    true, if the connection is within a transaction.
  - addListener
```
public void addListener(PushListener listener)
```
    Description copied from interface: StatefulRedisConnection
    
    Add a new listener to consume push messages.
    
    Specified by:
    
    addListener in interface StatefulRedisConnection<K,V>
    
    Parameters:
    
    listener - the listener, must not be null.
  - removeListener
```
public void removeListener(PushListener listener)
```
    Description copied from interface: StatefulRedisConnection
    
    Remove an existing listener.
    
    Specified by:
    
    removeListener in interface StatefulRedisConnection<K,V>
    
    Parameters:
    
    listener - the listener, must not be null.
  - getCodec
```
public RedisCodec<K,V> getCodec()
```
    Specified by:
    
    getCodec in interface StatefulConnection<K,V>
    
    Returns:
    
    the RedisCodec used by this connection.
  - getCurrentEndpoint
```
public RedisURI getCurrentEndpoint()
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Get the current database endpoint.
    
    Specified by:
    
    getCurrentEndpoint in interface BaseRedisMultiDbConnection
    
    Returns:
    
    the current database endpoint
  - getEndpoints
```
public Iterable<RedisURI> getEndpoints()
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Get all available database endpoints.
    
    Specified by:
    
    getEndpoints in interface BaseRedisMultiDbConnection
    
    Returns:
    
    an iterable of all database endpoints
  - switchToDatabase
```
public void switchToDatabase(RedisURI redisURI)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Switch to a different database.
    
    Specified by:
    
    switchToDatabase in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    redisURI - the Redis URI of the database to switch to, must not be null
  - doBySharedLock
```
protected void doBySharedLock(Runnable operation)
```
  - doByExclusiveLock
```
protected void doByExclusiveLock(Runnable operation)
```
  - getCircuitBreaker
```
public CircuitBreaker getCircuitBreaker(RedisURI endpoint)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Get the circuit breaker for a specific endpoint.
    
    Specified by:
    
    getCircuitBreaker in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    endpoint - the Redis endpoint URI
    
    Returns:
    
    the circuit breaker for the endpoint
  - isHealthy
```
public boolean isHealthy(RedisURI endpoint)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Check if an endpoint is healthy (health status is HEALTHY and circuit breaker is CLOSED).
    
    Specified by:
    
    isHealthy in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    endpoint - the Redis endpoint URI
    
    Returns:
    
    true if the endpoint is healthy (HEALTHY status and CLOSED circuit breaker), false otherwise
  - addDatabase
```
public void addDatabase(RedisURI redisURI,
                        float weight)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Add a new database to the multi-database connection.
    
    Specified by:
    
    addDatabase in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    redisURI - the Redis URI for the new database, must not be null
    
    weight - the weight for load balancing, must be greater than 0
  - addDatabase
```
public void addDatabase(DatabaseConfig databaseConfig)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Add a new database to the multi-database connection.
    
    Specified by:
    
    addDatabase in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    databaseConfig - the database configuration, must not be null
  - removeDatabase
```
public void removeDatabase(RedisURI redisURI)
```
    Description copied from interface: BaseRedisMultiDbConnection
    
    Remove a database from the multi-database connection.
    
    Specified by:
    
    removeDatabase in interface BaseRedisMultiDbConnection
    
    Parameters:
    
    redisURI - the Redis URI of the database to remove, must not be null

Class StatefulRedisMultiDbConnectionImpl<C extends StatefulRedisConnection<K,V>,K,V>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

databases

healthStatusManager

current

sync

async

reactive

codec

parser

pushListeners

connectionStateListeners

connectionFactory

Constructor Detail

StatefulRedisMultiDbConnectionImpl

Method Detail

async

newRedisSyncCommandsImpl

syncHandler

newRedisAsyncCommandsImpl

reactive

newRedisReactiveCommandsImpl

sync

addListener

removeListener

setTimeout

getTimeout

dispatch

dispatch

close

closeAsync

isOpen

getOptions

getResources

setAutoFlushCommands

flushCommands

isMulti

addListener

removeListener

getCodec

getCurrentEndpoint

getEndpoints

switchToDatabase

doBySharedLock

doByExclusiveLock

getCircuitBreaker

isHealthy

addDatabase

addDatabase

removeDatabase