# lettucemod

**Repository Path**: calm4wei/lettucemod

## Basic Information

- **Project Name**: lettucemod
- **Description**: lettuce支持的redissearch等redis扩展模块客户端
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-04-08
- **Last Updated**: 2024-04-08

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

= LettuceMod
:linkattrs:
:icons: font
:project-owner:   redis-developer
:project-name:    lettucemod
:project-group:   com.redis
:project-version: 3.8.0

image:https://github.com/{project-owner}/{project-name}/actions/workflows/early-access.yml/badge.svg["Build Status",link="https://github.com/{project-owner}/{project-name}/actions"]
image:https://img.shields.io/maven-central/v/{project-group}/{project-name}[Download,link="https://search.maven.org/#search|ga|1|{project-name}"]
image:https://img.shields.io/github/license/{project-owner}/{project-name}["License",link="https://github.com/{project-owner}/{project-name}"]
image:https://codecov.io/gh/{project-owner}/{project-name}/branch/master/graph/badge.svg?token=A5IX98M8JT["Coverage",link="https://codecov.io/gh/{project-owner}/{project-name}"]
image:https://img.shields.io/badge/Forum-Modules-blue["forum",link=https://forum.redis.com/c/modules/]

LettuceMod is a Java client for https://redis.io/docs/about/about-stack/[Redis Stack] based on https://lettuce.io[Lettuce].
It supports the following Redis Stack features:

* https://redis.io/docs/data-types/json/[JSON data type] (storing, updating, and fetching)
* https://redis.io/docs/interact/search-and-query/[Search and query] of hashes and JSON documents
* https://redis.io/docs/data-types/timeseries/[Time series] data support
* https://redis.io/docs/data-types/probabilistic/[Probabilistic data structures]
** https://redis.io/docs/data-types/probabilistic/bloom-filter/[Bloom filter]
** https://redis.io/docs/data-types/probabilistic/cuckoo-filter/[Cuckoo filter]
** https://redis.io/docs/data-types/probabilistic/t-digest/[t-digest]
** https://redis.io/docs/data-types/probabilistic/top-k/[Top-K]
** https://redis.io/docs/data-types/probabilistic/count-min-sketch/[Count-min sketch]

== Getting Started

=== Java

.Maven
[source,xml,subs="verbatim,attributes"]
----
<dependency>
    <groupId>{project-group}</groupId>
    <artifactId>{project-name}</artifactId>
    <version>{project-version}</version>
</dependency>
----

.Gradle
[source,groovy,subs="verbatim,attributes"]
----
dependencies {
    implementation '{project-group}:{project-name}:{project-version}'
}
----

=== Spring

.Maven
[source,xml,subs="verbatim,attributes"]
----
<dependency>
    <groupId>{project-group}</groupId>
    <artifactId>spring-lettucemod</artifactId>
    <version>{project-version}</version>
</dependency>
----

.Gradle
[source,groovy,subs="verbatim,attributes"]
----
dependencies {
    implementation '{project-group}:spring-lettucemod:{project-version}'
}
----

=== Snapshot Releases

For early-access releases use the following repository:

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

.Maven
[source,xml]
----
<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
[source,groovy]
----
repositories {
    maven {
        url "https://s01.oss.sonatype.org/content/repositories/snapshots/"
    }
}
----

== Usage

=== Java

==== Standalone Client

[source,java]
----
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

[source,java]
----
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

[source,java]
----
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

[source,java]
----
@Component
public class MyComponent {

    @Autowired
    StatefulRedisModulesConnection<String, String> connection;

    // ...
}
----

==== Connection Pool

[source,java]
----
@Component
public class MyComponent {

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

    // ...
}
----

=== Commands

[source,java]
----
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

[source,java]
----
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

[source,java]
----
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