Lettuce is an MIT-licensed, thread-safe Java Redis client from the Redis organization that speaks to Redis over synchronous, asynchronous, and reactive APIs, and it is aimed at Java teams running Redis or Redis-compatible caches such as AWS ElastiCache and Azure Redis Cache.

What it is

Lettuce is a scalable, thread-safe Redis client for Java, built on the Netty event-loop and networking framework. It exposes three programming models over the same connection: a synchronous API, an asynchronous API, and a reactive API, and it supports advanced Redis topologies and features including Redis Sentinel, Redis Cluster, Pipelining, Auto-Reconnect, and the Redis data models. The client also covers protocol and connection details such as SSL connections, Unix Domain Socket connections, a Streaming API, Codecs for UTF8, bit, and JSON representations of data, multiple Command Interfaces, and support for Native Transports. This version has been tested against the latest Redis source-build, and it is compatible with Java 8 and later, shipping as an implicit automatic module without descriptors.

The concrete problem it replaces is hand-rolled or thread-bound Redis access in JVM services. Rather than forcing a connection per thread or a pool discipline that has to be managed around every call, Lettuce lets multiple threads share one connection, provided those threads avoid blocking and transactional operations such as BLPOP and MULTI/EXEC. In the Java ecosystem that means a team writes its Redis access against one client library that scales with the application's concurrency model instead of against connection management code that has to be tuned and repaired per service.

Key capabilities

• Synchronous, asynchronous, and reactive APIs over a single shared connection, so an application can mix blocking calls, CompletableFuture-style results, and reactive streams without a second client.
• Redis Sentinel and Redis Cluster support for high-availability and sharded deployments, configured through the client rather than through bespoke routing code.
• Pipelining, which batches commands without waiting for individual replies, plus Auto-Reconnect to re-establish connections after a failure.
• SSL connections and Unix Domain Socket connections for encrypted or host-local access.
• Codecs for UTF8, bit, and JSON representations of data, controlling how keys and values are serialized onto the wire.
• Streaming API and multiple Command Interfaces, for consuming Redis Streams and for choosing how commands are expressed in code.
• Support for RediSearch, RedisJSON, and Redis Vector Sets, extending the client beyond core Redis commands.

Who uses it and how

• JVM services that must serve many concurrent requests against one Redis connection rather than paying for a connection per thread.
• Applications deployed against managed Redis endpoints, indicated by the aws-elasticache and azure-redis-cache topics, where the client handles topology and failover rather than application code.
• Sharded or replicated production deployments using Redis Cluster or Redis Sentinel for failover.
• Teams building reactive or asynchronous pipelines, using the reactive and asynchronous topics to match the client to a non-blocking application stack.
• Applications that store structured values, using JSON codecs and RedisJSON, or that run search and vector workloads through RediSearch and Redis Vector Sets.

Getting started

Add the Maven Central artifact io.lettuce:lettuce-core to a build — dependency information is published for Maven, Ivy, Gradle, and other build tools — or download a release from the project's Releases page. Reference documentation lives at https://redis.github.io/lettuce/ and the Javadoc at https://www.javadoc.io/doc/io.lettuce/lettuce-core/latest/index.html.

How it compares

This registry entry provides no list of paid products that Lettuce replaces and names no comparable Java Redis clients, so on the facts available it stands alone here rather than sitting in a documented head-to-head set. What is certain from the licence field and README is that it is MIT-licensed open source from the Redis organization itself, with no cost model, seat count, or hosted-service dependency attached, and it can be pointed at any Redis endpoint the operator controls, including self-managed clusters and cloud caches.

When to use it — and when not to

Choose Lettuce when a Java service needs one thread-safe client with synchronous, asynchronous, and reactive access and support for Cluster or Sentinel. Operators take on the Redis deployment itself — servers, topology, failover configuration, and any TLS material for SSL connections — because the client carries no bundled database, storage layer, or mail service. Teams that only make a handful of blocking calls and cannot rely on the shared-connection rule for blocking or transactional commands such as BLPOP and MULTI/EXEC should confirm their usage pattern fits before adopting it, and the 204 open issues are worth reviewing for known rough edges in the areas being used.

<dependency>
  <groupId>io.lettuce</groupId>
  <artifactId>lettuce-core</artifactId>
  <version>x.y.z</version>
</dependency>

<dependency>
  <groupId>io.lettuce</groupId>
  <artifactId>lettuce-core</artifactId>
  <version>x.y.z.BUILD-SNAPSHOT</version>
</dependency>

<repositories>
  <repository>
    <id>sonatype-snapshots</id>
    <name>Sonatype Snapshot Repository</name>
    <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
    <snapshots>
      <enabled>true</enabled>
    </snapshots>
  </repository>
</repositories>

RedisClient client = RedisClient.create("redis://localhost");
StatefulRedisConnection<String, String> connection = client.connect();
RedisStringCommands sync = connection.sync();
String value = sync.get("key");

StatefulRedisConnection<String, String> connection = client.connect();
RedisStringAsyncCommands<String, String> async = connection.async();
RedisFuture<String> set = async.set("key", "value");
RedisFuture<String> get = async.get("key");

LettuceFutures.awaitAll(set, get) == true

set.get() == "OK"
get.get() == "value"

StatefulRedisConnection<String, String> connection = client.connect();
RedisStringReactiveCommands<String, String> reactive = connection.reactive();
Mono<String> set = reactive.set("key", "value");
Mono<String> get = reactive.get("key");

set.subscribe();

get.block() == "value"

RedisPubSubCommands<String, String> connection = client.connectPubSub().sync();
connection.getStatefulConnection().addListener(new RedisPubSubListener<String, String>() { ... })
connection.subscribe("channel");

$ git clone https://github.com/redis/lettuce.git
$ cd lettuce/
$ make start