LettuceMod

LettuceMod is a Java client for Redis Stack based on Lettuce. It supports the following Redis Stack features:

• JSON data type (storing, updating, and fetching)

• Search and query of hashes and JSON documents

• Time series data support

• Probabilistic data structures

  • Bloom filter

  • Cuckoo filter

  • t-digest

  • Top-K

  • Count-min sketch

Getting Started

Java

Maven

<dependency>
    <groupId>com.redis</groupId>
    <artifactId>lettucemod</artifactId>
    <version>3.8.0</version>
</dependency>

Gradle

dependencies {
    implementation 'com.redis:lettucemod:3.8.0'
}

Spring

Maven

<dependency>
    <groupId>com.redis</groupId>
    <artifactId>spring-lettucemod</artifactId>
    <version>3.8.0</version>
</dependency>

Gradle

dependencies {
    implementation 'com.redis:spring-lettucemod:3.8.0'
}

Snapshot Releases

For early-access releases use the following repository:

https://s01.oss.sonatype.org/content/repositories/snapshots/

Maven

<repositories>
   <repository>
      <id>oss.sonatype.org-snapshot</id>
         <url>https://s01.oss.sonatype.org/content/repositories/snapshots</url>
         <releases>
            <enabled>false</enabled>
         </releases>
         <snapshots>
           <enabled>true</enabled>
         </snapshots>
   </repository>
</repositories>

Gradle

repositories {
    maven {
        url "https://s01.oss.sonatype.org/content/repositories/snapshots/"
    }
}

Usage

Java

Standalone Client

RedisModulesClient client = RedisModulesClient.create("redis://localhost:6379"); // (1)
StatefulRedisModulesConnection<String, String> connection = client.connect(); // (2)
RedisModulesCommands<String, String> commands = connection.sync(); // (3)

1. Create a modules client

2. Connect to Redis server

Cluster Client

List<RedisURI> uris = Arrays.asList(RedisURI.create("node1", 6379), RedisURI.create("node2", 6379)); // (1)
RedisModulesClusterClient client = RedisModulesClusterClient.create(uris); // (2)
StatefulRedisModulesClusterConnection<String, String> connection = client.connect(); // (3)
RedisModulesAdvancedClusterCommands<String, String> commands = connection.sync(); // (4)

1. Create list of cluster node URIs

2. Create a cluster client

3. Connect to Redis servers

4. Use the sync, async, or reactive API

Connection Pool

GenericObjectPoolConfig<StatefulRedisModulesConnection<String, String>> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(4); // (1)
// ...
GenericObjectPool<StatefulRedisModulesConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(client::connect, config); // (2)

1. Create a pool configuration

2. Create the connection pool

Spring

Client

@Component
public class MyComponent {

    @Autowired
    StatefulRedisModulesConnection<String, String> connection;

    // ...
}

Connection Pool

@Component
public class MyComponent {

    @Autowired
    GenericObjectPool<StatefulRedisModulesConnection<String, String>> pool;

    // ...
}

Commands

RedisModulesCommands<String, String> commands = connection.sync();

// JSON.SET
commands.jsonSet("arr", ".", "[1,2,3]");

// FT.CREATE
commands.ftCreate("beers", Field.text("name").build(), Field.numeric("ibu").build());

// FT.SEARCH
commands.ftSearch("beers", "chou*");

// TS.ADD
commands.tsAdd("temp:3:11", Sample.of(1548149181, 30));

// BF.EXISTS
commands.bfExists("bloom:1", "test");

// CF.EXISTS
commands.cfExists("cuckoo:1", "one");

// CMS.QUERY
commands.cmsQuery("cms:1", "one", "two", "three");

// TDIGEST.RANK
commands.tDigestRank("tdigest:1", -5, 100, 5.3);

// TOPK.QUERY
commands.topKQuery("topk:1", "four", "three", "two", "foo");

Pipelining

RedisModulesAsyncCommands<String, String> commands = connection.async();
commands.setAutoFlushCommands(false); // (1)
List<RedisFuture<?>> futures = new ArrayList<>(); // (2)
for (MyEntity element : entities()) {
    futures.add(commands.ftSugadd("names",  Suggestion.of(element.getName(), element.getScore())));
}
commands.flushCommands(); // (3)
boolean result = LettuceFutures.awaitAll(5, TimeUnit.SECONDS,
        futures.toArray(new RedisFuture[0])); // (4)
connection.close(); // (5)

1. Disable auto-flushing

2. Perform a series of independent calls

3. Write all commands to the transport layer

4. Synchronization example: Wait until all futures complete

5. Later

Connection Pooling

GenericObjectPoolConfig<StatefulRedisModulesConnection<String, String>> config = new GenericObjectPoolConfig<>(); // (1)
config.setMaxTotal(16);
// ...
GenericObjectPool<StatefulRedisModulesConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(client::connect, config); // (2)
try (StatefulRedisModulesConnection<String, String> connection = pool.borrowObject()) { // (3)
    RedisModulesAsyncCommands<String, String> commands = connection.async(); // (4)
    // ...
} catch (Exception e) {
    log.error("Could not get a connection from the pool", e);
}

1. Create a pool configuration

2. Create the connection pool

3. Get connection from pool. Try-with automatically closes connection which returns it to pool

4. Use sync, async, or reactive commands