Redis Extension Reference Guide

Use the Redis Client

如果你想使用此扩展，则需要首先添加 io.quarkus:quarkus-redis 扩展。在你的 pom.xml 文件中，添加：

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-redis-client</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-redis-client")

使用此依赖项，你之后可以注入 Redis 客户端或 datasource（高级、类型安全 API），例如：

import io.quarkus.redis.datasource.RedisDataSource;

// ...
@Inject RedisAPI lowLevelClient;
@Inject RedisDataSource highLevelApi;

One extension, multiple APIs 部分提供了有关 quarkus-redis 扩展提供的各种 API 的更多详细信息。

如需将 Redis 用作缓存后端，请参阅 Redis Cache Backend reference。

One extension, multiple APIs

此扩展提供了多种与 Redis 交互的方式：

  • low-level Vert.x 客户端：这是一个完全反应式、非阻塞和异步的客户端。有关 the Vert.x Redis Client documentation 的更多详细信息。公开了两个 API： io.vertx.redis.client.Redis，和 io.vertx.redis.client.RedisAPI。除非你需要自己管理连接，否则通常会使用后者。

  • Vert.x API 的 low-level Mutiny 变体：与前一个不同，它公开了 Mutiny API 并提供了反应方法和命令式方法（后缀为 andAwait()）。公开了两个 API： io.vertx.mutiny.redis.client.Redis 和 io.vertx.mutiny.redis.client.RedisAPI。除非你需要自己管理连接，否则通常会使用后者。

  • high-level 反应数据源：一个类型安全的、高级 API 用于与 Redis 交互。此 API 完全是反应式且异步的。它公开了 Mutiny API。它公开了 io.quarkus.redis.datasource.ReactiveRedisDataSource 接口。

  • high-level 命令式数据源：一个类型安全的、高级 API 用于与 Redis 交互。它是反应数据源的命令式变体。它公开了 io.quarkus.redis.datasource.RedisDataSource 接口。

为了帮助你选择适合自己的 API，这里有几点建议：

  • 如果你正在构建一个命令式（classic）Quarkus 应用程序并与 Redis 集成：使用 io.quarkus.redis.datasource.RedisDataSource。

  • 如果你正在构建一个反应式 Quarkus 应用程序并与 Redis 集成：使用 io.quarkus.redis.datasource.ReactiveRedisDataSource。

  • 如果你需要精细化控制或以通用的方式执行命令：使用 io.vertx.mutiny.redis.client.RedisAPI

  • 如果你有现有的 Vert.x 代码，使用 io.vertx.redis.client.RedisAPI

  • 如果你需要发出自定义命令，你可以使用数据源（反应式或命令式），也可以使用 io.vertx.mutiny.redis.client.Redis。

[id="inject-the-default-and-named-clients"] Inject the default and named clients

此扩展允许你配置 default Redis 客户端/数据源或 named 客户端/数据源。当你需要连接到多个 Redis 实例时，后者至关重要。

使用 quarkus.redis.* 属性配置默认连接。例如，要配置默认 Redis 客户端，请使用：

quarkus.redis.hosts=redis://localhost/

使用默认连接时，你可以使用 plain @Inject 注入各种 API：

@ApplicationScoped
public class RedisExample {
    @Inject ReactiveRedisDataSource reactiveDataSource;
    @Inject RedisDataSource redisDataSource;
    @Inject RedisAPI redisAPI;
    // ...
}

通常，你注入一个；前面的代码段只是一个示例。

Named 客户端使用 quarkus.redis.<name>.* 属性配置：

quarkus.redis.my-redis-1.hosts=redis://localhost/
quarkus.redis.my-redis-2.hosts=redis://my-other-redis:6379

要访问 API，你需要使用 @RedisClientName 限定符：

@ApplicationScoped
public class RedisExample {
    @Inject @RedisClientName("my-redis-1") ReactiveRedisDataSource reactiveDataSource;
    @Inject @RedisClientName("my-redis-2") RedisDataSource redisDataSource;
    // ...
}

使用 @RedisClientName 时，您可以省略 @Inject 注释。

Connect to the Redis server

Redis 扩展程序可以使用 4 种不同的模式：

  • 简单客户端（可能是大多数用户需要的内容）。

  • 哨兵（在高可用性模式下使用 Redis 时）。

  • 集群（在集群模式下使用 Redis 时）。

  • 复制（单分片，一个节点写入，多个读取）。

连接 URL 使用 quarkus.redis.hosts （或 quarkus.redis.<name>.hosts）配置如下：

quarkus.redis.hosts=redis://[:password@]host[:port][/db-number]

Use Unix Socket

使用 Unix 套接字时，您需要：

quarkus.redis.hosts=unix://[:password@]/domain/docker.sock[?select=db-number]

Use the Sentinel Mode

使用 Sentinel 时，您需要传递多个 host urls 并将客户端类型配置为 sentinel：

quarkus.redis.hosts=redis://localhost:5000,redis://localhost:5001,redis://localhost:5002
quarkus.redis.client-type=sentinel

# Optional
quarkus.redis.master-name=my-sentinel # Default is mymaster
quarkus.redis.role=master # master is the default

此处的主机 URL 必须是哨兵服务器。客户端将从其中一个哨兵获取实际 Redis 服务器（主服务器或副本，取决于 role）的 URL，使用 master-name 作为“主服务器集”的标识符。

请注意，您实际上永远不想配置 quarkus.redis.role=sentinel。此设置意味着 Redis 客户端将在哨兵服务器之一上直接执行命令，而不是在哨兵守护的实际 Redis 服务器上。

Use the Cluster Mode

在集群模式下使用 Redis 时，您需要传递多个 host urls，将客户端类型配置为 cluster 并配置 replicas 模式：

quarkus.redis.hosts=redis://localhost:7000,redis://localhost:7001,redis://localhost:7002
quarkus.redis.client-type=cluster

# Optional
quarkus.redis.replicas=share # defaults to "never"

此处的主机 URL 必须是集群成员中的部分成员。并非所有集群成员都需要进行配置，因为客户端将从已知服务器之一获取完整的集群拓扑。但是，建议配置至少 2 个或 3 个节点，而不仅仅是 1 个。

默认情况下，所有命令都将发送到主节点（如果命令有密钥，则它是拥有该密钥的分片的主节点，否则是随机主节点）。可以将 Redis 客户端配置为向副本节点发送只读命令（查询）。将 quarkus.redis.replicas 配置属性设置为：

  • never：从不使用副本节点，始终向主节点发送查询（这是默认设置）

  • always：始终使用副本节点（如果分片中有多个副本，则随机选择一个），从不向主节点发送查询

  • share：使用主节点和副本节点来执行查询（为每个查询选择的特定节点随机选择）

请注意，Redis 中的复制是异步的，因此副本节点可能落后于其主节点。

Use the Replication Mode

在使用复制模式时，您需要传递单个主机 URL 并将类型配置为 replication：

quarkus.redis.hosts=redis://localhost:7000
quarkus.redis.client-type=replication

# Optional
quarkus.redis.replicas=share # defaults to "never"

默认情况下，所有命令都发送至主节点。可以将 Redis 客户端配置为向副本节点发送只读命令（查询）。将 quarkus.redis.replicas 配置属性设置为：

  • never：从不使用副本节点，始终向主节点发送查询（这是默认值）

  • always：始终使用副本节点（如果有多个副本，会随机选择一个），从不向主节点发送查询

  • share：使用主节点和副本节点来执行查询（为每个查询选择的特定节点随机选择）

请注意，Redis 中的复制是异步的，因此副本节点可能落后于主节点。

Connect to Redis Cloud

要连接到 Redis Cloud，你需要以下属性：

quarkus.redis.hosts=<the redis cloud url such as redis://redis-12436.c14.us-east-1-3.ec2.cloud.redislabs.com:12436>
quarkus.redis.password=<the password>

Use TLS

要使用 TLS，你需要：

  1. 设置 quarkus.redis.tls.enabled=true 属性或使用 TLS registry （推荐）

  2. 确保 URL 以 rediss:// （两个 s）开头

使用 TLS 注册表时，需要使用具名配置以避免与其他 TLS 配置发生冲突：

quarkus.tls.redis.trust-store.p12.path=client.p12
quarkus.tls.redis.trust-store.p12.password=secret

quarkus.redis.tls-configuration-name=redis # Reference the named configuration

默认主机名验证器设置为 NONE，这意味着它不会验证主机名。你可以通过设置 quarkus.redis.tls.hostname-verification-algorithm 属性（如 HTTPS）来更改此行为。

Configure the authentication

Redis 密码可以设置在 redis:// URL 中或使用 quarkus.redis.password 属性设置。建议使用后者，如果可能，使用机密或环境变量来配置密码。

关联的环境变量是 QUARKUS_REDIS_PASSWORD，对于具名客户端则是 QUARKUS_REDIS_<NAME>_PASSWORD。

Connection pooling

与 Redis 的连接始终是池化的。默认情况下，池中最大连接数为 6。这可以通过 quarkus.redis.max-pool-size 配置。

当连接池耗尽时，获取连接的尝试会被放入队列。默认情况下，等待在队列中获取 Redis 连接的最大尝试次数为 24。这可以通过 quarkus.redis.max-pool-waiting 配置。

执行某些命令会修改服务器端状态和连接行为。这样的连接不能被重用，关闭时，它们不会被放回连接池；而是会彻底关闭。以下命令会导致此行为：

  • 订阅命令 (SUBSCRIBE、UNSUBSCRIBE 等)

  • SELECT

  • AUTH

Use Redis data sources

Quarkus 公开了一个位于 Redis 上的高级 API。此 API 类型安全，围绕 group 的概念构建，继承自 Redis command organization。此 API 可以更方便、安全地执行 Redis 命令。

Inject data sources

对于每个已配置的 Redis 客户端，会公开两个 Redis 数据源：

  • io.quarkus.redis.datasource.RedisDataSource - 强制（阻塞）Redis 数据源。每个操作都会阻塞，直到收到响应或超时

  • io.quarkus.redis.datasource.ReactiveRedisDataSource - 返回 Uni&lt;X&gt; 或 Multi&lt;X&gt; 的反应式 Redis 数据源。

如果您配置了 default Redis 客户端，则可以使用以下内容注入数据源：

@Inject RedisDataSource defaultRedisDataSource;
@Inject ReactiveRedisDataSource defaultReactiveRedisDataSource;

如果您配置了 named Redis 客户端，则需要使用 `io.quarkus.redis.RedisClientName`限定符来选择正确的客户端：

@RedisClientName("my-redis") RedisDataSource myRedisDataSource;
@RedisClientName("my-redis") ReactiveRedisDataSource myReactiveRedisDataSource;

当使用 blocking 变体时，您可以使用以下内容配置默认超时：

quarkus.redis.timeout=5s
quarkus.redis.my-redis.timeout=5s

默认超时配置为 10s。

All about delegation

阻塞数据源 (io.quarkus.redis.datasource.RedisDataSource) 是在反应式数据源 (io.quarkus.redis.datasource.ReactiveRedisDataSource) 的基础上实现的。ReactiveRedisDataSource 是在 io.vertx.mutiny.redis.Redis API 的基础上实现的。

Data Source groups

如上所述，API 分为以下几组：

  • bitmap - .bitmap()

  • key (generic) - .key()

  • geo - .geo(memberType)

  • hash - .hash(`valueType)

  • hyperloglog - .hyperloglog(memberType)

  • list - .list(memberType)

  • pubsub - pubsub()

  • set - .set(memberType)

  • sorted-set - .sortedSet(memberType)

  • string - .value(valueType)

  • stream - .stream(`valueType)

  • transactions - withTransaction

  • json - .json() (在服务器端需要 RedisJSON 模块)

  • bloom - .bloom() (在服务器端需要 RedisBloom 模块)

  • cuckoo - .cuckoo() (在服务器端需要 rRedisBloom 模块，该模块还提供布谷鸟过滤器命令)

  • count-min - .countmin() (在服务器端需要 RedisBloom 模块，该模块还提供计数最小过滤器命令)

  • top-k - .topk() (在服务器端需要 RedisBloom 模块，该模块还提供前 k 个过滤器命令)

  • graph - .graph() (在服务器端需要 RedisGraph 模块)。这些命令被标记为实验性的。此外，该模块已被 Redis 声明为 end of life。

  • search - .search() (在服务器端需要 RedisSearch 模块)。

  • auto-suggest - .autosuggest() (在服务器端需要 RedisSearch 模块)。

  • time-series - .timeseries() (在服务器端需要 Redis Time Series 模块)。

这些命令被标记为实验性的，因为我们需要在使命令稳定之前获得反馈。

这些方法中的每一个都返回一个允许您执行与该组相关的命令的对象。以下代码摘录演示了如何使用 hash 组：

@ApplicationScoped
public class MyRedisService {

    private static final String MY_KEY = "my-key";

    private final HashCommands<String, String, Person> commands;

    public MyRedisService(RedisDataSource ds) { (1)
        commands = ds.hash(Person.class); (2)
    }

    public void set(String field, Person value) {
        commands.hset(MY_KEY, field, value);  (3)
    }

    public Person get(String field) {
        return commands.hget(MY_KEY, field);  (4)
    }
}
1 在构造函数中注入 RedisDataSource
2 创建 `HashCommands`对象。该对象有三个类型参数：键的类型、字段的类型和成员的类型
3 使用已创建的 `commands`将字段 `field`与值 `value`关联
4 使用已创建的 `commands`检索字段 `field`的值。

Serializing and Deserializing data

数据源 API 会自动处理序列化和反序列化。默认情况下，非标准类型会被序列化为 JSON 并从 JSON 中反序列化。在这种情况下，将使用 quarkus-jackson。

Binary

要存储或检索二进制数据，请使用 byte[]。

Custom codec

你可以通过提供实现 `io.quarkus.redis.datasource.codecs.Codec`接口的 CDI _bean_来注册自定义编解码器：

import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;

import jakarta.enterprise.context.ApplicationScoped;

import io.quarkus.redis.datasource.codecs.Codec;

@ApplicationScoped
public class PersonCodec implements Codec {
    @Override
    public boolean canHandle(Type clazz) {
        return clazz.equals(Person.class);
    }

    @Override
    public byte[] encode(Object item) {
        var p = (Person) item;
        return (p.firstName + ";" + p.lastName.toUpperCase()).getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public Object decode(byte[] item) {
        var value = new String(item, StandardCharsets.UTF_8);
        var segments = value.split(";");
        return new Person(segments[0], segments[1]);
    }
}

方法 `canHandle`会被调用以检查该编解码器是否可以处理特定的类型。以 `encode`方法接收的参数与该类型匹配。以方法 `decode`返回的对象也必须与该类型匹配。

Use type reference

每个组都可以使用 Class，也可以使用 `TypeReference`对象进行配置。在处理 Java 泛型时，`TypeReference`非常有用：

@ApplicationScoped
public class MyRedisService {

    private static final String MY_KEY = "my-key";

    private final HashCommands<String, String, List<Person>> commands;

    public MyRedisService(RedisDataSource ds) {
        commands = ds.hash(new TypeReference<List<Person>>(){});
    }

    public void set(String field, List<Person> value) {
        commands.hset(MY_KEY, field, value);
    }

    public List<Person> get(String field) {
        return commands.hget(MY_KEY, field);
    }
}

使用事务时不能使用类型引用。这是一个已知限制。

Manipulate cached and binary data with the value group

组 `value`用于处理 Redis Strings。因此，该组不仅限于 Java 字符串，还可以用于整数（如计数器）或二进制内容（如图像）。

Work with cached values

يمكنك استخدام setex كذاكرة تخزين مؤقتة باستخدام أمر setex الذي يخزن قيمة معينة لمفتاح معين لمدة زمنية معينة. يُوضح الجزء التالي كيف يمكن استخدام هذا الأمر لتخزين BusinessObject لمدة ثانية واحدة.

@ApplicationScoped
public static class MyRedisCache {

    private final ValueCommands<String, BusinessObject> commands;

    public MyRedisCache(RedisDataSource ds) {
        commands = ds.value(BusinessObject.class);
    }

    public BusinessObject get(String key) {
        return commands.get(key);
    }

    public void set(String key, BusinessObject bo) {
        commands.setex(key, 1, bo); // Expires after 1 second
    }
}

يمكنك استخدام طريقة setnx فقط لتعيين القيمة إذا لم يتم تخزين أي قيمة للمفتاح المعطى.

توفر المجموعة key مزيدًا من التحكم الدقيق في انتهاء الصلاحية ووقت البقاء لكل مفتاح.

يمكن أن تتلقى طريقة set أيضًا وسيطة SetArgs التي تعدل السلوك:

  • ex(seconds) - تعيين وقت انتهاء الصلاحية المحدد، بالثواني.

  • px(milliseconds) - تعيين وقت انتهاء الصلاحية المحدد، بالمللي ثانية.

  • exat(timestamp-seconds) - تعيين وقت يونكس المحدد الذي سينتهي فيه صلاحية المفتاح، بالثواني.

  • pxat(timestamp-milliseconds) - تعيين وقت يونكس المحدد الذي سينتهي فيه صلاحية المفتاح، بالمللي ثانية.

  • nx() - تعيين المفتاح فقط إذا لم يكن موجودًا بالفعل.

  • xx() - 如果键已存在，则只设置键。

  • keepttl() - 保留与键关联的生存时间。

Store binary data

Redis strings 可用于存储二进制数据，例如图像。在这种情况下，我们将 byte[] 用作值类型：

@ApplicationScoped
public static class MyBinaryRepository {

    private final ValueCommands<String, byte[]> commands;

    public MyBinaryRepository(RedisDataSource ds) {
        commands = ds.value(byte[].class);
    }

    public byte[] get(String key) {
        byte[] bytes = commands.get(key);
        if (bytes == null) {
            throw new NoSuchElementException("`" + key + "` not found");
        }
        return bytes;
    }

    public void add(String key, byte[] bytes) {
        commands.set(key, bytes);
    }

    public void addIfAbsent(String key, byte[] bytes) {
        commands.setnx(key, bytes);
    }
}

Store a counter

您可以在 Redis 中存储计数器，如下所示：

@ApplicationScoped
public static class MyRedisCounter {

    private final ValueCommands<String, Long> commands;

    public MyRedisCounter(RedisDataSource ds) {
        commands = ds.value(Long.class); (1)
    }

    public long get(String key) {
        Long l = commands.get(key);  (2)
        if (l == null) {
            return 0L;
        }
        return l;
    }

    public void incr(String key) {
        commands.incr(key);  (3)
    }

}
1 检索命令。这次我们将处理 Long 值
2 检索与给定 key 关联的计数器。当未存储计数器时，返回 0L。
3 增加值。如果键没有存储计数器，incr 命令将 0 视为值（因此 incr 将值设为 1）。

还有其他方法可用于处理计数器，例如：

  • incrby - 允许设置增量值（正值或负值）

  • incrbyfloat - 允许将增量值设为浮点数/双精度数（存储的值将为双精度数）

  • set - 在需要时设置初始值

  • decr 和 decrby - 允许递减存储的值

Communicate with pub/sub

Redis 允许向频道发送 messages 并监听这些消息。这些功能可在 pubsub 组中获得。

以下代码段显示了 cache 如何在每次 set 后发出 Notification，以及订阅者如何接收通知。

public static final class Notification {
    public String key;
    public BusinessObject bo;

    public Notification() {

    }

    public Notification(String key, BusinessObject bo) {
        this.key = key;
        this.bo = bo;
    }
}

@ApplicationScoped
@Startup // We want to create the bean instance on startup to subscribe to the channel.
public static class MySubscriber implements Consumer<Notification> {
    private final PubSubCommands<Notification> pub;
    private final PubSubCommands.RedisSubscriber subscriber;

    public MySubscriber(RedisDataSource ds) {
        pub = ds.pubsub(Notification.class);
        subscriber = pub.subscribe("notifications", this);
    }

    @Override
    public void accept(Notification notification) {
        // Receive the notification
    }

    @PreDestroy
    public void terminate() {
        subscriber.unsubscribe(); // Unsubscribe from all subscribed channels
    }
}

@ApplicationScoped
public static class MyCache {

    private final ValueCommands<String, BusinessObject> commands;
    private final PubSubCommands<Notification> pub;

    public MyCache(RedisDataSource ds) {
        commands = ds.value(BusinessObject.class);
        pub = ds.pubsub(Notification.class);
    }

    public BusinessObject get(String key) {
        return commands.get(key);
    }

    public void set(String key, BusinessObject bo) {
        commands.set(key, bo);
        pub.publish("notifications", new Notification(key, bo));
    }
}

Use Redis transactions

Redis 事务与关系数据库事务略有不同。Redis 事务是一批同时执行的命令。

Redis 事务可以 watch 一组键，如果在事务执行期间更新了这些键中的一个，则 discard 事务。

在事务中排队的命令在整个事务执行之前不会执行。这意味着您无法在事务期间检索结果。结果累积在一个 TransactionResult 对象中，您将在事务完成后访问该对象。此对象包含事务是否成功或被丢弃，在前一种情况下还包含每条命令的结果（按命令顺序编制索引）。

要启动事务，您使用 withTransaction 方法。此方法接收一个 Consumer<TransactionalRedisDataSource>，该 Consumer<TransactionalRedisDataSource> 遵循与常规 RedisDataSource 相同的 API，不同之处在于这些命令返回 void（对于反应式变体，返回 Uni<Void>）。当消费者返回时，事务 executed。

以下代码段展示了如何创建执行两个相关_writes_的事务：

@Inject RedisDataSource ds;

// ...

TransactionResult result = ds.withTransaction(tx -> {
        TransactionalHashCommands<String, String, String> hash = tx.hash(String.class);
        hash.hset(KEY, "field-1", "hello");
        hash.hset(KEY, "field-2", "hello");
    });

接收到的`tx`对象也可以用于_discard_事务，方法为：tx.discard();。返回的`TransactionResult`让你检索每个命令的结果。

当使用数据源的响应型变量时，传递的回调是一个`Function<ReactiveTransactionalRedisDataSource, Uni<Void>>`：

@Inject ReactiveRedisDataSource ds;

// ...

Uni<TransactionResult> result = ds.withTransaction(tx -> {
        ReactiveTransactionalHashCommands<String, String, String> hash = tx.hash(String.class);
        return hash.hset(KEY, "field-1", "hello")
            .chain(() -> hash.hset(KEY, "field-2", "hello"));
});

事务执行可能受到_keys_的制约。当一个已传递的键在事务执行期间被修改时，该事务会被舍弃。这些键传递为`String`，作为`withTransaction`方法的第二个参数：

TransactionResult result = ds.withTransaction(tx -> {
    TransactionalHashCommands<String, String, String> hash = tx.hash(String.class);
    hash.hset(KEY, "field-1", "hello");
    hash.hset(KEY, "field-2", "hello");
}, KEY);

你不能在事务中使用发布/订阅功能。

Implement the optimistic locking pattern

要使用乐观锁，你需要使用`withTransaction`方法的变种，允许在事务开始前执行代码。换句话说，它将如下执行：

WATCH key

// Pre-transaction block
// ....
// Produce a result

MULTI
  // In transaction code, receive the result produced by the pre-transaction block.
EXEC

例如，如果你需要仅在字段存在时更新哈希表中的一个值，你将使用以下 API：

OptimisticLockingTransactionResult<Boolean> result = blocking.withTransaction(ds -> {
    // The pre-transaction block:
    HashCommands<String, String, String> hashCommands = ds.hash(String.class);
    return hashCommands.hexists(key, "field"); // Produce a result (boolean in this case)
},
 (exists, tx) -> { // The transactional block, receives the result and the transactional data source
        if (exists) {
            tx.hash(String.class).hset(key, "field", "new value");
        } else {
            tx.discard();
        }
 },
  key); // The watched key

如果在事务前或事务块执行期间触及了一个监视的键，那么将中止该事务。事务前块产生一个结果，事务块可以使用这个结果。这个构造是必要的，因为在事务中，这些命令不会产生结果。结果只能在执行事务后检索。

事务前和事务块在同一 Redis 连接中调用。因此，事务前块必须使用已传递的数据源来执行命令。因此，命令从该连接发出。这些命令不得修改监视的键。

如果事务前块抛出一个异常（或者在使用响应型 API 时产生失败），那么该事务将中止。

Execute custom commands

要执行自定义命令，或者 API 不支持的命令，请使用以下方法：

@Inject ReactiveRedisDataSource ds;

// ...

Response response = ds.execute("my-command", param1, param2, param3);

execute`方法将命令发送给 Redis 并检索`Response。命令名称以第一个参数的形式传递。你可以在你的命令中添加任意数量的*String*参数。结果将封装到一个`Response`对象中。

响应型变量将返回一个`Uni<Response>`。

你也可以在一个事务中执行自定义命令。

Preload data into Redis

在启动时，你可以配置 Redis 客户端将数据预加载到 Redis 数据库中。

Configure the load scripts

使用以下命令指定要加载的_load script_：

quarkus.redis.load-script=import.redis # import.redis is the default in dev mode, no-file is the default in production mode
quarkus.redis.my-redis.load-script=actors.redis, movies.redis

`load-script`是一个编译时属性，在运行时不能被覆盖。

请注意，每个客户端可能具有不同的脚本，甚至是脚本列表。如果是列表，数据会以列表顺序导入（例如，首先是`actors.redis`，然后是`my-redis`客户端的`movies.redis`）。

Write load scripts

`.redis`文件遵循_one command per line_格式：

# Line starting with # and -- are ignored, as well as empty lines

-- One command per line:
HSET foo field1 abc field2 123

-- Parameters with spaces must be wrapped into single or double quotes
HSET bar field1 "abc def" field2 '123 456 '

-- Parameters with double quotes must be wrapped into single quotes and the opposite
SET key1 'A value using "double-quotes"'
SET key2 "A value using 'single-quotes'"

Quarkus 会将所有命令从单个文件批处理，然后发送所有命令。如果有任何错误，加载过程将会失败，但是之前的指令也许已经执行过了。为避免这种情况，你可以将命令封装在 Redis transaction 中：

-- Run inside a transaction
MULTI
SET key value
SET space:key 'another value'
INCR counter
EXEC

Configure the pre-loading

数据会在应用启动时加载。默认情况下，它会在导入前丢弃整个数据库。你可以使用 quarkus.redis.flush-before-load=false 来阻止这种情况发生。

另请注意，只有在数据库为空（没有键）时才会运行导入过程。你可以使用 quarkus.redis.load-only-if-empty=false 来强制导入，即使存在数据。

Distinguish dev/test vs. prod when pre-loading

如上所述，在开发和测试模式中，Quarkus 会尝试通过寻找 src/main/resources/import.redis 来导入数据。此行为在 prod 模式中处于禁用状态，如果你想导入即使是在生产中，添加：

%prod.quarkus.redis.load-script=import.redis

在 prod 模式中导入之前，确保你相应地配置了 quarkus.redis.flush-before-load。

在开发模式中，为了重新加载 .redis 加载脚本的内容，你需要添加： %dev.quarkus.vertx.caching=false

Use the Vert.x redis client

除了高级 API 之外，你还可以直接在代码中使用 Vertx Redis 客户端。Vert.x Redis Client 的文档可在 Vert.x Web Site 中找到。

Configure Redis hosts programmatically

RedisHostsProvider 以编程的方式提供 redis 主机。这允许从其他来源配置诸如 redis 连接密码之类的属性。

这很有用，因为它消除了在 application.properties 中存储敏感数据的需求。

 
@ApplicationScoped
@Identifier("hosts-provider") // the name of the host provider
public class ExampleRedisHostProvider implements RedisHostsProvider {
    @Override
    public Set<URI> getHosts() {
        // do stuff to get the host
        String host = "redis://localhost:6379/3";
        return Collections.singleton(URI.create(host));
    }
}

主机提供程序可用于配置 redis 客户端，如下所示：

quarkus.redis.hosts-provider-name=hosts-provider

Customize the Redis options programmatically

你可以公开一个实现了 io.quarkus.redis.client.RedisOptionsCustomizer 接口的 bean，以自定义 Redis 客户端选项。该 bean 会对每个已配置的 Redis 客户端进行调用：

@ApplicationScoped
public static class MyExampleCustomizer implements RedisOptionsCustomizer {

    @Override
    public void customize(String clientName, RedisOptions options) {
        if (clientName.equalsIgnoreCase("my-redis")
                || clientName.equalsIgnoreCase(RedisConfig.DEFAULT_CLIENT_NAME)) {
            // modify the given options
        } else {
            throw new IllegalStateException("Unknown client name: " + clientName);
        }
    }
}

Use the Redis Dev Services

参见 Redis Dev Service。

Configure Redis observability

Enable the health checks

如果你使用 quarkus-smallrye-health 扩展，quarkus-redis 会自动添加一个准备就绪运行状况检查以验证与 Redis 服务器的连接。

因此，当您访问应用程序的 /q/health/ready 端点时，您将获得有关连接验证状态的信息。

此行为可通过在 application.properties 中将 quarkus.redis.health.enabled 属性设为 false 来禁用。

Enable metrics

当应用程序也使用 quarkus-micrometer 扩展时，Redis 客户端指标会自动启用。Micrometer 会收集应用程序实现的所有 Redis 客户端的指标。

比如，如果你将指标导出到 Prometheus，你将得到：

# HELP redis_commands_duration_seconds The duration of the operations (commands of batches
# TYPE redis_commands_duration_seconds summary
redis_commands_duration_seconds_count{client_name="<default>",} 3.0
redis_commands_duration_seconds_sum{client_name="<default>",} 0.047500042
# HELP redis_commands_duration_seconds_max The duration of the operations (commands of batches
# TYPE redis_commands_duration_seconds_max gauge
redis_commands_duration_seconds_max{client_name="<default>",} 0.033273167
# HELP redis_pool_active The number of resources from the pool currently used
# TYPE redis_pool_active gauge
redis_pool_active{pool_name="<default>",pool_type="redis",} 0.0
# HELP redis_pool_ratio Pool usage ratio
# TYPE redis_pool_ratio gauge
redis_pool_ratio{pool_name="<default>",pool_type="redis",} 0.0
# HELP redis_pool_queue_size Number of pending elements in the waiting queue
# TYPE redis_pool_queue_size gauge
redis_pool_queue_size{pool_name="<default>",pool_type="redis",} 0.0
# HELP redis_commands_failure_total The number of operations (commands or batches) that have been failed
# TYPE redis_commands_failure_total counter
redis_commands_failure_total{client_name="<default>",} 0.0
# HELP redis_commands_success_total The number of operations (commands or batches) that have been executed successfully
# TYPE redis_commands_success_total counter
redis_commands_success_total{client_name="<default>",} 3.0
# HELP redis_pool_idle The number of resources from the pool currently used
# TYPE redis_pool_idle gauge
redis_pool_idle{pool_name="<default>",pool_type="redis",} 6.0
# HELP redis_pool_completed_total Number of times resources from the pool have been acquired
# TYPE redis_pool_completed_total counter
redis_pool_completed_total{pool_name="<default>",pool_type="redis",} 3.0
# HELP redis_commands_count_total The number of operations (commands or batches) executed
# TYPE redis_commands_count_total counter
redis_commands_count_total{client_name="<default>",} 3.0
# HELP redis_pool_usage_seconds Time spent using resources from the pool
# TYPE redis_pool_usage_seconds summary
redis_pool_usage_seconds_count{pool_name="<default>",pool_type="redis",} 3.0
redis_pool_usage_seconds_sum{pool_name="<default>",pool_type="redis",} 0.024381375
# HELP redis_pool_usage_seconds_max Time spent using resources from the pool
# TYPE redis_pool_usage_seconds_max gauge
redis_pool_usage_seconds_max{pool_name="<default>",pool_type="redis",} 0.010671542
# HELP redis_pool_queue_delay_seconds Time spent in the waiting queue before being processed
# TYPE redis_pool_queue_delay_seconds summary
redis_pool_queue_delay_seconds_count{pool_name="<default>",pool_type="redis",} 3.0
redis_pool_queue_delay_seconds_sum{pool_name="<default>",pool_type="redis",} 0.022341249
# HELP redis_pool_queue_delay_seconds_max Time spent in the waiting queue before being processed
# TYPE redis_pool_queue_delay_seconds_max gauge
redis_pool_queue_delay_seconds_max{pool_name="<default>",pool_type="redis",} 0.021926083

Redis 客户端名称可在 tags 中找到。

该指标包含 Redis 连接池指标 (redis_pool_*) 和关于命令执行的指标 (redis_commands_*)，例如命令数、成功、失败和持续时间。

Disable metrics

要停用 Redis 客户端指标（在使用 quarkus-micrometer 的时候），可以将以下属性添加到应用程序配置中：

quarkus.micrometer.binder.redis.enabled=false

Configuration reference

Unresolved include directive in modules/ROOT/pages/redis-reference.adoc - include::../../../target/quarkus-generated-doc/config/quarkus-redis-client.adoc[]