Core Client Classes

public class Jedis implements ServerCommands, DatabaseCommands, JedisCommands, JedisBinaryCommands,
    ControlCommands, ControlBinaryCommands, ClusterCommands, ModuleCommands, GenericControlCommands,
    SentinelCommands, CommandCommands, Closeable {
    /**
     * Creates a new Jedis client connected to localhost:6379
     */
    public Jedis();
    
    /**
     * Creates a new Jedis client from URL string
     * @param url Redis connection URL
     */
    public Jedis(String url);
    
    /**
     * Creates a new Jedis client
     * @param hp Host and port endpoint
     */
    public Jedis(HostAndPort hp);
    
    /**
     * Creates a new Jedis client
     * @param host Redis server host
     * @param port Redis server port
     */
    public Jedis(String host, int port);
    
    /**
     * Creates a new Jedis client with configuration
     * @param host Redis server host
     * @param port Redis server port  
     * @param config Client configuration
     */
    public Jedis(String host, int port, JedisClientConfig config);
    
    /**
     * Creates a new Jedis client with endpoint and configuration
     * @param hostPort Host and port endpoint
     * @param config Client configuration
     */
    public Jedis(HostAndPort hostPort, JedisClientConfig config);
    
    /**
     * Creates a new Jedis client with SSL support
     * @param host Redis server host
     * @param port Redis server port
     * @param ssl Enable SSL connection
     */
    public Jedis(String host, int port, boolean ssl);
    
    /**
     * Creates a Jedis client with timeout
     * @param host Redis server host
     * @param port Redis server port
     * @param timeout Connection and socket timeout in milliseconds
     */
    public Jedis(String host, int port, int timeout);
    
    /**
     * Creates a Jedis client with timeout and SSL
     * @param host Redis server host
     * @param port Redis server port
     * @param timeout Connection and socket timeout in milliseconds
     * @param ssl Enable SSL connection
     */
    public Jedis(String host, int port, int timeout, boolean ssl);
    
    /**
     * Creates a Jedis client with connection details
     * @param host Redis server host
     * @param port Redis server port
     * @param connectionTimeout Connection timeout in milliseconds
     * @param soTimeout Socket timeout in milliseconds
     */
    public Jedis(String host, int port, int connectionTimeout, int soTimeout);
    
    /**
     * Creates a Jedis client with timeouts and SSL
     * @param host Redis server host
     * @param port Redis server port
     * @param connectionTimeout Connection timeout in milliseconds
     * @param soTimeout Socket timeout in milliseconds
     * @param ssl Enable SSL connection
     */
    public Jedis(String host, int port, int connectionTimeout, int soTimeout, boolean ssl);
    
    /**
     * Creates a new Jedis client from URI
     * @param uri Redis connection URI (redis://host:port/db)
     */
    public Jedis(URI uri);
    
    /**
     * Creates a new Jedis client from URI with timeout
     * @param uri Redis connection URI
     * @param timeout Connection timeout in milliseconds
     */
    public Jedis(URI uri, int timeout);
    
    /**
     * Creates a new Jedis client from URI with timeouts
     * @param uri Redis connection URI
     * @param connectionTimeout Connection timeout in milliseconds
     * @param soTimeout Socket timeout in milliseconds
     */
    public Jedis(URI uri, int connectionTimeout, int soTimeout);
    
    /**
     * Creates a new Jedis client from URI with configuration
     * @param uri Redis connection URI
     * @param config Client configuration
     */
    public Jedis(URI uri, JedisClientConfig config);
    
    /**
     * Creates a new Jedis client with socket factory
     * @param jedisSocketFactory Custom socket factory
     */
    public Jedis(JedisSocketFactory jedisSocketFactory);
    
    /**
     * Creates a new Jedis client with socket factory and configuration
     * @param jedisSocketFactory Custom socket factory
     * @param clientConfig Client configuration
     */
    public Jedis(JedisSocketFactory jedisSocketFactory, JedisClientConfig clientConfig);
    
    /**
     * Creates a new Jedis client with existing connection
     * @param connection Existing connection object
     */
    public Jedis(Connection connection);
    
    /**
     * Tests if client is connected to Redis server
     * @return true if connected
     */
    public boolean isConnected();
    
    /**
     * Gets the database index currently selected
     * @return Database index (0-15)
     */
    public int getDB();
    
    /**
     * Executes Redis AUTH command for authentication
     * @param password Redis password
     * @return Status code reply
     */
    public String auth(String password);
    
    /**
     * Executes Redis AUTH command with username and password
     * @param user Redis username
     * @param password Redis password  
     * @return Status code reply
     */
    public String auth(String user, String password);
    
    /**
     * Selects a Redis database
     * @param index Database index (0-15)
     * @return Status code reply
     */
    public String select(int index);
    
    /**
     * Closes the connection to Redis server
     */
    public void close();
    
    /**
     * Returns connection to Redis server
     * @return Connection object
     */
    public Connection getConnection();
}

// Basic usage
Jedis jedis = new Jedis("localhost", 6379);
jedis.set("key", "value");
String value = jedis.get("key");
jedis.close();

// With authentication
Jedis jedis = new Jedis("localhost", 6379);
jedis.auth("password");
jedis.select(1); // Use database 1
jedis.set("key", "value");
jedis.close();

// With URI and SSL
URI uri = URI.create("rediss://username:password@redis.example.com:6380/0");
JedisClientConfig config = DefaultJedisClientConfig.builder()
    .ssl(true)
    .sslVerifyMode(SslVerifyMode.FULL)
    .build();
Jedis jedis = new Jedis(uri, config);

public class UnifiedJedis implements JedisCommands, JedisBinaryCommands,
    SampleKeyedCommands, SampleBinaryKeyedCommands, RedisModuleCommands,
    AutoCloseable {
    /**
     * Creates UnifiedJedis with default localhost:6379 connection
     */
    public UnifiedJedis();
    
    /**
     * Creates UnifiedJedis for single Redis instance
     * @param hostAndPort Host and port endpoint
     */
    public UnifiedJedis(HostAndPort hostAndPort);
    
    /**
     * Creates UnifiedJedis from URL string
     * @param url Redis connection URL
     */
    public UnifiedJedis(String url);
    
    /**
     * Creates UnifiedJedis from Redis URI
     * @param uri Redis connection URI
     */
    public UnifiedJedis(URI uri);
    
    /**
     * Creates UnifiedJedis from URI with configuration
     * @param uri Redis connection URI
     * @param config Client configuration
     */
    public UnifiedJedis(URI uri, JedisClientConfig config);
    
    /**
     * Creates UnifiedJedis for single instance with configuration
     * @param hostAndPort Host and port endpoint
     * @param clientConfig Client configuration
     */
    public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig);
    
    /**
     * Creates UnifiedJedis with endpoint, client config and cache config
     * @param hostAndPort Host and port endpoint
     * @param clientConfig Client configuration
     * @param cacheConfig Cache configuration
     */
    public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig, CacheConfig cacheConfig);
    
    /**
     * Creates UnifiedJedis with endpoint, client config and cache
     * @param hostAndPort Host and port endpoint
     * @param clientConfig Client configuration
     * @param cache Cache instance
     */
    public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig, Cache cache);
    
    /**
     * Creates UnifiedJedis with connection provider
     * @param provider Connection provider for different deployment types
     */
    public UnifiedJedis(ConnectionProvider provider);
    
    /**
     * Creates UnifiedJedis with socket factory
     * @param socketFactory Custom socket factory
     */
    public UnifiedJedis(JedisSocketFactory socketFactory);
    
    /**
     * Creates UnifiedJedis with socket factory and configuration
     * @param socketFactory Custom socket factory
     * @param clientConfig Client configuration
     */
    public UnifiedJedis(JedisSocketFactory socketFactory, JedisClientConfig clientConfig);
    
    /**
     * Creates UnifiedJedis with existing connection
     * @param connection Existing connection object
     */
    public UnifiedJedis(Connection connection);
    
    /**
     * Creates UnifiedJedis for Redis Cluster
     * @param jedisClusterNodes Set of cluster node endpoints
     * @param clientConfig Client configuration
     * @param maxAttempts Maximum retry attempts
     */
    public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts);
    
    /**
     * Creates UnifiedJedis with cluster provider and retry settings
     * @param provider Cluster connection provider
     * @param maxAttempts Maximum retry attempts
     * @param maxTotalRetriesDuration Maximum total retry duration
     */
    public UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration);
    
    /**
     * Creates UnifiedJedis with sharded provider
     * @param provider Sharded connection provider
     */
    public UnifiedJedis(ShardedConnectionProvider provider);
    
    /**
     * Creates UnifiedJedis with sharded provider and tag pattern
     * @param provider Sharded connection provider
     * @param tagPattern Tag pattern for key routing
     */
    public UnifiedJedis(ShardedConnectionProvider provider, Pattern tagPattern);
    
    /**
     * Creates UnifiedJedis with connection provider and retry settings
     * @param provider Connection provider
     * @param maxAttempts Maximum retry attempts
     * @param maxTotalRetriesDuration Maximum total retry duration
     */
    public UnifiedJedis(ConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration);
    
    /**
     * Creates UnifiedJedis with multi-cluster provider
     * @param provider Multi-cluster connection provider
     */
    public UnifiedJedis(MultiClusterPooledConnectionProvider provider);
    
    /**
     * Creates UnifiedJedis with command executor
     * @param executor Command executor
     */
    public UnifiedJedis(CommandExecutor executor);
    
    /**
     * Creates UnifiedJedis with executor, provider and command objects
     * @param executor Command executor
     * @param provider Connection provider
     * @param commandObjects Command objects factory
     */
    public UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects);
    
    /**
     * Closes the client and releases resources
     */
    public void close();
}

// Single instance
UnifiedJedis jedis = new UnifiedJedis("localhost", 6379);

// Cluster deployment  
Set<HostAndPort> clusterNodes = Set.of(
    new HostAndPort("redis-node1", 7000),
    new HostAndPort("redis-node2", 7001),
    new HostAndPort("redis-node3", 7002)
);
UnifiedJedis jedis = new UnifiedJedis(clusterNodes);

// With connection provider
ConnectionProvider provider = new PooledConnectionProvider(
    new JedisPool("localhost", 6379)
);
UnifiedJedis jedis = new UnifiedJedis(provider);

public class JedisCluster extends UnifiedJedis {
    /**
     * Creates cluster client with default configuration
     * @param jedisClusterNode Single cluster node endpoint
     */
    public JedisCluster(HostAndPort jedisClusterNode);
    
    /**
     * Creates cluster client
     * @param clusterNodes Set of cluster node endpoints
     */
    public JedisCluster(Set<HostAndPort> clusterNodes);
    
    /**
     * Creates cluster client with configuration
     * @param clusterNodes Set of cluster node endpoints  
     * @param config Client configuration
     */
    public JedisCluster(Set<HostAndPort> clusterNodes, JedisClientConfig config);
    
    /**
     * Creates cluster client with timeout configuration
     * @param clusterNodes Set of cluster node endpoints
     * @param connectionTimeout Connection timeout in milliseconds
     * @param soTimeout Socket timeout in milliseconds  
     */
    public JedisCluster(Set<HostAndPort> clusterNodes, int connectionTimeout, int soTimeout);
    
    /**
     * Creates cluster client with pool configuration
     * @param clusterNodes Set of cluster node endpoints
     * @param config Client configuration
     * @param poolConfig Pool configuration
     */
    public JedisCluster(Set<HostAndPort> clusterNodes, JedisClientConfig config, 
                       JedisPoolConfig poolConfig);
    
    /**
     * Gets cluster information
     * @return Cluster info string
     */
    public String clusterInfo();
    
    /**
     * Gets cluster nodes information
     * @return Cluster nodes info
     */
    public String clusterNodes();
    
    /**
     * Gets cluster slots mapping
     * @return List of cluster slot ranges and responsible nodes
     */
    public List<Object> clusterSlots();
    
    /**
     * Refreshes cluster slot mapping
     */
    public void refreshClusterSlots();
    
    /**
     * Gets connection pool for specific cluster node
     * @param node Cluster node endpoint
     * @return Connection pool for the node
     */
    public JedisPool getConnectionPoolFromSlot(int slot);
    
    /**
     * Gets all connection pools in cluster
     * @return Map of node endpoints to connection pools
     */
    public Map<String, JedisPool> getClusterNodes();
    
    /**
     * Closes cluster client and all connections
     */
    public void close();
}

Set<HostAndPort> clusterNodes = new HashSet<>();
clusterNodes.add(new HostAndPort("redis-node1.example.com", 7000));
clusterNodes.add(new HostAndPort("redis-node2.example.com", 7001)); 
clusterNodes.add(new HostAndPort("redis-node3.example.com", 7002));

JedisCluster cluster = new JedisCluster(clusterNodes);

// Use like regular Redis client - clustering is transparent
cluster.set("user:1:name", "John");
cluster.hset("user:1:profile", "age", "30");
String name = cluster.get("user:1:name");

// Cluster-specific operations
String clusterInfo = cluster.clusterInfo();
String nodes = cluster.clusterNodes();

cluster.close();

public class JedisPool implements Pool<Jedis>, Closeable {
    /**
     * Creates pool with default configuration
     * @param host Redis server host
     * @param port Redis server port
     */
    public JedisPool(String host, int port);
    
    /**
     * Creates pool with pool configuration
     * @param poolConfig Pool configuration settings
     * @param host Redis server host  
     * @param port Redis server port
     */
    public JedisPool(JedisPoolConfig poolConfig, String host, int port);
    
    /**
     * Creates pool with client configuration
     * @param poolConfig Pool configuration
     * @param host Redis server host
     * @param port Redis server port
     * @param clientConfig Client configuration
     */
    public JedisPool(JedisPoolConfig poolConfig, String host, int port, 
                    JedisClientConfig clientConfig);
    
    /**
     * Creates pool from URI
     * @param uri Redis connection URI
     */
    public JedisPool(URI uri);
    
    /**
     * Creates pool from URI with configuration
     * @param poolConfig Pool configuration
     * @param uri Redis connection URI
     */
    public JedisPool(JedisPoolConfig poolConfig, URI uri);
    
    /**
     * Gets a Jedis instance from pool
     * @return Jedis instance (must be returned to pool after use)
     */
    public Jedis getResource();
    
    /**
     * Gets number of active connections in pool
     * @return Number of active connections
     */
    public int getNumActive();
    
    /**
     * Gets number of idle connections in pool  
     * @return Number of idle connections
     */
    public int getNumIdle();
    
    /**
     * Gets number of threads waiting for connections
     * @return Number of waiting threads
     */
    public int getNumWaiters();
    
    /**
     * Closes pool and all connections
     */
    public void close();
    
    /**
     * Destroys pool (alias for close)
     */
    public void destroy();
}

// Create pool with configuration
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(128);
poolConfig.setMaxIdle(128);
poolConfig.setMinIdle(16);
poolConfig.setTestOnBorrow(true);

JedisPool pool = new JedisPool(poolConfig, "localhost", 6379);

// Use pool - always use try-with-resources
try (Jedis jedis = pool.getResource()) {
    jedis.set("key", "value");
    String value = jedis.get("key");
}

// Monitor pool health
System.out.println("Active connections: " + pool.getNumActive());
System.out.println("Idle connections: " + pool.getNumIdle());

// Clean shutdown
pool.close();

public class JedisSentinelPool extends Pool<Jedis> {
    /**
     * Creates sentinel pool
     * @param masterName Name of Redis master in Sentinel configuration
     * @param sentinels Set of Sentinel endpoints
     */
    public JedisSentinelPool(String masterName, Set<String> sentinels);
    
    /**
     * Creates sentinel pool with pool configuration
     * @param masterName Name of Redis master
     * @param sentinels Set of Sentinel endpoints  
     * @param poolConfig Pool configuration
     */
    public JedisSentinelPool(String masterName, Set<String> sentinels, 
                           JedisPoolConfig poolConfig);
    
    /**
     * Creates sentinel pool with client configuration
     * @param masterName Name of Redis master
     * @param sentinels Set of Sentinel endpoints
     * @param clientConfig Client configuration
     */
    public JedisSentinelPool(String masterName, Set<String> sentinels, 
                           JedisClientConfig clientConfig);
    
    /**
     * Creates sentinel pool with full configuration
     * @param masterName Name of Redis master
     * @param sentinels Set of Sentinel endpoints
     * @param poolConfig Pool configuration  
     * @param clientConfig Client configuration
     */
    public JedisSentinelPool(String masterName, Set<String> sentinels,
                           JedisPoolConfig poolConfig, JedisClientConfig clientConfig);
    
    /**
     * Gets current master address
     * @return Current master host and port
     */
    public HostAndPort getCurrentHostMaster();
    
    /**
     * Gets a Jedis connection from pool
     * @return Jedis instance
     */
    public Jedis getResource();
    
    /**
     * Destroys the pool
     */
    public void destroy();
}

String masterName = "mymaster";
Set<String> sentinels = Set.of(
    "sentinel1:26379",
    "sentinel2:26379", 
    "sentinel3:26379"
);

JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(20);

JedisSentinelPool sentinelPool = new JedisSentinelPool(
    masterName, sentinels, poolConfig
);

// Use like regular pool - failover is automatic
try (Jedis jedis = sentinelPool.getResource()) {
    jedis.set("key", "value");
    String value = jedis.get("key");
}

// Check current master
HostAndPort master = sentinelPool.getCurrentHostMaster();
System.out.println("Current master: " + master);

sentinelPool.destroy();

public class JedisPooled implements JedisCommands, JedisBinaryCommands, AutoCloseable {
    /**
     * Creates pooled client
     * @param host Redis server host
     * @param port Redis server port
     */
    public JedisPooled(String host, int port);
    
    /**
     * Creates pooled client with configuration
     * @param host Redis server host
     * @param port Redis server port
     * @param config Client configuration
     */
    public JedisPooled(String host, int port, JedisClientConfig config);
    
    /**
     * Creates pooled client with pool configuration
     * @param poolConfig Pool configuration
     * @param host Redis server host
     * @param port Redis server port  
     */
    public JedisPooled(JedisPoolConfig poolConfig, String host, int port);
    
    /**
     * Creates pooled client from URI
     * @param uri Redis connection URI
     */
    public JedisPooled(URI uri);
    
    /**
     * Creates pooled client from connection provider
     * @param connectionProvider Connection provider
     */
    public JedisPooled(ConnectionProvider connectionProvider);
    
    /**
     * Creates pooled client with no parameters (localhost:6379)
     */
    public JedisPooled();
    
    /**
     * Creates pooled client with host and port endpoint
     * @param hostAndPort Server endpoint
     */
    public JedisPooled(HostAndPort hostAndPort);
    
    /**
     * Creates pooled client with endpoint and client config
     * @param hostAndPort Server endpoint  
     * @param clientConfig Client configuration
     */
    public JedisPooled(HostAndPort hostAndPort, JedisClientConfig clientConfig);
    
    /**
     * Creates pooled client with pool and client config
     * @param poolConfig Pool configuration
     * @param hostAndPort Server endpoint
     * @param clientConfig Client configuration
     */
    public JedisPooled(GenericObjectPoolConfig<Connection> poolConfig, HostAndPort hostAndPort, JedisClientConfig clientConfig);
    
    /**
     * Creates pooled client with caching support
     * @param hostAndPort Server endpoint
     * @param clientConfig Client configuration
     * @param cacheConfig Cache configuration
     */
    public JedisPooled(HostAndPort hostAndPort, JedisClientConfig clientConfig, CacheConfig cacheConfig);
    
    /**
     * Gets the underlying connection pool
     * @return Connection pool
     */
    public Pool<Connection> getPool();
    
    /**
     * Closes the pooled client
     */
    public void close();
}

// Simple usage - no manual connection management needed
JedisPooled jedis = new JedisPooled("localhost", 6379);

// Use directly like regular Jedis - pooling is transparent  
jedis.set("key", "value");
String value = jedis.get("key");
jedis.hset("hash", "field", "value");

// No need to return connections - handled automatically
jedis.close();

public class JedisSharding implements JedisCommands, AutoCloseable {
    /**
     * Creates sharding client
     * @param shards List of Redis shards with weights
     * @param algo Hashing algorithm  
     */
    public JedisSharding(List<JedisShardInfo> shards, Hashing algo);
    
    /**
     * Creates sharding client with default hashing
     * @param shards List of Redis shards
     */
    public JedisSharding(List<JedisShardInfo> shards);
    
    /**
     * Gets shard info for a key
     * @param key Redis key
     * @return Shard information for the key
     */
    public JedisShardInfo getShardInfo(String key);
    
    /**
     * Gets collection of all shards
     * @return Collection of shard information
     */
    public Collection<JedisShardInfo> getAllShardInfo();
    
    /**
     * Gets Jedis instance for a specific key
     * @param key Redis key  
     * @return Jedis instance for the shard containing the key
     */
    public Jedis getShard(String key);
    
    /**
     * Closes all shard connections
     */
    public void close();
}

List<JedisShardInfo> shards = Arrays.asList(
    new JedisShardInfo("redis1", 6379, 1),  // weight 1
    new JedisShardInfo("redis2", 6379, 1),  // weight 1  
    new JedisShardInfo("redis3", 6379, 2)   // weight 2 (handles more keys)
);

JedisSharding sharding = new JedisSharding(shards);

// Keys are automatically distributed across shards
sharding.set("user:1", "data1");  // Goes to shard based on key hash
sharding.set("user:2", "data2");  // May go to different shard

// Get data - client finds correct shard automatically
String data = sharding.get("user:1");

sharding.close();

public interface JedisClientConfig {
    int getConnectionTimeoutMillis();
    int getSoTimeoutMillis(); 
    int getBlockingSocketTimeoutMillis();
    String getUser();
    String getPassword();
    int getDatabase();
    String getClientName();
    boolean isSsl();
    SslSocketFactory getSslSocketFactory();
    SSLParameters getSslParameters();
    HostnameVerifier getHostnameVerifier();
    RedisProtocol getRedisProtocol();
}

public class DefaultJedisClientConfig implements JedisClientConfig {
    public static Builder builder() {
        return new Builder();
    }
    
    public static class Builder {
        public Builder connectionTimeoutMillis(int connectionTimeoutMillis);
        public Builder socketTimeoutMillis(int socketTimeoutMillis);
        public Builder blockingSocketTimeoutMillis(int blockingSocketTimeoutMillis);
        public Builder user(String user);
        public Builder password(String password);
        public Builder database(int database);
        public Builder clientName(String clientName);
        public Builder ssl(boolean ssl);
        public Builder protocol(RedisProtocol protocol);
        public DefaultJedisClientConfig build();
    }
}

public class JedisShardInfo {
    /**
     * Creates shard info
     * @param host Redis host
     * @param port Redis port
     */
    public JedisShardInfo(String host, int port);
    
    /**
     * Creates shard info with name  
     * @param host Redis host
     * @param port Redis port
     * @param name Shard name
     */
    public JedisShardInfo(String host, int port, String name);
    
    /**
     * Creates shard info with weight
     * @param host Redis host
     * @param port Redis port  
     * @param weight Shard weight for distribution
     */
    public JedisShardInfo(String host, int port, int weight);
    
    /**
     * Creates shard info from URI
     * @param uri Redis connection URI
     */
    public JedisShardInfo(URI uri);
    
    public String getHost();
    public int getPort();
    public String getName();
    public int getWeight();
    public int getTimeout();
    public String getPassword();
}