or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

authentication.md client-side-caching.md clustering.md commands-operations.md connection-management.md core-clients.md exceptions.md index.md modules.md parameters.md pubsub.md transactions-pipelining.md

tile.json

tessl/maven-redis-clients--jedis

Jedis is a blazingly small and sane Redis java client.

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/redis.clients/jedis@6.0.x

To install, run

npx @tessl/cli install tessl/maven-redis-clients--jedis@6.0.0

Jedis Redis Java Client

Jedis is a blazingly small and sane Redis Java client providing comprehensive access to Redis functionality. It offers multiple deployment patterns including single instance, cluster, sentinel, and sharded configurations with support for connection pooling, pipelining, transactions, and all Redis modules.

Package Information

Package Name: redis.clients:jedis
Package Type: maven
Language: Java
Version: 6.0.0
Installation: Add to Maven dependencies: <dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>6.0.0</version></dependency>

Core Imports

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.UnifiedJedis;
import redis.clients.jedis.exceptions.JedisException;

Basic Usage

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

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

// Connection pooling (recommended for production)
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(128);
JedisPool pool = new JedisPool(poolConfig, "localhost", 6379);

try (Jedis jedis = pool.getResource()) {
    jedis.set("key", "value");
    String value = jedis.get("key");
    
    // Hash operations
    jedis.hset("user:1", "name", "John");
    jedis.hset("user:1", "age", "30");
    String name = jedis.hget("user:1", "name");
}
pool.close();

Architecture

Jedis follows a modular architecture with clear separation between:

Core Clients: Main client classes for different deployment patterns
Connection Management: Pooling, factories, and connection lifecycle
Command Interfaces: Organized by Redis data types and operations
Parameters: Type-safe configuration objects for Redis commands
Response Types: Structured objects for Redis responses
Module Support: Full integration with Redis modules (Search, JSON, Bloom, TimeSeries)
Exception Handling: Comprehensive exception hierarchy for error management

Capabilities

Core Client Classes

Primary client implementations for different Redis deployment patterns.

// Single Redis instance client
public class Jedis implements JedisCommands, JedisBinaryCommands, AutoCloseable {
    public Jedis(String host, int port);
    public Jedis(String host, int port, JedisClientConfig config);
    public String set(String key, String value);
    public String get(String key);
    public Long del(String... keys);
    public void close();
}

// Unified client for any deployment type
public class UnifiedJedis implements JedisCommands, JedisBinaryCommands, AutoCloseable {
    public UnifiedJedis(JedisClientConfig config, ConnectionProvider connectionProvider);
    public UnifiedJedis(String host, int port);
}

// Redis Cluster client
public class JedisCluster extends UnifiedJedis {
    public JedisCluster(Set<HostAndPort> nodes);
    public JedisCluster(Set<HostAndPort> nodes, JedisClientConfig config);
    public JedisCluster(Set<HostAndPort> nodes, int connectionTimeout, int soTimeout);
}

// Connection pool for single instance
public class JedisPool implements Pool<Jedis>, Closeable {
    public JedisPool(JedisPoolConfig poolConfig, String host, int port);
    public JedisPool(JedisPoolConfig poolConfig, String host, int port, JedisClientConfig clientConfig);
    public Jedis getResource();
    public void close();
}

// Easier connection management with automatic pooling
public class JedisPooled extends UnifiedJedis implements JedisCommands, JedisBinaryCommands {
    public JedisPooled();
    public JedisPooled(String host, int port);
    public JedisPooled(HostAndPort hostAndPort, JedisClientConfig clientConfig);
    public JedisPooled(GenericObjectPoolConfig<Connection> poolConfig, String host, int port);
}

Core Client Classes

Connection Management

Connection pooling, factories, and lifecycle management for optimal performance.

// Pool configuration
public class JedisPoolConfig extends GenericObjectPoolConfig<Jedis> {
    public void setMaxTotal(int maxTotal);
    public void setMaxIdle(int maxIdle);
    public void setMinIdle(int minIdle);
    public void setTestOnBorrow(boolean testOnBorrow);
}

// Client configuration interface
public interface JedisClientConfig {
    int getConnectionTimeoutMillis();
    int getSoTimeoutMillis();
    String getUser();
    String getPassword();
    int getDatabase();
    String getClientName();
    boolean isSsl();
}

// Server endpoint representation
public class HostAndPort {
    public HostAndPort(String host, int port);
    public String getHost();
    public int getPort();
}

Connection Management

Commands and Operations

Comprehensive Redis command support organized by data types.

// String operations
public interface StringCommands {
    String set(String key, String value);
    String set(String key, String value, SetParams params);
    String get(String key);
    String getSet(String key, String value);
    Long incr(String key);
    Long incrBy(String key, long increment);
    Double incrByFloat(String key, double increment);
}

// Hash operations
public interface HashCommands {
    Long hset(String key, String field, String value);
    Long hset(String key, Map<String, String> hash);
    String hget(String key, String field);
    Map<String, String> hgetAll(String key);
    Long hdel(String key, String... fields);
    Boolean hexists(String key, String field);
}

// List operations
public interface ListCommands {
    Long lpush(String key, String... strings);
    Long rpush(String key, String... strings);
    String lpop(String key);
    String rpop(String key);
    List<String> lrange(String key, long start, long stop);
    Long llen(String key);
}

Commands and Operations

Clustering and High Availability

Redis Cluster support with automatic failover and multi-cluster scenarios.

// Cluster commands interface
public interface ClusterCommands {
    String clusterNodes();
    String clusterInfo();
    List<String> clusterGetKeysInSlot(int slot, int count);
    Long clusterCountKeysInSlot(int slot);
    String clusterFailover(ClusterFailoverOption failoverOption);
}

// Sentinel pool for high availability
public class JedisSentinelPool extends Pool<Jedis> {
    public JedisSentinelPool(String masterName, Set<String> sentinels);
    public JedisSentinelPool(String masterName, Set<String> sentinels, JedisPoolConfig poolConfig);
    public JedisSentinelPool(String masterName, Set<String> sentinels, JedisClientConfig clientConfig);
}

// Multi-cluster failover configuration
public class MultiClusterClientConfig {
    public static class Builder {
        public Builder fallbackExceptionList(List<Class<? extends Exception>> fallbackExceptionList);
        public Builder circuitBreakerSlidingWindowSize(int circuitBreakerSlidingWindowSize);
        public Builder circuitBreakerFailureRateThreshold(float circuitBreakerFailureRateThreshold);
        public MultiClusterClientConfig build();
    }
}

Clustering and High Availability

Pub/Sub Messaging

Redis publish/subscribe messaging with support for pattern subscriptions.

// Pub/Sub message handler
public abstract class JedisPubSub {
    public abstract void onMessage(String channel, String message);
    public abstract void onPMessage(String pattern, String channel, String message);
    public abstract void onSubscribe(String channel, int subscribedChannels);
    public abstract void onUnsubscribe(String channel, int subscribedChannels);
    public void subscribe(String... channels);
    public void psubscribe(String... patterns);
    public void unsubscribe(String... channels);
    public void punsubscribe(String... patterns);
}

// Binary pub/sub for non-text data
public abstract class BinaryJedisPubSub {
    public abstract void onMessage(byte[] channel, byte[] message);
    public abstract void onPMessage(byte[] pattern, byte[] channel, byte[] message);
    public void subscribe(byte[]... channels);
    public void psubscribe(byte[]... patterns);
}

Pub/Sub Messaging

Transactions and Pipelining

ACID transactions and command pipelining for performance optimization.

// Transaction support
public class Transaction implements AutoCloseable {
    public Response<String> set(String key, String value);
    public Response<String> get(String key);
    public Response<Long> incr(String key);
    public List<Object> exec();
    public String discard();
    public void close();
}

// Command pipelining
public class Pipeline implements AutoCloseable {
    public Response<String> set(String key, String value);
    public Response<String> get(String key);
    public Response<Long> incr(String key);
    public void sync();
    public List<Object> syncAndReturnAll();
    public void close();
}

// Pipeline response wrapper
public class Response<T> {
    public T get();
    public boolean isSet();
}

Transactions and Pipelining

Redis Modules

Full support for Redis modules including RediSearch, RedisJSON, Bloom filters, and TimeSeries.

// RediSearch commands
public interface RediSearchCommands {
    String ftCreate(String indexName, IndexOptions indexOptions, Schema schema);
    SearchResult ftSearch(String indexName, String query);
    SearchResult ftSearch(String indexName, Query query);
    AggregationResult ftAggregate(String indexName, AggregationBuilder aggr);
}

// RedisJSON commands  
public interface RedisJsonCommands {
    String jsonSet(String key, Path path, Object object);
    <T> T jsonGet(String key, Class<T> clazz);
    <T> T jsonGet(String key, Class<T> clazz, Path... paths);
    Long jsonDel(String key, Path path);
}

// Bloom filter commands
public interface BloomFilterCommands {
    String bfReserve(String key, double errorRate, long capacity);
    Boolean bfAdd(String key, String item);
    Boolean bfExists(String key, String item);
    List<Boolean> bfMAdd(String key, String... items);
}

Redis Modules

Parameters and Configuration

Type-safe parameter objects for configuring Redis commands.

// SET command parameters
public class SetParams implements IParams {
    public SetParams ex(long secondsToExpire);
    public SetParams px(long millisecondsToExpire);
    public SetParams nx();
    public SetParams xx();
    public SetParams keepTtl();
}

// SCAN parameters
public class ScanParams implements IParams {
    public ScanParams match(String pattern);
    public ScanParams count(int count);
    public ScanParams type(String type);
}

// Sorted set parameters
public class ZAddParams implements IParams {
    public ZAddParams nx();
    public ZAddParams xx(); 
    public ZAddParams ch();
    public ZAddParams incr();
}

Parameters and Configuration

Exception Handling

Comprehensive exception hierarchy for robust error handling.

// Base Jedis exception
public class JedisException extends RuntimeException {
    public JedisException(String message);
    public JedisException(String message, Throwable cause);
}

// Connection related exceptions
public class JedisConnectionException extends JedisException {
    public JedisConnectionException(String message);
    public JedisConnectionException(String message, Throwable cause);
}

// Cluster specific exceptions
public class JedisClusterException extends JedisException {
    public JedisClusterException(String message);
}

public class JedisMovedDataException extends JedisRedirectionException {
    public JedisMovedDataException(String message, HostAndPort targetNode, int slot);
    public HostAndPort getTargetNode();
    public int getSlot();
}

Exception Handling

Client-Side Caching

High-performance client-side caching support for improved response times and reduced server load.

// Cache interface for client-side caching
public interface Cache {
    void flush();
    void flushAll();
    void invalidate(CacheKey key);
    Cacheable getValue(CacheKey key);
    void setValue(CacheKey key, Cacheable value);
    CacheStats getStats();
}

// Cache configuration
public class CacheConfig {
    public CacheConfig(int maxSize, int ttlSeconds);
    public CacheConfig maxSize(int maxSize);
    public CacheConfig ttl(int ttlSeconds);
    public CacheConfig evictionPolicy(EvictionPolicy evictionPolicy);
}

// Default cache implementation
public class DefaultCache implements Cache {
    public DefaultCache(int maxSize);
    public DefaultCache(CacheConfig config);
}

// Cache entry wrapper
public class CacheEntry {
    public Object getValue();
    public long getTimestamp();
    public boolean isExpired();
}

Client-Side Caching

Authentication

Token-based authentication and advanced security features.

// Authentication manager for token-based auth
public class AuthXManager {
    public AuthXManager(RedisCredentialsProvider credentialsProvider);
    public void authenticate(Connection connection);
    public void refreshToken();
}

// Token credentials
public class TokenCredentials implements RedisCredentials {
    public TokenCredentials(String token);
    public String getToken();
}

// Authentication exception
public class JedisAuthenticationException extends JedisException {
    public JedisAuthenticationException(String message);
}

Authentication

Response Types

// Scan result wrapper
public class ScanResult<T> {
    public String getCursor();
    public List<T> getResult();
}

// Sorted set member with score
public class Tuple {
    public String getElement();
    public double getScore();
}

// Stream entry
public class StreamEntry {
    public StreamEntryID getID();
    public Map<String, String> getFields();
}

// Geospatial response
public class GeoRadiusResponse {
    public String getMember();
    public double getDistance();
    public GeoCoordinate getCoordinate();
    public long getHash();
}

Key Features

Multiple Deployment Patterns: Single instance, cluster, sentinel, and sharded configurations
Connection Pooling: Production-ready connection pool management with Apache Commons Pool
Full Redis Support: All Redis commands and data types with type-safe APIs
Module Integration: Native support for RediSearch, RedisJSON, Bloom filters, and TimeSeries
Performance Optimization: Pipelining and transaction support for high-throughput scenarios
High Availability: Automatic failover with Redis Sentinel and Cluster
Client-Side Caching: Built-in caching support with configurable eviction policies and TTL
Token-Based Authentication: Advanced authentication with AuthX support including Microsoft EntraID
SSL/TLS Support: Secure connections with certificate validation
Authentication: Support for Redis ACL, legacy AUTH commands, and token-based authentication
Monitoring: Integration with Redis MONITOR and slow log

Version

Tile

Files

tessl/maven-redis-clients--jedis

To install, run

index.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Jedis Redis Java Client

Package Information

Core Imports

Basic Usage

Architecture

Capabilities

Core Client Classes

Connection Management

Commands and Operations

Clustering and High Availability

Pub/Sub Messaging

Transactions and Pipelining

Redis Modules

Parameters and Configuration

Exception Handling

Client-Side Caching

Authentication

Response Types

Key Features

index.mddocs/