CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-redisson--redisson

Valkey and Redis Java client providing complete Real-Time Data Platform with distributed objects and services

—

Pending
Overview
Eval results
Files

configuration.mddocs/

Configuration and Client Setup

Redisson provides flexible configuration options for connecting to Redis in various deployment scenarios including single server, cluster, sentinel, and replicated server modes. The configuration system supports both programmatic setup and external configuration files.

Capabilities

Client Factory Methods

Factory methods for creating Redisson clients with various configurations.

/**
 * Create a Redisson client with default configuration
 * Connects to localhost:6379 by default
 * @return RedissonClient instance
 */
public static RedissonClient create();

/**
 * Create a Redisson client with custom configuration
 * @param config - configuration object specifying connection details
 * @return RedissonClient instance
 */
public static RedissonClient create(Config config);

/**
 * Get reactive streams client interface from existing client
 * @return RedissonReactiveClient for reactive programming
 */
public RedissonReactiveClient reactive();

/**
 * Get RxJava client interface from existing client  
 * @return RedissonRxClient for RxJava programming
 */
public RedissonRxClient rxJava();

Usage Examples:

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

// Default configuration (localhost:6379)
RedissonClient redisson = Redisson.create();

// Custom configuration
Config config = new Config();
config.useSingleServer()
    .setAddress("redis://127.0.0.1:6379")
    .setPassword("mypassword")
    .setDatabase(0);
    
RedissonClient customRedisson = Redisson.create(config);

// Get reactive client
RedissonReactiveClient reactiveClient = redisson.reactive();

// Get RxJava client
RedissonRxClient rxClient = redisson.rxJava();

Core Configuration Class

The main configuration class with server mode setup and global options.

/**
 * Main configuration class for Redisson client
 */
public class Config {
    // Factory methods for different server modes
    public SingleServerConfig useSingleServer();
    public ClusterServersConfig useClusterServers();
    public SentinelServersConfig useSentinelServers(); 
    public MasterSlaveServersConfig useMasterSlaveServers();
    public ReplicatedServersConfig useReplicatedServers();
    
    // Global configuration properties
    public Config setThreads(int threads);
    public Config setNettyThreads(int nettyThreads);
    public Config setCodec(Codec codec);
    public Config setExecutor(ExecutorService executor);
    public Config setNettyExecutor(Executor nettyExecutor);
    public Config setEventLoopGroup(EventLoopGroup eventLoopGroup);
    public Config setTransportMode(TransportMode transportMode);
    
    // Lock and synchronization settings
    public Config setLockWatchdogTimeout(long lockWatchdogTimeout);
    public Config setLockWatchdogBatchSize(int lockWatchdogBatchSize);
    public Config setFairLockWaitTimeout(long fairLockWaitTimeout);
    public Config setCheckLockSyncedSlaves(boolean checkLockSyncedSlaves);
    public Config setSlavesSyncTimeout(long slavesSyncTimeout);
    
    // Pub/sub and reliability settings
    public Config setReliableTopicWatchdogTimeout(long reliableTopicWatchdogTimeout);
    public Config setKeepPubSubOrder(boolean keepPubSubOrder);
    public Config setUseScriptCache(boolean useScriptCache);
    
    // Cleanup settings
    public Config setMinCleanUpDelay(int minCleanUpDelay);
    public Config setMaxCleanUpDelay(int maxCleanUpDelay);
    public Config setCleanUpKeysAmount(int cleanUpKeysAmount);
    
    // Advanced settings
    public Config setReferenceEnabled(boolean referenceEnabled);
    public Config setNettyHook(NettyHook nettyHook);
    public Config setConnectionListener(ConnectionListener connectionListener);
    
    // Getters
    public int getThreads();
    public int getNettyThreads();
    public Codec getCodec();
    public TransportMode getTransportMode();
    public long getLockWatchdogTimeout();
    // ... other getters
}

Configuration Examples:

Config config = new Config();

// Basic settings
config.setThreads(16) // Number of threads for Redis operations
      .setNettyThreads(32) // Number of Netty threads
      .setCodec(new JsonJacksonCodec()) // JSON serialization
      .setTransportMode(TransportMode.NIO); // NIO transport

// Lock settings
config.setLockWatchdogTimeout(30000) // 30 second lock watchdog
      .setCheckLockSyncedSlaves(true) // Verify lock replication
      .setSlavesSyncTimeout(1000); // Slave sync timeout

// Cleanup settings  
config.setMinCleanUpDelay(5)
      .setMaxCleanUpDelay(1800)
      .setCleanUpKeysAmount(100);

RedissonClient redisson = Redisson.create(config);

Single Server Configuration

Configuration for connecting to a single Redis server.

public class SingleServerConfig extends BaseConfig<SingleServerConfig> {
    // Connection settings
    public SingleServerConfig setAddress(String address);
    public SingleServerConfig setUsername(String username);
    public SingleServerConfig setPassword(String password);
    public SingleServerConfig setDatabase(int database);
    public SingleServerConfig setClientName(String clientName);
    
    // Connection pool settings
    public SingleServerConfig setConnectionMinimumIdleSize(int connectionMinimumIdleSize);
    public SingleServerConfig setConnectionPoolSize(int connectionPoolSize);
    public SingleServerConfig setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize);
    public SingleServerConfig setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize);
    
    // Timeout settings
    public SingleServerConfig setConnectTimeout(int connectTimeout);
    public SingleServerConfig setIdleConnectionTimeout(int idleConnectionTimeout);
    public SingleServerConfig setTimeout(int timeout);
    public SingleServerConfig setRetryAttempts(int retryAttempts);
    public SingleServerConfig setRetryInterval(int retryInterval);
    
    // Advanced settings
    public SingleServerConfig setKeepAlive(boolean keepAlive);
    public SingleServerConfig setTcpNoDelay(boolean tcpNoDelay);
    public SingleServerConfig setDnsMonitoringInterval(long dnsMonitoringInterval);
    public SingleServerConfig setSslTruststore(URI sslTruststore);
    public SingleServerConfig setSslTruststorePassword(String sslTruststorePassword);
    public SingleServerConfig setSslKeystore(URI sslKeystore);
    public SingleServerConfig setSslKeystorePassword(String sslKeystorePassword);
    
    // Getters for all properties
    public String getAddress();
    public String getPassword();
    public int getDatabase();
    public int getConnectionPoolSize();
    // ... other getters
}

Single Server Examples:

Config config = new Config();
SingleServerConfig singleConfig = config.useSingleServer();

// Basic connection
singleConfig.setAddress("redis://127.0.0.1:6379")
           .setPassword("mypassword")
           .setDatabase(0)
           .setClientName("myapp");

// Connection pooling
singleConfig.setConnectionPoolSize(64)
           .setConnectionMinimumIdleSize(10)
           .setSubscriptionConnectionPoolSize(50)
           .setSubscriptionConnectionMinimumIdleSize(1);

// Timeouts and retry
singleConfig.setConnectTimeout(10000)
           .setIdleConnectionTimeout(10000)
           .setTimeout(3000)
           .setRetryAttempts(3)
           .setRetryInterval(1500);

// SSL configuration
singleConfig.setSslTruststore(URI.create("file:///path/to/truststore.jks"))
           .setSslTruststorePassword("password")
           .setSslKeystore(URI.create("file:///path/to/keystore.jks"))
           .setSslKeystorePassword("password");

RedissonClient redisson = Redisson.create(config);

Cluster Configuration

Configuration for connecting to a Redis cluster.

public class ClusterServersConfig extends BaseConfig<ClusterServersConfig> {
    // Node addresses
    public ClusterServersConfig addNodeAddress(String... addresses);
    public ClusterServersConfig setNodeAddresses(List<String> addresses);
    
    // Scan settings
    public ClusterServersConfig setScanInterval(int scanInterval);
    public ClusterServersConfig setCheckSlotsCoverage(boolean checkSlotsCoverage);
    
    // Connection settings (inherits from BaseConfig)
    public ClusterServersConfig setUsername(String username);
    public ClusterServersConfig setPassword(String password);
    public ClusterServersConfig setClientName(String clientName);
    
    // Master connection pool settings
    public ClusterServersConfig setMasterConnectionMinimumIdleSize(int masterConnectionMinimumIdleSize);
    public ClusterServersConfig setMasterConnectionPoolSize(int masterConnectionPoolSize);
    
    // Slave connection pool settings
    public ClusterServersConfig setSlaveConnectionMinimumIdleSize(int slaveConnectionMinimumIdleSize);
    public ClusterServersConfig setSlaveConnectionPoolSize(int slaveConnectionPoolSize);
    
    // Subscription connection settings
    public ClusterServersConfig setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize);
    public ClusterServersConfig setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize);
    
    // Read mode settings
    public ClusterServersConfig setReadMode(ReadMode readMode);
    public ClusterServersConfig setSubscriptionMode(SubscriptionMode subscriptionMode);
    
    // Failover settings
    public ClusterServersConfig setFailedSlaveReconnectionInterval(int failedSlaveReconnectionInterval);
    public ClusterServersConfig setFailedSlaveCheckInterval(int failedSlaveCheckInterval);
    public ClusterServersConfig setSlavesSyncTimeout(long slavesSyncTimeout);
    
    // Getters
    public List<String> getNodeAddresses();
    public int getScanInterval();
    public ReadMode getReadMode();
    // ... other getters
}

Cluster Examples:

Config config = new Config();
ClusterServersConfig clusterConfig = config.useClusterServers();

// Node addresses
clusterConfig.addNodeAddress("redis://127.0.0.1:7004", "redis://127.0.0.1:7001", "redis://127.0.0.1:7000")
            .setPassword("cluster_password")
            .setClientName("cluster-client");

// Scan settings
clusterConfig.setScanInterval(2000) // Scan for new nodes every 2 seconds
            .setCheckSlotsCoverage(true); // Verify all slots are covered

// Connection pools
clusterConfig.setMasterConnectionPoolSize(64)
            .setMasterConnectionMinimumIdleSize(10)
            .setSlaveConnectionPoolSize(64)
            .setSlaveConnectionMinimumIdleSize(10);

// Read mode - where to read from
clusterConfig.setReadMode(ReadMode.SLAVE) // Read from slaves
            .setSubscriptionMode(SubscriptionMode.MASTER); // Subscribe to masters

// Failover settings
clusterConfig.setFailedSlaveReconnectionInterval(3000)
            .setFailedSlaveCheckInterval(60000)
            .setSlavesSyncTimeout(1000);

RedissonClient redisson = Redisson.create(config);

Sentinel Configuration

Configuration for connecting through Redis Sentinel for high availability.

public class SentinelServersConfig extends BaseConfig<SentinelServersConfig> {
    // Sentinel settings
    public SentinelServersConfig addSentinelAddress(String... addresses);
    public SentinelServersConfig setSentinelAddresses(List<String> sentinelAddresses);
    public SentinelServersConfig setMasterName(String masterName);
    public SentinelServersConfig setSentinelUsername(String sentinelUsername);
    public SentinelServersConfig setSentinelPassword(String sentinelPassword);
    
    // Database settings (inherits from BaseConfig)
    public SentinelServersConfig setDatabase(int database);
    public SentinelServersConfig setUsername(String username);
    public SentinelServersConfig setPassword(String password);
    public SentinelServersConfig setClientName(String clientName);
    
    // Master connection pool
    public SentinelServersConfig setMasterConnectionMinimumIdleSize(int masterConnectionMinimumIdleSize);
    public SentinelServersConfig setMasterConnectionPoolSize(int masterConnectionPoolSize);
    
    // Slave connection pool  
    public SentinelServersConfig setSlaveConnectionMinimumIdleSize(int slaveConnectionMinimumIdleSize);
    public SentinelServersConfig setSlaveConnectionPoolSize(int slaveConnectionPoolSize);
    
    // Subscription connections
    public SentinelServersConfig setSubscriptionConnectionMinimumIdleSize(int subscriptionConnectionMinimumIdleSize);
    public SentinelServersConfig setSubscriptionConnectionPoolSize(int subscriptionConnectionPoolSize);
    
    // Sentinel monitoring
    public SentinelServersConfig setSentinelsDiscovery(boolean sentinelsDiscovery);
    public SentinelServersConfig setCheckSentinelsList(boolean checkSentinelsList);
    
    // Read settings
    public SentinelServersConfig setReadMode(ReadMode readMode);
    public SentinelServersConfig setSubscriptionMode(SubscriptionMode subscriptionMode);
    
    // Getters
    public List<String> getSentinelAddresses();
    public String getMasterName();
    public String getSentinelPassword();
    // ... other getters
}

Sentinel Examples:

Config config = new Config();
SentinelServersConfig sentinelConfig = config.useSentinelServers();

// Sentinel setup
sentinelConfig.setMasterName("mymaster")
             .addSentinelAddress("redis://127.0.0.1:26379", "redis://127.0.0.1:26380", "redis://127.0.0.1:26381")
             .setSentinelPassword("sentinel_password")
             .setPassword("redis_password")
             .setDatabase(0);

// Discovery settings
sentinelConfig.setSentinelsDiscovery(true)
             .setCheckSentinelsList(true);

// Connection pools
sentinelConfig.setMasterConnectionPoolSize(64)
             .setSlaveConnectionPoolSize(64)
             .setSubscriptionConnectionPoolSize(50);

// Read strategy  
sentinelConfig.setReadMode(ReadMode.SLAVE)
             .setSubscriptionMode(SubscriptionMode.MASTER);

RedissonClient redisson = Redisson.create(config);

Configuration File Loading

Methods for loading configuration from external files.

// JSON configuration loading
public static Config fromJSON(String content);
public static Config fromJSON(File file) throws IOException;
public static Config fromJSON(URL url) throws IOException;
public static Config fromJSON(Reader reader) throws IOException;
public static Config fromJSON(InputStream inputStream) throws IOException;

// YAML configuration loading  
public static Config fromYAML(String content);
public static Config fromYAML(File file) throws IOException;
public static Config fromYAML(URL url) throws IOException;
public static Config fromYAML(Reader reader) throws IOException;
public static Config fromYAML(InputStream inputStream) throws IOException;

Configuration File Examples:

JSON configuration file (redisson.json):

{
    "threads": 16,
    "nettyThreads": 32,
    "codec": "org.redisson.codec.JsonJacksonCodec",
    "transportMode": "NIO",
    "singleServerConfig": {
        "address": "redis://127.0.0.1:6379",
        "password": "mypassword",
        "database": 0,
        "connectionPoolSize": 64,
        "connectionMinimumIdleSize": 10,
        "subscriptionConnectionPoolSize": 50,
        "timeout": 3000,
        "connectTimeout": 10000,
        "idleConnectionTimeout": 10000,
        "retryAttempts": 3,
        "retryInterval": 1500
    }
}

YAML configuration file (redisson.yml):

threads: 16
nettyThreads: 32
codec: "org.redisson.codec.JsonJacksonCodec"
transportMode: "NIO"

singleServerConfig:
  address: "redis://127.0.0.1:6379"
  password: "mypassword"
  database: 0
  connectionPoolSize: 64
  connectionMinimumIdleSize: 10
  subscriptionConnectionPoolSize: 50
  timeout: 3000
  connectTimeout: 10000
  idleConnectionTimeout: 10000
  retryAttempts: 3
  retryInterval: 1500

Loading configuration from files:

// Load from JSON file
Config config = Config.fromJSON(new File("redisson.json"));
RedissonClient redisson = Redisson.create(config);

// Load from YAML file
Config yamlConfig = Config.fromYAML(new File("redisson.yml"));
RedissonClient yamlRedisson = Redisson.create(yamlConfig);

// Load from classpath resource
Config resourceConfig = Config.fromYAML(
    getClass().getClassLoader().getResourceAsStream("redisson-config.yml")
);

// Load from URL
Config urlConfig = Config.fromJSON(new URL("https://example.com/redisson-config.json"));

Configuration Enums and Options

// Transport modes
public enum TransportMode {
    NIO,     // Standard NIO transport
    EPOLL,   // Linux epoll transport (higher performance on Linux)
    KQUEUE   // macOS/BSD kqueue transport
}

// Read modes for cluster/sentinel
public enum ReadMode {
    SLAVE,              // Read from slave nodes only
    MASTER,             // Read from master nodes only  
    MASTER_SLAVE        // Read from both master and slave nodes
}

// Subscription modes
public enum SubscriptionMode {
    SLAVE,   // Subscribe through slave nodes
    MASTER   // Subscribe through master nodes
}

// Codec implementations for serialization
public enum CodecType {
    JSON_JACKSON("org.redisson.codec.JsonJacksonCodec"),
    KRYO("org.redisson.codec.KryoCodec"),
    FST("org.redisson.codec.FstCodec"),
    SERIALIZATION("org.redisson.codec.SerializationCodec"),
    MSGPACK_JACKSON("org.redisson.codec.MsgPackJacksonCodec"),
    SMILE_JACKSON("org.redisson.codec.SmileJacksonCodec"),
    CBOR_JACKSON("org.redisson.codec.CborJacksonCodec"),
    ION_JACKSON("org.redisson.codec.IonJacksonCodec");
    
    private final String className;
    
    CodecType(String className) {
        this.className = className;
    }
    
    public String getClassName() {
        return className;
    }
}

// Base configuration class
public abstract class BaseConfig<T extends BaseConfig<T>> {
    protected String password;
    protected String username;
    protected String clientName;
    protected int connectTimeout = 10000;
    protected int timeout = 3000;
    protected int retryAttempts = 3;
    protected int retryInterval = 1500;
    protected int idleConnectionTimeout = 10000;
    protected boolean keepAlive = true;
    protected boolean tcpNoDelay = true;
    
    // Common configuration methods available to all server configs
    public T setPassword(String password);
    public T setUsername(String username);
    public T setClientName(String clientName);
    public T setConnectTimeout(int connectTimeout);
    public T setTimeout(int timeout);
    public T setRetryAttempts(int retryAttempts);
    public T setRetryInterval(int retryInterval);
    public T setIdleConnectionTimeout(int idleConnectionTimeout);
    public T setKeepAlive(boolean keepAlive);
    public T setTcpNoDelay(boolean tcpNoDelay);
}

Install with Tessl CLI

npx tessl i tessl/maven-org-redisson--redisson

docs

collections.md

configuration.md

data-structures.md

index.md

messaging.md

reactive-async.md

synchronization.md

tile.json