Java Clients (Jedis & Lettuce)

Connect to Redis from Java using Jedis or Lettuce, the official Java clients

Redis provides two official Java clients: Jedis and Lettuce. Both offer full support for Redis commands and features, but with different architectural approaches.

Choosing Between Jedis and Lettuce

Jedis

Best for: Simple, synchronous applications

• Easy to use
• Synchronous API
• Lower overhead
• Thread-safe with connection pooling

Lettuce

Best for: High-performance, async applications

• Reactive programming support
• Async and sync APIs
• Thread-safe connections
• Better for high concurrency

Jedis Client

Installation

Add Jedis to your project:

Maven

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.0</version>
</dependency>

Quick Start with Jedis

1. Create a connection

   Connect to Redis using Jedis:

   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisPool;
   import redis.clients.jedis.JedisPoolConfig;
   
   public class RedisExample {
       public static void main(String[] args) {
           // Create connection pool
           JedisPoolConfig poolConfig = new JedisPoolConfig();
           poolConfig.setMaxTotal(10);
           poolConfig.setMaxIdle(5);
           poolConfig.setMinIdle(1);
           
           JedisPool pool = new JedisPool(poolConfig, "localhost", 6379);
           
           // Get a connection from the pool
           try (Jedis jedis = pool.getResource()) {
               String response = jedis.ping();
               System.out.println("Connected: " + response);
           }
           
           pool.close();
       }
   }
   

   Always use JedisPool in production applications. It manages connections efficiently and is thread-safe.

2. Perform basic operations

   Execute Redis commands:

   try (Jedis jedis = pool.getResource()) {
       // SET and GET operations
       jedis.set("user:1:name", "Alice");
       String name = jedis.get("user:1:name");
       System.out.println("Name: " + name);  // Output: Name: Alice
       
       // Work with numbers
       jedis.set("counter", "0");
       jedis.incr("counter");
       jedis.incrBy("counter", 5);
       String count = jedis.get("counter");
       System.out.println("Counter: " + count);  // Output: Counter: 6
       
       // Expiration
       jedis.setex("session:abc", 3600, "session_data");  // Expires in 1 hour
   }
   
3. Handle errors

   Implement proper error handling:

   import redis.clients.jedis.exceptions.JedisConnectionException;
   import redis.clients.jedis.exceptions.JedisDataException;
   
   try (Jedis jedis = pool.getResource()) {
       jedis.set("key", "value");
       String value = jedis.get("key");
       System.out.println(value);
       
   } catch (JedisConnectionException e) {
       System.err.println("Connection error: " + e.getMessage());
   } catch (JedisDataException e) {
       System.err.println("Data error: " + e.getMessage());
   } catch (Exception e) {
       System.err.println("Unexpected error: " + e.getMessage());
   }
   

Jedis Connection Patterns

Secure TLS Connection

import redis.clients.jedis.DefaultJedisClientConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisClientConfig;

import javax.net.ssl.SSLParameters;
import javax.net.ssl.SSLSocketFactory;

SSLSocketFactory sslSocketFactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
SSLParameters sslParameters = new SSLParameters();

JedisClientConfig config = DefaultJedisClientConfig.builder()
    .password("your-password")
    .ssl(true)
    .sslSocketFactory(sslSocketFactory)
    .sslParameters(sslParameters)
    .build();

JedisPool pool = new JedisPool(
    new HostAndPort("your-redis-host.com", 6380),
    config
);

Redis Cloud Connection

JedisClientConfig config = DefaultJedisClientConfig.builder()
    .password("your-password")
    .ssl(true)
    .build();

JedisPool pool = new JedisPool(
    new HostAndPort("your-endpoint.redis.cloud", 12345),
    config
);

Working with Data Structures in Jedis

Hashes

import java.util.HashMap;
import java.util.Map;

try (Jedis jedis = pool.getResource()) {
    // Store user data as a hash
    Map<String, String> user = new HashMap<>();
    user.put("name", "Alice");
    user.put("email", "[e-mail]");
    user.put("age", "30");
    jedis.hset("user:1", user);
    
    // Get specific field
    String name = jedis.hget("user:1", "name");
    
    // Get all fields
    Map<String, String> userData = jedis.hgetAll("user:1");
    
    // Increment numeric field
    jedis.hincrBy("user:1", "age", 1);
}

Lists

try (Jedis jedis = pool.getResource()) {
    // Add items to a list
    jedis.rpush("queue", "task1", "task2", "task3");
    
    // Get list length
    long length = jedis.llen("queue");
    
    // Pop item from list
    String task = jedis.lpop("queue");
    
    // Get range of items
    List<String> tasks = jedis.lrange("queue", 0, -1);
}

Sets

try (Jedis jedis = pool.getResource()) {
    // Add members to a set
    jedis.sadd("tags", "python", "redis", "database");
    
    // Check membership
    boolean isMember = jedis.sismember("tags", "python");
    
    // Get all members
    Set<String> tags = jedis.smembers("tags");
    
    // Set operations
    jedis.sadd("tags2", "redis", "cache", "nosql");
    Set<String> common = jedis.sinter("tags", "tags2");
}

Jedis Advanced Features

Pipelining

try (Jedis jedis = pool.getResource()) {
    Pipeline pipe = jedis.pipelined();
    
    pipe.set("key1", "value1");
    pipe.set("key2", "value2");
    pipe.incr("counter");
    Response<String> value = pipe.get("key1");
    
    pipe.sync();  // Execute all commands
    
    System.out.println(value.get());  // value1
}

Transactions

try (Jedis jedis = pool.getResource()) {
    Transaction trans = jedis.multi();
    
    trans.set("key1", "value1");
    trans.set("key2", "value2");
    trans.incr("counter");
    
    List<Object> results = trans.exec();  // Execute atomically
}

Lettuce Client

Installation

Add Lettuce to your project:

Maven

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.3.0.RELEASE</version>
</dependency>

Quick Start with Lettuce

1. Create a connection

   Connect to Redis using Lettuce:

   import io.lettuce.core.RedisClient;
   import io.lettuce.core.RedisURI;
   import io.lettuce.core.api.StatefulRedisConnection;
   import io.lettuce.core.api.sync.RedisCommands;
   
   public class LettuceExample {
       public static void main(String[] args) {
           // Create Redis client
           RedisURI redisUri = RedisURI.builder()
               .withHost("localhost")
               .withPort(6379)
               .build();
           
           RedisClient client = RedisClient.create(redisUri);
           StatefulRedisConnection<String, String> connection = client.connect();
           RedisCommands<String, String> commands = connection.sync();
           
           String response = commands.ping();
           System.out.println("Connected: " + response);
           
           connection.close();
           client.shutdown();
       }
   }
   
2. Perform basic operations

   Execute Redis commands synchronously:

   // SET and GET operations
   commands.set("user:1:name", "Alice");
   String name = commands.get("user:1:name");
   System.out.println("Name: " + name);
   
   // Work with numbers
   commands.set("counter", "0");
   commands.incr("counter");
   commands.incrby("counter", 5);
   String count = commands.get("counter");
   System.out.println("Counter: " + count);
   
   // Expiration
   commands.setex("session:abc", 3600, "session_data");
   
3. Use async operations

   Leverage Lettuce’s asynchronous API:

   import io.lettuce.core.api.async.RedisAsyncCommands;
   import io.lettuce.core.RedisFuture;
   
   RedisAsyncCommands<String, String> async = connection.async();
   
   RedisFuture<String> future = async.get("key");
   
   future.thenAccept(value -> {
       System.out.println("Value: " + value);
   });
   
   // Wait for completion if needed
   String result = future.get();
   

Lettuce Reactive API

For reactive programming with Project Reactor:

import io.lettuce.core.api.reactive.RedisReactiveCommands;
import reactor.core.publisher.Mono;

RedisReactiveCommands<String, String> reactive = connection.reactive();

Mono<String> mono = reactive.get("key");

mono.subscribe(
    value -> System.out.println("Value: " + value),
    error -> System.err.println("Error: " + error),
    () -> System.out.println("Completed")
);

Starter Project

Redis Java Starter Project

Clone the official starter project with Spring Boot, Jedis examples, and best practices.

Additional Resources

Jedis Documentation

Official Jedis documentation

Lettuce Documentation

Official Lettuce documentation

Redis Commands

Complete Redis command reference

Data Types Guide

Learn about Redis data structures