吃透Redis系列（十一）：Jedis和Lettuce客户端详细介绍

2024-09-03 01:32
文章标签 介绍 redis 系列 详细 客户端 jedis 十一 吃透 lettuce

本文主要是介绍吃透Redis系列（十一）：Jedis和Lettuce客户端详细介绍，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Redis系列文章：

吃透Redis系列（一）：Linux下Redis安装

吃透Redis系列（二）：Redis六大数据类型详细用法

吃透Redis系列（三）：Redis管道，发布/订阅，事物，过期时间 详细介绍

吃透Redis系列（四）：布隆（bloom）过滤器详细介绍

吃透Redis系列（五）：RDB和AOF持久化详细介绍

吃透Redis系列（六）：主从复制详细介绍

吃透Redis系列（七）：哨兵机制详细介绍

吃透Redis系列（八）：集群详细介绍

吃透Redis系列（九）：Redis代理twemproxy和predixy详细介绍

吃透Redis系列（十）：Redis内存模型详细介绍

吃透Redis系列（十一）：Jedis和Lettuce客户端详细介绍

文章目录

    • 前言
    • 一，Jedis使用
      • 1，导入maven包
      • 2，五种基本类型
      • 3，管道
      • 4，事物
      • 5，哨兵
      • 6，集群
    • 二，Lettuce使用
      • 1，Lettuce简单使用
      • 2，API
        • 2.1，同步API
        • 2.2，异步API
        • 2.3，反应式API
      • 3，发布/订阅
      • 4，管道
      • 5，事物
      • 6，普通主从模式
      • 7，哨兵
      • 8，集群

前言

我们打开Redis官网（https://redis.io/clients）发现，Redis支持以下语言：

在这里插入图片描述

因为Redis是二进制安全的，只存字节数组，所以只要各种语言客户端相互编解码一致，那么就可以互相通用，比如c存java取，等等。

当然，我们最关心的还是在Java中的使用，所以我们还是点开Java，看都有哪些客户端支持：

在这里插入图片描述

有如上几种客户端，那么你看最常用的就是标星的Jedis，Lettuce，Redisson。

接下来我们只详细了解Jedis，Lettuce，因为我们Spring中也是用了这两种客户端，具体在Spring中怎么使用，请参考挂网 Spring Data Redis

一，Jedis使用

首先打开Jedis的github：https://github.com/redis/jedis?_ga=2.241806790.538319447.1611192789-1620311179.1610019103

1，导入maven包

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.5.0</version><type>jar</type><scope>compile</scope>
</dependency>

2，五种基本类型

public class MyRedisTest {public static void main(String[] args) {Jedis jedis = new Jedis("127.0.0.1", 6379);/*** 1，字符串操作*/jedis.set("name", "bobo");jedis.set("age", "18");jedis.incr("age");System.out.println("name:" + jedis.get("name") + " age:" + jedis.get("age"));/*** 2，list操作*/String keyList = "myList";jedis.rpush(keyList, "1");jedis.rpush(keyList, "2");jedis.rpush(keyList, "3");System.out.println(jedis.lrange(keyList, 0, -1));/*** 3，set操作*/String keySet1 = "mySet1";String keySet2 = "mySet2";jedis.sadd(keySet1, "a", "b", "c");jedis.sadd(keySet2, "d", "b", "f");//取交集jedis.sinterstore("result1", keySet1, keySet2);System.out.println("交集：" + jedis.smembers("result1"));//取并集jedis.sunionstore("result2", keySet1, keySet2);System.out.println("并集：" + jedis.smembers("result2"));/*** 4，有序集合*/String keyStoreSet = "myStoreSet";jedis.zadd(keyStoreSet, 3, "score3");jedis.zadd(keyStoreSet, 1, "score1");jedis.zadd(keyStoreSet, 2, "score2");System.out.println("zSet:" + jedis.zrange(keyStoreSet, 0, -1));/*** 5，哈希操作*/String hashKey = "myHashKey";jedis.hset(hashKey, "name", "bobo");jedis.hset(hashKey, "age", "18");System.out.println("hash value:" + jedis.hvals(hashKey));}
}

运行输出：

name:bobo age:19
[1, 2, 3]
交集：[b]
并集：[f, a, b, c, d]
zSet:[score1, score2, score3]
hash value:[bobo, 18]

redis-cli查询key：

在这里插入图片描述

3，管道

	@Testpublic void testPipe() {// 清空数据jedis.flushDB();Pipeline pipelined = jedis.pipelined();pipelined.set("name", "bobo");pipelined.zadd("storeSet", 3, "score3");pipelined.zadd("storeSet", 1, "score1");pipelined.zadd("storeSet", 2, "score2");pipelined.sync();System.out.println("name:" + jedis.get("name"));System.out.println("storeSet:" + jedis.zrange("storeSet", 0, -1));}

运行输出：

name:bobo
storeSet:[score1, score2, score3]

4，事物

	@Testpublic void testTransaction() {jedis.flushDB();Transaction transaction = jedis.multi();transaction.set("name", "bobo");transaction.lpush("myList", "a", "b", "c");transaction.lpop("myList");transaction.exec();System.out.println("name:" + jedis.get("name"));System.out.println("myList:" + jedis.lrange("myList", 0, -1));}

运行输出：

name:bobo
myList:[b, a]

5，哨兵

部署三个哨兵节点

哨兵部署详细操作请看：吃透Redis系列（七）：哨兵机制详细介绍

# sentinel_26379.conf
port 26379
daemonize yes
logfile /var/lib/sentinel_26379.log
sentinel monitor mymaster 127.0.0.1 6379 2# sentinel_26380.conf
port 26380
daemonize yes
logfile /var/lib/sentinel_26380.log
sentinel monitor mymaster 127.0.0.1 6379 2# sentinel_26381.conf
port 26381
daemonize yes
logfile /var/lib/sentinel_26381.log
sentinel monitor mymaster 127.0.0.1 6379 2

并启动以上三个哨兵

sudo redis-sentinel /etc/redis/sentinel_26379.conf
sudo redis-sentinel /etc/redis/sentinel_26380.conf
sudo redis-sentinel /etc/redis/sentinel_26381.conf

查看哨兵运行状态：

在这里插入图片描述

jedis访问：

	@Testpublic void testSentinel(){Set<String> set = new HashSet<String>();set.add("127.0.0.1:26379");set.add("127.0.0.1:26380");set.add("127.0.0.1:26381");JedisSentinelPool sentinelPool = new JedisSentinelPool("mymaster", set);Jedis jedis = sentinelPool.getResource();jedis.set("name","bo");System.out.println(jedis.get("name"));}

运行输出：

bo

6，集群

部署redis cluster集群

redis cluster集群的部署详细介绍参考：吃透Redis系列（八）：集群详细介绍

部署集群，其中7000，7001，7002是三个主节点

8000，8001，8002是三个从节点

搭建完成之后，查看当前集群节点状态：

在这里插入图片描述

Jedis访问集群：

	@Testpublic void testCluster(){Set<HostAndPort> set = new HashSet<HostAndPort>();set.add(new HostAndPort("127.0.0.1",7000));set.add(new HostAndPort("127.0.0.1",7001));set.add(new HostAndPort("127.0.0.1",7002));JedisCluster jedisCluster = new JedisCluster(set);jedisCluster.set("name","helloword");System.out.println(jedisCluster.get("name"));}

运行输出：

helloword

二，Lettuce使用

Lettuce是一个高性能基于Java编写的Redis驱动框架，底层集成了Project Reactor提供天然的反应式编程，通信框架集成了Netty使用了非阻塞IO，5.x版本之后融合了JDK1.8的异步编程特性，在保证高性能的同时提供了十分丰富易用的API。

Lettuce使用的时候依赖于四个主要组件：

  • RedisURI：连接信息。
  • RedisClient：Redis客户端，特殊地，集群连接有一个定制的RedisClusterClient。
  • Connection：Redis连接，主要是StatefulConnection或者StatefulRedisConnection的子类，连接的类型主要由连接的具体方式（单机、哨兵、集群、订阅发布等等）选定，比较重要。
  • RedisCommands：Redis命令API接口，基本上覆盖了Redis发行版本的所有命令，提供了同步（sync）、异步（async）、反应式（reative）的调用方式，对于使用者而言，会经常跟RedisCommands系列接口打交道。

使用到的软件版本：Java 1.8.0_191、Redis 6.0.6、lettuce 5.3.1.RELEASE。

Lettuce内容参考连接：https://www.cnblogs.com/throwable/p/11601538.html#lettuce

1，Lettuce简单使用

导入maven包

<dependency><groupId>io.lettuce</groupId><artifactId>lettuce-core</artifactId><version>5.3.1.RELEASE</version>
</dependency>

基本使用

	@Testpublic void testSetGet() {// 连接信息RedisURI redisURI = RedisURI.builder().withHost("127.0.0.1").withPort(6379).withTimeout(Duration.of(10, ChronoUnit.SECONDS)).build();// redis客户端RedisClient redisClient = RedisClient.create(redisURI);// 创建redis连接StatefulRedisConnection<String, String> connect = redisClient.connect();// 同步调用方式RedisCommands<String, String> redisCommands = connect.sync();// set参数,设置5秒过期时间SetArgs setArgs = SetArgs.Builder.nx().ex(5);// 设置key，valueredisCommands.set("name", "bobo", setArgs);// 获取name的值System.out.println(redisCommands.get("name"));// 关闭连接connect.close();// 关闭客户端redisClient.shutdown();}

运行输出：

bobo

2，API

Lettuce主要提供三种API：

  • 同步（sync）：RedisCommands。
  • 异步（async）：RedisAsyncCommands。
  • 反应式（reactive）：RedisReactiveCommands。

先准备好一个单机Redis连接备用：

	// redis客户端private RedisClient redisClient;// redis连接private StatefulRedisConnection<String, String> connection;@Beforepublic void before() {RedisURI redisURI = RedisURI.builder().withHost("127.0.0.1").withPort(6379).withTimeout(Duration.of(10, ChronoUnit.SECONDS)).build();// redis客户端redisClient = RedisClient.create(redisURI);// 创建redis连接connection = redisClient.connect();}@Afterpublic void after() {connection.close();redisClient.shutdown();}

Redis命令API的具体实现可以直接从StatefulRedisConnection实例获取，见其接口定义：

public interface StatefulRedisConnection<K, V> extends StatefulConnection<K, V> {boolean isMulti();RedisCommands<K, V> sync();RedisAsyncCommands<K, V> async();RedisReactiveCommands<K, V> reactive();
}

值得注意的是，在不指定编码解码器RedisCodec的前提下，RedisClient创建的StatefulRedisConnection实例一般是泛型实例StatefulRedisConnection<String,String>，也就是所有命令API的KEY和VALUE都是String类型，这种使用方式能满足大部分的使用场景。当然，必要的时候可以定制编码解码器RedisCodec<K,V>。

2.1，同步API

同步API在所有命令调用之后会立即返回结果。和上一篇介绍的Jedis差不多，RedisCommands的用法其实和它相差不大。

	@Testpublic void testSync(){RedisCommands<String, String> redisCommands = connection.sync();redisCommands.set("name","bobo");System.out.println(redisCommands.get("name"));}
2.2，异步API
	@Testpublic void testAsync() throws ExecutionException, InterruptedException {RedisAsyncCommands<String, String> redisAsyncCommands = connection.async();RedisFuture<String> redisFuture = redisAsyncCommands.set("name", "bobo");System.out.println(redisFuture.get());System.out.println("get2:" + redisAsyncCommands.get("name").get());}

RedisAsyncCommands所有方法执行返回结果都是RedisFuture实例，而RedisFuture接口的定义如下：

public interface RedisFuture<V> extends CompletionStage<V>, Future<V> {String getError();boolean await(long timeout, TimeUnit unit) throws InterruptedException;
}

也就是，RedisFuture可以无缝使用Future或者JDK1.8中引入的CompletableFuture提供的方法。

2.3，反应式API

Lettuce引入的反应式编程框架是Project Reactor，如果没有反应式编程经验可以先自行了解一下Project Reactor。

构建RedisReactiveCommands实例：

	@Testpublic void testReactive(){RedisReactiveCommands<String, String> redisReactiveCommands = connection.reactive();redisReactiveCommands.set("name", "bobo");System.out.println(redisReactiveCommands.get("name"));redisReactiveCommands.sadd("fruit","apple","banana");System.out.println(redisReactiveCommands.smembers("fruit"));}

运行输出：

MonoFromPublisher
FluxSource

RedisReactiveCommands的方法如果返回的结果只包含0或1个元素，那么返回值类型是Mono，如果返回的结果包含0到N（N大于0）个元素，那么返回值是Flux。

3，发布/订阅

非集群模式下的发布订阅依赖于定制的连接StatefulRedisPubSubConnection，集群模式下的发布订阅依赖于定制的连接StatefulRedisClusterPubSubConnection，两者分别来源于RedisClient#connectPubSub()系列方法和RedisClusterClient#connectPubSub()：

非集群模式：

// 可能是单机、普通主从、哨兵等非集群模式的客户端
RedisClient client = ...
StatefulRedisPubSubConnection<String, String> connection = client.connectPubSub();
connection.addListener(new RedisPubSubListener<String, String>() { ... });// 同步命令
RedisPubSubCommands<String, String> sync = connection.sync();
sync.subscribe("channel");// 异步命令
RedisPubSubAsyncCommands<String, String> async = connection.async();
RedisFuture<Void> future = async.subscribe("channel");// 反应式命令
RedisPubSubReactiveCommands<String, String> reactive = connection.reactive();
reactive.subscribe("channel").subscribe();reactive.observeChannels().doOnNext(patternMessage -> {...}).subscribe()

集群模式：

// 使用方式其实和非集群模式基本一致
RedisClusterClient clusterClient = ...
StatefulRedisClusterPubSubConnection<String, String> connection = clusterClient.connectPubSub();
connection.addListener(new RedisPubSubListener<String, String>() { ... });
RedisPubSubCommands<String, String> sync = connection.sync();
sync.subscribe("channel");
// ...

4，管道

Redis的Pipeline也就是管道机制可以理解为把多个命令打包在一次请求发送到Redis服务端，然后Redis服务端把所有的响应结果打包好一次性返回，从而节省不必要的网络资源（最主要是减少网络请求次数）。Redis对于Pipeline机制如何实现并没有明确的规定，也没有提供特殊的命令支持Pipeline机制。Jedis中底层采用BIO（阻塞IO）通讯，所以它的做法是客户端缓存将要发送的命令，最后需要触发然后同步发送一个巨大的命令列表包，再接收和解析一个巨大的响应列表包。

Pipeline在Lettuce中对使用者是透明的，由于底层的通讯框架是Netty，所以网络通讯层面的优化Lettuce不需要过多干预，换言之可以这样理解：Netty帮Lettuce从底层实现了Redis的Pipeline机制。

5，事物

事务相关的命令就是WATCH、UNWATCH、EXEC、MULTI和DISCARD，在RedisCommands系列接口中有对应的方法。举个例子：

	@Testpublic void testMulti() {RedisCommands<String, String> redisCommands = connection.sync();redisCommands.multi();redisCommands.set("name", "bobo");redisCommands.set("age", "18");redisCommands.exec();System.out.println(redisCommands.get("name"));System.out.println(redisCommands.get("age"));}

运行输出：

bobo
18

6，普通主从模式

假设现在有三个Redis服务形成树状主从关系如下：

  • 节点一：localhost:6379，角色为Master。
  • 节点二：localhost:6380，角色为Slavor，节点一的从节点。
  • 节点三：localhost:6381，角色为Slavor，节点二的从节点。
@Test
public void testStaticReplica() throws Exception {List<RedisURI> uris = new ArrayList<>();RedisURI uri1 = RedisURI.builder().withHost("localhost").withPort(6379).build();RedisURI uri2 = RedisURI.builder().withHost("localhost").withPort(6380).build();RedisURI uri3 = RedisURI.builder().withHost("localhost").withPort(6381).build();uris.add(uri1);uris.add(uri2);uris.add(uri3);RedisClient redisClient = RedisClient.create();StatefulRedisMasterSlaveConnection<String, String> connection = MasterSlave.connect(redisClient,new Utf8StringCodec(), uris);// 只从主节点读取数据connection.setReadFrom(ReadFrom.MASTER);// 执行其他Redis命令connection.close();redisClient.shutdown();
}

7，哨兵

由于Lettuce自身提供了哨兵的拓扑发现机制，所以只需要随便配置一个哨兵节点的RedisURI实例即可：

@Test
public void testDynamicSentinel() throws Exception {RedisURI redisUri = RedisURI.builder().withPassword("你的密码").withSentinel("localhost", 26379).withSentinelMasterId("哨兵Master的ID").build();RedisClient redisClient = RedisClient.create();StatefulRedisMasterSlaveConnection<String, String> connection = MasterSlave.connect(redisClient, new Utf8StringCodec(), redisUri);// 只允许从从节点读取数据connection.setReadFrom(ReadFrom.SLAVE);RedisCommands<String, String> command = connection.sync();SetArgs setArgs = SetArgs.Builder.nx().ex(5);command.set("name", "throwable", setArgs);String value = command.get("name");log.info("Get value:{}", value);
}

8，集群

下面的API提供跨槽位（Slot）调用的功能：

  • RedisAdvancedClusterCommands。
  • RedisAdvancedClusterAsyncCommands。
  • RedisAdvancedClusterReactiveCommands。

静态节点选择功能：

  • masters：选择所有主节点执行命令。
  • slaves：选择所有从节点执行命令，其实就是只读模式。
  • all nodes：命令可以在所有节点执行。

集群拓扑视图动态更新功能：

  • 手动更新，主动调用RedisClusterClient#reloadPartitions()。
  • 后台定时更新。
  • 自适应更新，基于连接断开和MOVED/ASK命令重定向自动更新。

简单的集群连接和使用方式如下：

	@Testpublic void testCluster() {Set<RedisURI> redisURISet = new HashSet<>();redisURISet.add(RedisURI.builder().withHost("127.0.0.1").withPort(7000).build());redisURISet.add(RedisURI.builder().withHost("127.0.0.1").withPort(7001).build());redisURISet.add(RedisURI.builder().withHost("127.0.0.1").withPort(7002).build());RedisClusterClient redisClusterClient = RedisClusterClient.create(redisURISet);StatefulRedisClusterConnection<String, String> connect = redisClusterClient.connect();RedisAdvancedClusterCommands<String, String> clusterCommands = connect.sync();clusterCommands.set("name","bobo");System.out.println(clusterCommands.get("name"));}

集群节点信息如下：

在这里插入图片描述

这篇关于吃透Redis系列（十一）：Jedis和Lettuce客户端详细介绍的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1131644。

相关文章

使用Dify访问mysql数据库详细代码示例

使用Dify访问mysql数据库详细代码示例

《使用Dify访问mysql数据库详细代码示例》：本文主要介绍使用Dify访问mysql数据库的相关资料,并详细讲解了如何在本地搭建数据库访问服务,使用ngrok暴露到公网,并创建知识库、数据库访... 1、在本地搭建数据库访问的服务，并使用ngrok暴露到公网。#sql_tools.pyfrom
阅读更多...
java导出pdf文件的详细实现方法

java导出pdf文件的详细实现方法

《java导出pdf文件的详细实现方法》：本文主要介绍java导出pdf文件的详细实现方法,包括制作模板、获取中文字体文件、实现后端服务以及前端发起请求并生成下载链接,需要的朋友可以参考下... 目录使用注意点包含内容1、制作pdf模板2、获取pdf导出中文需要的文件3、实现4、前端发起请求并生成下载链接使
阅读更多...
IDEA连接达梦数据库的详细配置指南

IDEA连接达梦数据库的详细配置指南

《IDEA连接达梦数据库的详细配置指南》达梦数据库（DMDatabase）作为国产关系型数据库的代表,广泛应用于企业级系统开发,本文将详细介绍如何在IntelliJIDEA中配置并连接达梦数据库,助力... 目录准备工作1. 下载达梦JDBC驱动配置步骤1. 将驱动添加到IDEA2. 创建数据库连接连接参数
阅读更多...
2025最新版Python3.13.1安装使用指南(超详细)

2025最新版Python3.13.1安装使用指南(超详细)

《2025最新版Python3.13.1安装使用指南(超详细)》Python编程语言自诞生以来,已经成为全球最受欢迎的编程语言之一,它简单易学易用,以标准库和功能强大且广泛外挂的扩展库,为用户提供包罗... 目录2025最新版python 3.13.1安装使用指南1. 2025年Python语言最新排名2.
阅读更多...
JAVA SE包装类和泛型详细介绍及说明方法

JAVA SE包装类和泛型详细介绍及说明方法

《JAVASE包装类和泛型详细介绍及说明方法》：本文主要介绍JAVASE包装类和泛型的相关资料,包括基本数据类型与包装类的对应关系,以及装箱和拆箱的概念,并重点讲解了自动装箱和自动拆箱的机制,文... 目录1. 包装类1.1 基本数据类型和对应的包装类1.2 装箱和拆箱1.3 自动装箱和自动拆箱2. 泛型2
阅读更多...
Java中使用注解校验手机号格式的详细指南

Java中使用注解校验手机号格式的详细指南

《Java中使用注解校验手机号格式的详细指南》在现代的Web应用开发中,数据校验是一个非常重要的环节,本文将详细介绍如何在Java中使用注解对手机号格式进行校验,感兴趣的小伙伴可以了解下... 目录1. 引言2. 数据校验的重要性3. Java中的数据校验框架4. 使用注解校验手机号格式4.1 @NotBl
阅读更多...
Redis客户端工具之RedisInsight的下载方式

Redis客户端工具之RedisInsight的下载方式

《Redis客户端工具之RedisInsight的下载方式》RedisInsight是Redis官方提供的图形化客户端工具,下载步骤包括访问Redis官网、选择RedisInsight、下载链接、注册... 目录Redis客户端工具RedisInsight的下载一、点击进入Redis官网二、点击RedisI
阅读更多...
Redis实现RBAC权限管理

Redis实现RBAC权限管理

《Redis实现RBAC权限管理》本文主要介绍了Redis实现RBAC权限管理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1. 什么是 RBAC？2. 为什么使用 Redis 实现 RBAC？3. 设计 RBAC 数据结构
阅读更多...
Redis 内存淘汰策略深度解析(最新推荐)

Redis 内存淘汰策略深度解析(最新推荐)

《Redis内存淘汰策略深度解析(最新推荐)》本文详细探讨了Redis的内存淘汰策略、实现原理、适用场景及最佳实践,介绍了八种内存淘汰策略,包括noeviction、LRU、LFU、TTL、Rand... 目录一、 内存淘汰策略概述二、内存淘汰策略详解2.1 ​noeviction（不淘汰）​2.2 ​LR
阅读更多...
Spring AI集成DeepSeek三步搞定Java智能应用的详细过程

Spring AI集成DeepSeek三步搞定Java智能应用的详细过程

《SpringAI集成DeepSeek三步搞定Java智能应用的详细过程》本文介绍了如何使用SpringAI集成DeepSeek,一个国内顶尖的多模态大模型,SpringAI提供了一套统一的接口,简... 目录DeepSeek 介绍Spring AI 是什么？Spring AI 的主要功能包括1、环境准备2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2