吃透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。

相关文章

Python进阶之Excel基本操作介绍

Python进阶之Excel基本操作介绍

《Python进阶之Excel基本操作介绍》在现实中,很多工作都需要与数据打交道,Excel作为常用的数据处理工具,一直备受人们的青睐,本文主要为大家介绍了一些Python中Excel的基本操作,希望... 目录概述写入使用 xlwt使用 XlsxWriter读取修改概述在现实中，很多工作都需要与数据打交
阅读更多...
java脚本使用不同版本jdk的说明介绍

java脚本使用不同版本jdk的说明介绍

《java脚本使用不同版本jdk的说明介绍》本文介绍了在Java中执行JavaScript脚本的几种方式,包括使用ScriptEngine、Nashorn和GraalVM,ScriptEngine适用... 目录Java脚本使用不同版本jdk的说明1.使用ScriptEngine执行javascript2.
阅读更多...
Python手搓邮件发送客户端

Python手搓邮件发送客户端

《Python手搓邮件发送客户端》这篇文章主要为大家详细介绍了如何使用Python手搓邮件发送客户端,支持发送邮件,附件,定时发送以及个性化邮件正文,感兴趣的可以了解下... 目录1. 简介2.主要功能2.1.邮件发送功能2.2.个性签名功能2.3.定时发送功能2. 4.附件管理2.5.配置加载功能2.6.
阅读更多...
Redis主从/哨兵机制原理分析

Redis主从/哨兵机制原理分析

《Redis主从/哨兵机制原理分析》本文介绍了Redis的主从复制和哨兵机制,主从复制实现了数据的热备份和负载均衡,而哨兵机制可以监控Redis集群,实现自动故障转移,哨兵机制通过监控、下线、选举和故... 目录一、主从复制1.1 什么是主从复制1.2 主从复制的作用1.3 主从复制原理1.3.1 全量复制
阅读更多...
Redis延迟队列的实现示例

Redis延迟队列的实现示例

《Redis延迟队列的实现示例》Redis延迟队列是一种使用Redis实现的消息队列,本文主要介绍了Redis延迟队列的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习... 目录一、什么是 Redis 延迟队列二、实现原理三、Java 代码示例四、注意事项五、使用 Redi
阅读更多...
Redis缓存问题与缓存更新机制详解

Redis缓存问题与缓存更新机制详解

《Redis缓存问题与缓存更新机制详解》本文主要介绍了缓存问题及其解决方案,包括缓存穿透、缓存击穿、缓存雪崩等问题的成因以及相应的预防和解决方法,同时,还详细探讨了缓存更新机制,包括不同情况下的缓存更... 目录一、缓存问题1.1 缓存穿透1.1.1 问题来源1.1.2 解决方案1.2 缓存击穿1.2.1
阅读更多...
redis-cli命令行工具的使用小结

redis-cli命令行工具的使用小结

《redis-cli命令行工具的使用小结》redis-cli是Redis的命令行客户端,支持多种参数用于连接、操作和管理Redis数据库,本文给大家介绍redis-cli命令行工具的使用小结,感兴趣的... 目录基本连接参数基本连接方式连接远程服务器带密码连接操作与格式参数-r参数重复执行命令-i参数指定命
阅读更多...
深入理解Redis大key的危害及解决方案

深入理解Redis大key的危害及解决方案

《深入理解Redis大key的危害及解决方案》本文主要介绍了深入理解Redis大key的危害及解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着... 目录一、背景二、什么是大key三、大key评价标准四、大key 产生的原因与场景五、大key影响与危
阅读更多...
Java操作PDF文件实现签订电子合同详细教程

Java操作PDF文件实现签订电子合同详细教程

《Java操作PDF文件实现签订电子合同详细教程》：本文主要介绍如何在PDF中加入电子签章与电子签名的过程,包括编写Word文件、生成PDF、为PDF格式做表单、为表单赋值、生成文档以及上传到OB... 目录前言：先看效果：1.编写word文件1.2然后生成PDF格式进行保存1.3我这里是将文件保存到本地后
阅读更多...
windows系统下shutdown重启关机命令超详细教程

windows系统下shutdown重启关机命令超详细教程

《windows系统下shutdown重启关机命令超详细教程》shutdown命令是一个强大的工具,允许你通过命令行快速完成关机、重启或注销操作,本文将为你详细解析shutdown命令的使用方法,并提... 目录一、shutdown 命令简介二、shutdown 命令的基本用法三、远程关机与重启四、实际应用
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2