当前位置：

首页 > 编程开发 > 使用Lettuce连接和操作Redis的步骤和方法

使用Lettuce连接和操作Redis的步骤和方法

作者：SunnyJourney 时间：2023-04-28 来源：正软商城浏览：6

Redis Assistant

Redis Assistant 是一款为Redis设计的高效可视化管理与监控工具，提供多种操作模式，高效处理服务器数据。日常使用里的持续防护和信息管理会更突出，适合把安全控制放进长期使用流程中的场景。

立即下载

￥19

Windows/macOS/Linux 2026-08-22

正版软件 Windows macOS软件 Linux 数据库管理工具

一、摘要Lettuce是Redis的一款高级Java客户端，与Jedis并列成为最热门的客户端之一，目前已成为SpringBoot2.0版本默认的redis客户端。相比老牌Jedis，Lettuce属于后起之秀，不仅功能丰富，而且提供了很多新的功能特性，比如异步操作、响应式编程等等，同时还解决了Jedis中线程不安全的问题。二、Lettuce2.1、基本使用首先，创建一个maven项目，引入lettuce-core包，就可以使用了。io.lettucelettuce-core5.3.1.RELEASE使用

本文目录

一、摘要

Lettuce 是 Redis 的一款高级 Java 客户端，与 Jedis 并列成为最热门的客户端之一，目前已成为 SpringBoot 2.0 版本默认的 redis 客户端。

相比老牌 Jedis，Lettuce 属于后起之秀，不仅功能丰富，而且提供了很多新的功能特性，比如异步操作、响应式编程等等，同时还解决了 Jedis 中线程不安全的问题。

二、Lettuce

2.1、基本使用

首先，创建一个 maven 项目，引入lettuce-core包，就可以使用了。


  io.lettuce
  lettuce-core
  5.3.1.RELEASE

使用 lettuce 连接 redis，测试是否能正常联通！

public class LettuceMain {

    public static void main(String[] args) {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient redisClient = RedisClient.create(redisUri);
        StatefulRedisConnection connection = redisClient.connect();
        RedisCommands commands = connection.sync();
        System.out.println(commands.ping());
        connection.close();
        redisClient.shutdown();
    }
}

2.2、同步操作

基本上只要是 Jedis 支持的同步命令操作，Lettuce 都支持。

下面，我们以同步操作字符串为例，Lettuce 的 api 操作如下！

public class LettuceSyncMain {

    public static void main(String[] args) {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient redisClient = RedisClient.create(redisUri);
        StatefulRedisConnection connection = redisClient.connect();
        //获取同步操作命令工具
        RedisCommands commands = connection.sync();

        System.out.println("清空数据："+commands.flushdb());
        System.out.println("判断某个键是否存在："+commands.exists("username"));
        System.out.println("新增<'username','xmr'>的键值对："+commands.set("username", "xmr"));
        System.out.println("新增<'password','password'>的键值对："+commands.set("password", "123"));
        System.out.println("获取<'password'>键的值："+commands.get("password"));
        System.out.println("系统中所有的键如下：" + commands.keys("*"));
        System.out.println("删除键password:"+commands.del("password"));
        System.out.println("判断键password是否存在："+commands.exists("password"));
        System.out.println("设置键username的过期时间为5s:"+commands.expire("username", 5L));
        System.out.println("查看键username的剩余生存时间："+commands.ttl("username"));
        System.out.println("移除键username的生存时间："+commands.persist("username"));
        System.out.println("查看键username的剩余生存时间："+commands.ttl("username"));
        System.out.println("查看键username所存储的值的类型："+commands.type("username"));

        connection.close();
        redisClient.shutdown();
    }
}

2.3、异步操作

除此之外，Lettuce 还支持异步操作，将上面的操作改成异步处理，结果如下！

public class LettuceASyncMain {

    public static void main(String[] args) throws Exception {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient redisClient = RedisClient.create(redisUri);
        StatefulRedisConnection connection = redisClient.connect();
        //获取异步操作命令工具
        RedisAsyncCommands commands = connection.async();

        System.out.println("清空数据："+commands.flushdb().get());
        System.out.println("判断某个键是否存在："+commands.exists("username").get());
        System.out.println("新增<'username','xmr'>的键值对："+commands.set("username", "xmr").get());
        System.out.println("新增<'password','password'>的键值对："+commands.set("password", "123").get());
        System.out.println("获取<'password'>键的值："+commands.get("password").get());
        System.out.println("系统中所有的键如下：" + commands.keys("*").get());
        System.out.println("删除键password:"+commands.del("password").get());
        System.out.println("判断键password是否存在："+commands.exists("password").get());
        System.out.println("设置键username的过期时间为5s:"+commands.expire("username", 5L).get());
        System.out.println("查看键username的剩余生存时间："+commands.ttl("username").get());
        System.out.println("移除键username的生存时间："+commands.persist("username").get());
        System.out.println("查看键username的剩余生存时间："+commands.ttl("username").get());
        System.out.println("查看键username所存储的值的类型："+commands.type("username").get());

        connection.close();
        redisClient.shutdown();
    }
}

2.4、响应式编程

Lettuce 除了支持异步编程以外，还支持响应式编程，Lettuce 引入的响应式编程框架是Project Reactor，如果没有响应式编程经验可以先自行了解一下。

响应式编程使用案例如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient redisClient = RedisClient.create(redisUri);
        StatefulRedisConnection connection = redisClient.connect();
        //获取响应式API操作命令工具
        RedisReactiveCommands commands = connection.reactive();

        Mono setc = commands.set("name", "mayun");
        System.out.println(setc.block());
        Mono getc = commands.get("name");
        getc.subscribe(System.out::println);
        Flux keys = commands.keys("*");
        keys.subscribe(System.out::println);

        //开启一个事务，先把count设置为1，再将count自增1
        commands.multi().doOnSuccess(r -> {
            commands.set("count", "1").doOnNext(value -> System.out.println("count1：" +  value)).subscribe();
            commands.incr("count").doOnNext(value -> System.out.println("count2：" +  value)).subscribe();
        }).flatMap(s -> commands.exec())
                .doOnNext(transactionResult -> System.out.println("transactionResult：" + transactionResult.wasDiscarded())).subscribe();

        Thread.sleep(1000 * 5);
        connection.close();
        redisClient.shutdown();
    }
}

2.5、发布和订阅

Lettuce 还支持 redis 的消息发布和订阅，具体实现案例如下：

public class LettuceReactiveMain1 {

    public static void main(String[] args) throws Exception {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient redisClient = RedisClient.create(redisUri);
        //获取发布订阅操作命令工具
        StatefulRedisPubSubConnection pubsubConn = redisClient.connectPubSub();
        pubsubConn.addListener(new RedisPubSubListener() {
            @Override
            public void unsubscribed(String channel, long count) {
                System.out.println("[unsubscribed]" + channel);
            }
            @Override
            public void subscribed(String channel, long count) {
                System.out.println("[subscribed]" + channel);
            }
            @Override
            public void punsubscribed(String pattern, long count) {
                System.out.println("[punsubscribed]" + pattern);
            }
            @Override
            public void psubscribed(String pattern, long count) {
                System.out.println("[psubscribed]" + pattern);
            }
            @Override
            public void message(String pattern, String channel, String message) {
                System.out.println("[message]" + pattern + " -> " + channel + " -> " + message);
            }
            @Override
            public void message(String channel, String message) {
                System.out.println("[message]" + channel + " -> " + message);
            }
        });
        RedisPubSubAsyncCommands pubsubCmd = pubsubConn.async();
        pubsubCmd.psubscribe("CH");
        pubsubCmd.psubscribe("CH2");
        pubsubCmd.unsubscribe("CH");

        Thread.sleep(100 * 5);
        pubsubConn.close();
        redisClient.shutdown();
    }
}

2.6、客户端资源与参数配置

Lettuce 客户端的通信框架集成了 Netty 的非阻塞 IO 操作，客户端资源的设置与 Lettuce 的性能、并发和事件处理紧密相关，如果不是特别熟悉客户端参数配置，不建议在没有经验的前提下凭直觉修改默认值，保持默认配置就行。

非集群环境下，具体的配置案例如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        ClientResources resources = DefaultClientResources.builder()
                .ioThreadPoolSize(4) //I/O线程数
                .computationThreadPoolSize(4) //任务线程数
                .build();
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        ClientOptions options = ClientOptions.builder()
                .autoReconnect(true)//是否自动重连
                .pingBeforeActivateConnection(true)//连接激活之前是否执行PING命令
                .build();
        RedisClient client = RedisClient.create(resources, redisUri);
        client.setOptions(options);
        StatefulRedisConnection connection = client.connect();
        RedisCommands commands = connection.sync();
        commands.set("name", "关羽");
        System.out.println(commands.get("name"));

        connection.close();
        client.shutdown();
        resources.shutdown();
    }
}

集群环境下，具体的配置案例如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        ClientResources resources = DefaultClientResources.builder()
                .ioThreadPoolSize(4) //I/O线程数
                .computationThreadPoolSize(4) //任务线程数
                .build();
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1").withPort(6379).withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        ClusterClientOptions options = ClusterClientOptions.builder()
                .autoReconnect(true)//是否自动重连
                .pingBeforeActivateConnection(true)//连接激活之前是否执行PING命令
                .validateClusterNodeMembership(true)//是否校验集群节点的成员关系
                .build();
        RedisClusterClient client = RedisClusterClient.create(resources, redisUri);
        client.setOptions(options);
        StatefulRedisClusterConnection connection = client.connect();
        RedisAdvancedClusterCommands commands = connection.sync();
        commands.set("name", "张飞");
        System.out.println(commands.get("name"));

        connection.close();
        client.shutdown();
        resources.shutdown();
    }
}

2.7、线程池配置

Lettuce 连接设计的时候，就是线程安全的，所以一个连接可以被多个线程共享，同时 lettuce 连接默认是自动重连的，使用单连接基本可以满足业务需求，大多数情况下不需要配置连接池，多连接并不会给操作带来性能上的提升。

但在某些特殊场景下，比如事物操作，使用连接池会是一个比较好的方案，那么如何配置线程池呢？

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        RedisURI redisUri = RedisURI.builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withPassword("111111")
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        RedisClient client = RedisClient.create(redisUri);
        //连接池配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxIdle(2);

        GenericObjectPool> pool = ConnectionPoolSupport.createGenericObjectPool(client::connect, poolConfig);
        StatefulRedisConnection connection = pool.borrowObject();
        RedisCommands commands = connection.sync();
        commands.set("name", "张飞");
        System.out.println(commands.get("name"));

        connection.close();
        pool.close();
        client.shutdown();
    }
}

2.8、主从模式配置

redis 一般采用主从复制模式，搭建高可用的架构，简单的说就一个主节点，多个从节点，自动从主节点同步最新数据。

Lettuce 支持自动发现主从模式下的节点信息，然后保存到本地，具体配置如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        //这里只需要配置一个节点的连接信息，不一定需要是主节点的信息，从节点也可以;可以自动发现主从节点
        RedisURI uri = RedisURI.builder().withHost("192.168.31.111").withPort(6379).withPassword("123456").build();
        RedisClient client = RedisClient.create(uri);
        StatefulRedisMasterReplicaConnection connection = MasterReplica.connect(client, StringCodec.UTF8, uri);
        //从节点读取数据
        connection.setReadFrom(ReadFrom.REPLICA);

        RedisCommands commands = connection.sync();
        commands.set("name", "张飞");
        System.out.println(commands.get("name"));

        connection.close();
        client.shutdown();
    }
}

当然我们也可以手动指定集群节点来加载，具体配置如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        //集群节点
        List uris = new ArrayList();
        uris.add(RedisURI.builder().withHost("192.168.31.111").withPort(6379).withPassword("111111").build());
        uris.add(RedisURI.builder().withHost("192.168.31.112").withPort(6379).withPassword("111111").build());
        uris.add(RedisURI.builder().withHost("192.168.31.113").withPort(6379).withPassword("111111").build());

        RedisClient client = RedisClient.create();
        StatefulRedisMasterReplicaConnection connection = MasterReplica.connect(client, StringCodec.UTF8, uris);
        //从节点读取数据
        connection.setReadFrom(ReadFrom.REPLICA);

        RedisCommands commands = connection.sync();
        commands.set("name", "张飞");
        System.out.println(commands.get("name"));

        connection.close();
        client.shutdown();
    }
}

2.9、哨兵模式配置

哨兵模式，也是 redis 实现服务高可用的一大亮点，具体配置实现如下：

public class LettuceMain {

    public static void main(String[] args) throws Exception {
        //集群节点
        List uris = new ArrayList();
        uris.add(RedisURI.builder().withSentinel("192.168.31.111", 26379).withSentinelMasterId("mymaster").withPassword("123456").build());
        uris.add(RedisURI.builder().withSentinel("192.168.31.112", 26379).withSentinelMasterId("mymaster").withPassword("123456").build());
        uris.add(RedisURI.builder().withSentinel("192.168.31.113", 26379).withSentinelMasterId("mymaster").withPassword("123456").build());

        RedisClient client = RedisClient.create();
        StatefulRedisMasterReplicaConnection connection = MasterReplica.connect(client, StringCodec.UTF8, uris);
        //从节点读取数据
        connection.setReadFrom(ReadFrom.REPLICA);

        RedisCommands commands = connection.sync();
        commands.set("name", "赵云");
        System.out.println(commands.get("name"));

        connection.close();
        client.shutdown();
    }
}

2.10、Cluster 集群模式配置

Cluster 集群模式，是之后推出的一种高可用的架构模型，主要是采用分片方式来存储数据，具体配置如下：

public class LettuceReactiveMain4 {

    public static void main(String[] args) throws Exception {
        Set uris = new HashSet<>();
        uris.add(RedisURI.builder().withHost("192.168.31.111").withPort(7000).withPassword("123456").build());
        uris.add(RedisURI.builder().withHost("192.168.31.112").withPort(7000).withPassword("123456").build());
        uris.add(RedisURI.builder().withHost("192.168.31.113").withPort(7000).withPassword("123456").build());
        uris.add(RedisURI.builder().withHost("192.168.31.114").withPort(7000).withPassword("123456").build());
        uris.add(RedisURI.builder().withHost("192.168.31.115").withPort(7000).withPassword("123456").build());
        uris.add(RedisURI.builder().withHost("192.168.31.116").withPort(7001).withPassword("123456").build());

        RedisClusterClient client = RedisClusterClient.create(uris);
        StatefulRedisClusterConnection connection = client.connect();
        RedisAdvancedClusterCommands commands = connection.sync();
        commands.set("name", "关羽");
        System.out.println(commands.get("name"));

        //选择从节点,只读
        NodeSelection replicas = commands.replicas();
        NodeSelectionCommands nodeSelectionCommands = replicas.commands();
        Executions> keys = nodeSelectionCommands.keys("*");
        keys.forEach(key -> System.out.println(key));

        connection.close();
        client.shutdown();
    }
}

本站声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系bd@zhengruan.com

作者最新文章

动漫共和国资源入口及正版地址分享 2026-11-04 12:05

xshell端口ssh SSH隧道建立方法 2026-11-03 10:11

CorelDRAW是免费软件吗？详解试用、订阅与一次性购买收费模式 2026-10-30 19:32

PDF怎么免费转成Word并保留内容？转换前后检查要点 2026-10-30 17:50

ArchiveofOurOwn小说快速入口链接 2026-10-30 10:30

编程开发

上一篇： thinkphp中route用来做什么

下一篇： Apple Books与Kindle哪一个更适合你？比较与选择

相关文章更多

php72w redis,docker php7安装php-redis

在Docker环境下为PHP安装Redis扩展：手动编译需下载源码、安装phpize、配置编译并安装，生成redis.so并在php.d目录新建redis.ini加载，重启PHP-FPM；也可直接yum安装php72w-pecl-redis，免手动编译。

2026-07-21 1 WeekendFlower

php 如何配置 redis,php 如何设置redis

配置PHP的Redis扩展：先安装Redis服务，从GitHub下载phpredis源码，用phpize编译安装，修改php.ini添加extension=redis.so，重启php-fpm或Apache，通过phpinfo验证并连接Redis。

2026-07-20 2 CalmWind

PHP

c++如何将结构体序列化为Redis兼容的RESP协议格式【深度】

C++结构体无法直接序列化为RESP协议，需手动将字段映射为*N数组嵌套$lenbulkstring形式。整数需转换为字符串并加:前缀，空字符串用$0\r\n，null用$-1\r\n。长度计算需精确到字节数，特别注意二进制安全，同时确保字段顺序与结构体定义一致。

2026-07-18 6 WarmHope

如何在Golang架构中部署Redict作为高能数据临时存储中转站

Redis作为跨服务临时状态枢纽，需按消息队列、缓存和原子状态三重角色设计。选型用List实现任务分发及延迟重试，Stream用于事件广播与位点回溯。go-redis/v8需配置MinIdleConns、MaxRetries及超时。数据写入应JSON序列化并带type标签、设合理TTL、将关键字段提至顶层。消费通过原子GET+DEL或processedkey

2026-07-15 6 小确幸

TP8.0 高并发下库存超卖？Redis 原子递减结合数据库乐观锁控制

在高并发秒杀场景下，利用Redis的减库存原子操作预扣减库存拦截超卖请求，再通过数据库乐观锁（版本号与库存校验）确保最终一致性，异常时回滚Redis库存并借助Lua脚本保证原子性，从而有效防止库存超卖。

2026-07-15 20 吹吹风会发光

如何在 Go 中利用 go-redis 执行 Lua 脚本优化逻辑

在Go中使用go-redis执行Lua脚本可借助原子性解决竞态问题，通过redis.Script封装脚本并自动处理SHA1缓存与重试。需注意KEYS必须为非空切片且所有键在Cluster模式下落在同一slot，ARGV以字符串传入并由tonumber转换。返回值需先检查错误再调用Val()，避免panic。

2026-07-12 9 小确幸

TP6.0 基于 Redis SetNX 实现的简单互斥锁机制【并发】

先看一个典型场景：电商秒杀、库存扣减、定时任务重复调度——这些并发冲突在 TP6 应用里屡见不鲜。用 Redis 的 SETNX 做互斥锁，确实是轻量又直接的方案，但“能用”和“稳妥”之间，隔着三层硬功夫：原子加锁、身份校验、合理超时。这三条，差一条就翻车。很多人第一次上手，直接写 SETNX 加

2026-07-11 5 EasyWind

TP6.0 如何处理高并发抢购？Redis 原子锁与队列削峰详解【秒杀】

高并发抢购中，Redis的DECR原子操作可安全扣库存；配合think-queue异步削峰，接口仅扣库存和推消息；分布式锁需用SETNXEX加唯一标识，释放时用Lua脚本校验；成功资格后须以数据库事务双写为准，失败时补回Redis库存。

2026-07-11 8 小确幸

Golang 实现基于 Redis 的延时任务队列

基于Redis的ZSET实现延时队列需解决并发重复消费、失败重试混乱、精度不足及内存爆炸等问题。通过Lua脚本保证取删原子性，使用毫秒级时间戳，对临时错误采用指数退避重试，永久错误记入独立哈希表，并限制最大延迟、定期清理过期任务、使用紧凑序列化格式。

2026-07-02 3 小月亮

RedisInsight怎么修改Key的过期时间 Redis操作方法【步骤】

操作 Redis 的时候，改个 Key 的过期时间其实是个高频场景。特别是做运维排查或者临时调试那会儿，谁也不想反复切命令行窗口、背那些命令参数。好在 RedisInsight 这个图形工具把这事儿做得很顺手——三种方式任选，总有一种合你胃口。在动手前，先确认一下 Key 当前的 TTL 状态是个