我的分享

Appearance

客户端 ​

命令行客户端 ​

redis-cli 是 Redis 的命令行界面工具，它允许用户通过命令行与 Redis 服务器进行交互。使用 redis-cli，你可以执行各种 Redis 命令来管理数据、监控服务器状态以及执行其他高级操作。

基本用法

  1. 连接到 Redis 服务器

    默认情况下，redis-cli 会尝试连接到运行在本地主机（localhost）上、默认端口（6379）的 Redis 服务器。如果你需要连接到不同的主机或端口，可以使用 -h 和 -p 选项：

    bash
    bash复制代码

redis-cli -h <hostname> -p <port>

    如果 Redis 服务器设置了密码保护，你可以使用 -a 选项来提供密码：

    bash
    bash复制代码

redis-cli -h <hostname> -p <port> -a <password>

  2. 执行 Redis 命令

    一旦连接到 Redis 服务器，你就可以在 redis-cli 提示符下输入 Redis 命令。例如，要设置一个键值对，你可以使用 SET 命令：

    bash
    bash复制代码

SET mykey "Hello, Redis!"

    要获取这个键的值，你可以使用 GET 命令：

    bash
    bash复制代码

GET mykey

  3. 退出 redis-cli

    要退出 redis-cli，你可以输入 exit 命令或按 Ctrl+D。

高级用法

  1. 批处理模式

    redis-cli 支持从标准输入读取命令并执行。这允许你将一系列命令写入一个文件，并通过重定向的方式一次性执行这些命令：

    bash
    bash复制代码

cat commands.txt | redis-cli

    或者，你也可以使用 -x 选项，让 redis-cli 从标准输入读取最后一个参数指定的文件内容作为命令：

    bash
    bash复制代码

redis-cli -x < commands.txt

  2. 交互式模式与非交互式模式

    在默认情况下，redis-cli 会进入交互式模式，等待用户输入命令。但你也可以通过提供命令作为命令行参数的方式，让 redis-cli 在非交互式模式下执行这些命令并立即退出：

    bash
    redis-cli SET mykey "Hello, Redis!"
redis-cli GET mykey

    注意，在非交互式模式下，每个命令都需要单独运行一个 redis-cli 实例。

  3. 脚本支持

    redis-cli 支持通过 --eval 选项执行 Lua 脚本。这对于需要在 Redis 中执行复杂逻辑的场景非常有用：

    bash
    bash复制代码

redis-cli --eval myscript.lua mykey , arg1 arg2 ...

    在这里，myscript.lua 是包含 Lua 脚本的文件名，mykey 是传递给 Lua 脚本的第一个键参数（在 Lua 脚本中可以通过 KEYS[1] 访问），arg1 arg2 ... 是传递给 Lua 脚本的其他参数（在 Lua 脚本中可以通过 ARGV[1], ARGV[2], ... 访问）。

  4. 原始模式

    使用 --raw 选项，redis-cli 会以原始格式输出数据，而不是尝试对数据进行转义或格式化。这对于处理二进制数据或需要精确控制输出格式的场景非常有用。

  5. 扫描模式

    redis-cli 还提供了 --scan 和 --pattern 选项，用于以更高效的方式扫描键空间。这些选项通常与 KEYS 命令的替代者 SCAN 命令一起使用。

注意事项

  • 在使用 redis-cli 时，请确保你有权访问目标 Redis 服务器，并且你知道如何安全地处理敏感信息（如密码）。
  • redis-cli 提供了许多选项和参数，用于定制其行为。你可以通过运行 redis-cli --help 命令来查看所有可用的选项和参数。
  • 在生产环境中，谨慎使用可能导致大量数据移动或服务器负载增加的命令（如 KEYS、FLUSHALL 等）。在执行这些命令之前，最好先了解它们的潜在影响。

使用 ping 探测服务是否已启动 ​

bash
redis-cli ping

如果服务已启动会响应 PONG

在 redis 集群中切换 master ​

使用 redis-cli 集群模式连接到 redis 集群中任意一个节点

sh
redis-cli -c

通过 get 不同的 key 自动 redirect 到不同的 master 节点

sh
get 0
get 1
get 2
get 3
...

图形化桌面客户端 ​

AnotherRedisDesktopManager ​

https://github.com/qishibo/AnotherRedisDesktopManager/

ubuntu 系统配置 ​

访问https://github.com/qishibo/AnotherRedisDesktopManager/releases下载客户端

移动客户端到 /usr/local 目录

bash
sudo mv ~/Downloads/Another-Redis-Desktop-Manager-linux-1.7.1-x86_64.AppImage /usr/local/

客户端新增可执行权限

bash
sudo chmod +x /usr/local/Another-Redis-Desktop-Manager-linux-1.7.1-x86_64.AppImage

新建 /usr/share/applications/another-redis-desktop-manager.desktop 文件内容如下：

properties
[Desktop Entry]
Encoding=UTF-8
Name=Another Redis Desktop Manager
Exec=/usr/local/Another-Redis-Desktop-Manager-linux-1.7.1-x86_64.AppImage
Terminal=false
Type=Application
StartupNotify=true

在应用中心中输入 redis 打开客户端

RedisInsight ​

官方参考

如果您不想保留 Redis Insight 数据：

bash
docker run --rm --name redisinsight -p 5540:5540 redis/redisinsight:latest

如果要保留 Redis Insight 数据，请先将 Docker 卷附加到 /data 路径，然后运行以下命令：

bash
docker run --rm --name redisinsight -p 5540:5540 redis/redisinsight:latest -v redisinsight:/data

接下来，将浏览器指向 http://localhost:5540。根据提示添加 Redis 服务器链接即可。

Redis Insight 还在 http://localhost:5540/api/health/ 提供了健康检查端点，以监控正在运行的容器的健康状况。

编程客户端 ​

Jedis ​

https://github.com/redis/jedis

Lettuce ​

参考链接1

参考链接2

介绍 ​

Lettuce 是一款可扩展的线程安全 Redis 客户端，可用于同步、异步和反应式使用。如果多个线程避免阻塞和事务操作（例如 BLPOP 和 MULTI/EXEC），则它们可以共享一个连接。Lettuce 是用 netty 构建的。支持高级 Redis 功能，例如 Sentinel、Cluster、Pipelining、Auto-Reconnect 和 Redis 数据模型。

用法 ​

详细用法请参考本站 示例

建立连接 ​

参考链接

单机连接

java
@SpringBootTest(classes = {Application.class})
@Slf4j
public class ApplicationStandaloneTests {

    RedisClient client;
    StatefulRedisConnection<String, String> connection;

    @BeforeEach
    public void before() {
        // 单机版 Redis 连接
        client = RedisClient.create("redis://123456@localhost:6379");
        connection = client.connect();
    }

    @AfterEach
    public void after() {
        if (this.connection != null) {
            this.connection.close();
            this.connection = null;
        }
        if (client != null) {
            client.shutdown();
            client = null;
        }
    }
}

集群连接

参考链接1

参考链接2

java
@SpringBootTest(classes = {Application.class})
@Slf4j
public class ApplicationClusterTests {

    RedisClusterClient clusterClient;
    StatefulRedisClusterConnection<String, String> clusterConnection;

    @BeforeEach
    public void before() {
        // 集群版 Redis 连接
        RedisURI node1 = RedisURI.create("localhost", 6380);
        RedisURI node2 = RedisURI.create("localhost", 6381);
        RedisURI node3 = RedisURI.create("localhost", 6382);
        clusterClient = RedisClusterClient.create(Arrays.asList(node1, node2, node3));
        clusterConnection = clusterClient.connect();
    }

    @AfterEach
    public void after() {
        if (clusterConnection != null) {
            clusterConnection.close();
            clusterConnection = null;
        }
        if (clusterClient != null) {
            clusterClient.shutdown();
            clusterClient = null;
        }
    }
}
同步 API ​
java
@Test
public void test() throws InterruptedException {
    // 同步阻塞
    RedisStringCommands<String, String> sync = connection.sync();
    String key = UUID.randomUUID().toString();
    sync.set(key, key);
    String value = sync.get(key);
    Assertions.assertEquals(key, value);
}
异步 API ​
java
@Test
public void test() throws InterruptedException {
    // 异步非阻塞
    RedisAsyncCommands<String, String> async = connection.async();
    key = UUID.randomUUID().toString();
    RedisFuture<String> redisFuture = async.set(key, key);
    String finalKey = key;
    CountDownLatch latch = new CountDownLatch(1);
    redisFuture.whenComplete((data, exception) -> {
        async.get(finalKey).whenComplete((dataInternal, exceptionInternal) -> {
            if (finalKey.equals(dataInternal)) {
                latch.countDown();
            }
        });
    });
    Assertions.assertTrue(latch.await(1, TimeUnit.SECONDS));
}

spring-data-redis ​

https://spring.io/projects/spring-data-redis

和 SpringBoot 应用集成 ​

注意：关于使用 RedisTemplate 执行 Lua 脚本提醒

java
DefaultRedisScript defaultRedisScript = new DefaultRedisScript<>();
// 每次请求 redis 都到 test.lua 文件读取 Lua 脚本，导致性能急剧下降
defaultRedisScript.setLocation(new ClassPathResource("test.lua"));
defaultRedisScript.setResultType(String.class);

// 下面是推荐写法
DefaultRedisScript defaultRedisScript = new DefaultRedisScript<>();
ClassPathResource classPathResource = new ClassPathResource("test.lua");
String script = StreamUtils.copyToString(classPathResource.getInputStream(), StandardCharsets.UTF_8);
classPathResource.getInputStream().close();
defaultRedisScript.setScriptText(script);
defaultRedisScript.setResultType(String.class);

pom 依赖配置如下：

xml
<!-- SpringBoot Redis 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Redis 连接池依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

Standalone 模式配置如下：

详细用法请参考示例https://gitee.com/dexterleslie/demonstration/tree/master/demo-redis/redistemplate/redistemplate-standalone

application.properties 配置如下：

xml
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123456

Sentinel 模式配置如下：

详细用法请参考示例https://gitee.com/dexterleslie/demonstration/tree/master/demo-redis/redistemplate/redistemplate-sentinel

java
@Configuration
public class RedisConfiguration {
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(256);
        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                // 在所有节点负载均衡读取
                // .readFrom(ReadFrom.ANY)
                // 从所有slave节点负载均衡读取
                .readFrom(ReadFrom.ANY_REPLICA)
                // 随机选择一个slave节点读取
                // .readFrom(ReadFrom.REPLICA)
                // .readFrom(ReadFrom.REPLICA_PREFERRED)
                .poolConfig(poolConfig)
                .clientResources(ClientResources.builder().build())
                .clientOptions(ClientOptions.builder().build())
                .build();

        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("localhost", 26381)
                .sentinel("localhost", 26380)
                .sentinel("localhost", 26379);
        return new LettuceConnectionFactory(sentinelConfig, clientConfig);
    }
}

Replication 模式配置如下：

详细用法请参考示例https://gitee.com/dexterleslie/demonstration/tree/master/demo-redis/redistemplate/redistemplate-replication

java
@Configuration
public class RedisConfiguration {
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(256);
        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                // 在所有节点负载均衡读取
                // .readFrom(ReadFrom.ANY)
                // 从所有slave节点负载均衡读取
                .readFrom(ReadFrom.ANY_REPLICA)
                // 随机选择一个slave节点读取
                // .readFrom(ReadFrom.REPLICA)
                // .readFrom(ReadFrom.REPLICA_PREFERRED)
                .poolConfig(poolConfig)
                .clientResources(ClientResources.builder().build())
                .clientOptions(ClientOptions.builder().build())
                .build();
        
        RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration("localhost", 6379);
        return new LettuceConnectionFactory(serverConfig, clientConfig);
    }
}

Cluster 模式配置如下：

详细用法请参考示例https://gitee.com/dexterleslie/demonstration/tree/master/demo-redis/redistemplate/redistemplate-cluster

application.properties 配置如下：

properties
# 配置redis集群节点，可以是全部或者部分节点（客户端会自动发现其他节点）
spring.redis.cluster.nodes=localhost:6380,localhost:6381,localhost:6382,localhost:6383,localhost:6384,localhost:6385
# 指定了 Redis 客户端在与 Redis 集群进行通信时，允许执行的重定向操作的最大次数。
# 当 Redis 客户端尝试在集群中执行某个操作时，可能会因为数据分布的原因而遇到节点的重定向操作。例如，客户端尝试访问一个 key，但该 key 并不在当前节点上，此时节点会告诉客户端去哪个节点上查找该 key。
# 用来定义这种重定向操作的最大次数。如果超过了这个限制次数，客户端将不再进行重定向，并且会报错。
spring.redis.cluster.max-redirects=6

在代码中注入并引用 StringRedisTemplate，参考 key string 序列化https://blog.csdn.net/Muscleheng/article/details/135323270

java
@Autowired
StringRedisTemplate redisTemplate = null;