Redis（key-value）数据库

谁践踏了优雅 2024-03-25 23:58 40阅读 0赞

## Redis ##

[KuangStudy][]

Redis学习视频：[狂神说Redis教程][Redis]

KuangStudy
    https://www.kuangstudy.com/course
    
    Redis学习视频(狂神说):
    https://www.bilibili.com/video/BV1S54y1R7SB/?p=1
    
    Redis官网：
    https://redis.io/
    
    Redis中文网：
    http://redis.cn/
    
    Github（Redis）:
    https://github.com/dmajkic/redis

### 一、NoSQL概述 ###

大数据时代，一般的数据库无法进行分析处理了Hadoop

#### 一、 单机SQL时代，更多使用静态网页 ####

*  如果数据量过大，一个机器放不下
 *  数据量超过300万时一定要创建索引，数据库现在使用B+Tree，一个机器的内存也放不下
 *  数据库访问量比较大，一开始是读写混合的，一个服务器也承受不了

![1640596516728][]

出现这三种情况，就需要升级，但是如果没有这么大的数据量，应该从单机开始

#### 二、Memcached缓存+MySQL+垂直拆分（读写分离） ####

网站百80%的操作都是在读，减轻数据库的压力可以使用缓存提高效率，缓存使用什么技术都没所谓

*  发展过程，先是优化数据结构和索引–文件缓存（IO操作）–Memcached（当时最热门的技术）

![1640597548690][]

#### 三、分库分表+水平拆分+MSQL集群 ####

使用缓存解决了读的问题，用分集群的方式解决读的问题，数据存在不同的库中

![1640598325081][]

早些年MySAM ：表锁，读取一行要将整个表锁起来，十分影响效率，高并发下会出现严重问题

后来转为innodb ：行锁

慢慢的就开始使用分库分表来解决写的压力，将表拆分，不同的业务使用不同表，存放在不同的数据库中，不同的业务使用单独的数据库，结合微服务，mysql推出了表分区，但是很少公司使用

Mysql的集群已经满足了那个年代的需求

#### 四、最近的年代 ####

定位也是一种数据，Mysql的关系型数据库已经不够用了，数据量多，变化快，

非关系型数据库

Json  
Bson  
图型数据库  
放在缓存中一段时间之后再进行持久化的操作，来保证效率和安全

存储很大的文件，会导致数据表很大效率会变低， 如果有一种专门的数据库来处理这种数据Mysql压力就会变得十分小，研究如何处理这些问题

如果数据量变大，要在对数据库进行更改，增加一行是很难的

用户先访问企业防火墙，到负载均衡的主机，到App服务器，到mysql实例，然后是独立功能的服务器  
![1640599170445][]

#### 五、最后总结为什么要用NoSQL ####

用户的个人信息、社交网络、地理位置、用户自己生产的数据、用户日志等等数据爆发式的生长，

NoSQL=Not Only SQL 不仅仅是SQL

泛指非关系型数据库，Web2.0的诞生，传统的关系型数据库很难对付Web2.0时代，尤其是超大规模的高并发的社区，

NoSQL在大数据环境下发展十分迅速

要存储的数据不是固定格式，以键值对来控制，Map< String , Object >,数据之间没有关系就很好扩展，Java现在要做面向接口编程也是为了解耦，

使用Redis也是为了高性能，官方的数据读取速度每秒11w次，写8w次
    
    数据类型是多样性的，不需要事先设计数据库，不需要设计键值对，随取随用
    
    传统的RDBMS和NoSQL

传统的RDBMS

结构化组织
    sql
    数据和关系都存储在表中 row column
    数据定义语言
    严格的一致性
    基础的事务
    。。。。。

NoSQL

不仅仅是数据
    没有固定查询语言
    很多的存储方式，键值对存储，列存储、文档存储、图形存储（社交关系）
    可以不用满足严格一致性，数据是可以有误差的，要保证的是最终一致性
    CAP定理，和BASE理论
    高性能、高可用、高可扩展
    。。。。。

#### 六、大数据时代的3V和3高 ####

大数据时代的3V，主要是描述问题的

*  海量的Volume
 *  多样的Variety
 *  实时Velocity

大数据时代的3高，主要是对程序的要求

*  高并发
 *  高可拓（随时水平拆分，机器不足，可用扩展来）
 *  高性能

真正在公司中实践一定是：NoSQL+RDBMS一起使用才是最好的

#### 七、阿里巴巴框架演进 ####

![1640658307465][]

# 商品信息
    - 一般存放在关系型数据库：Mysql,阿里巴巴使用的Mysql都是经过内部改动的。
    
    # 商品描述、评论(文字居多)
    - 文档型数据库：MongoDB
    
    # 图片
    - 分布式文件系统 FastDFS
    - 淘宝：TFS
    - Google: GFS
    - Hadoop: HDFS
    - 阿里云: oss
    
    # 商品关键字 用于搜索
    - 搜索引擎：solr,elasticsearch
    - 阿里：Isearch 多隆
    
    # 商品热门的波段信息
    - 内存数据库：Redis，Memcache
    
    # 商品交易，外部支付接口
    - 第三方应用

#### 八、Nosql的四大分类 ####

KV键值对

*  新浪：**Redis**
 *  美团：Redis + Tair
 *  阿里、百度：Redis + Memcache

文档型数据库（bson数据格式，与json格式一样）：

*  **MongoDB**(掌握)
    
     *  基于分布式文件存储的数据库。C++编写，用于处理大量文档。
     *  MongoDB是RDBMS(关系型数据库)和NoSQL（非关系型数据库）的中间产品。MongoDB是非关系型数据库中功能最丰富的，NoSQL中最像关系型数据库的数据库。
 *  ConthDB

列存储数据库

*  **HBase**(大数据必学)
 *  分布式文件系统

图关系数据库

用于广告推荐，社交网络

*  **Neo4j**、InfoGrid

![1640668419781][]

### 二、Redis入门 ###

#### 一、概述 ####

Redis是什么？

Redis（Remote Dictionary Server )，即远程字典服务。

*  是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
 *  与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis能干嘛？

*  内存存储、持久化，内存是断电即失的，所以需要持久化（RDB、AOF）
 *  高效率、用于高速缓冲
 *  发布订阅系统
 *  地图信息分析
 *  计时器、计数器(eg：浏览量)

特性

*  多样的数据类型
 *  持久化
 *  集群
 *  事务

#### 二、环境搭建 ####

官网：https://redis.io/

中文网：http://redis.cn/

Redis推荐使用Linux服务器学习。

windows版本的Redis（已经停更很久了）

![1640671079919][]

#### 三、Windows安装 ####

1.  下载安装包：https://github.com/dmajkic/redis
2.  解压安装包
3.  解压到电脑环境目录下
4.  开启redis-server.exe，双击启动即可（端口号：6379，进程号：15852，官网：https://redis.io/）
5.  使用Redis客户端连接Redis

![1640670817326][]

#### 四、Linux安装 ####

1、下载Redis安装包（官网：https://redis.io/）

2、上传远程服务器 /home/Jin 目录下

![1640677332349][]

3、解压安装包到/opt目录下

![1640677824044][]

4、进入解压后的文件，可以看到Redis的配置文件

![1640677988447][]

5、基本的环境命令

![1640678134043][]

[root@Jin redis-6.2.6]# make

![1640678520553][]

![1640678581333][]

6、redis默认的安装路劲（ */usr/local/bin*）

![1640678917371][]

7、将redis配置文件复制到当前目录下（创建一个Jinconfig放置）

![1640679155606][]

8、redis默认不是后台启动的，需要修改配置文件！

[root@Jin Jinconfig]# vim redis.conf

按 i 进入编辑，下拉到此更改！

![1640679506711][]

按 esc 进行退出编辑，按 ：wq 进行保存，回车

![1640679627567][]

9、使用redis-server启动Redis服务

![1640679790581][]

10、使用redis-cli进行连接测试

![1640679978542][]

11、(端口2)查看 redis的进程是否开启（重开端口测试）

![1640680220700][]

12、关闭Redis服务和查看Redis进程是否存在

![1640680319790][]

#### 五、测试性能（redis-benchmark） ####

\*\*redis-benchmark：\*\*Redis官方提供的性能测试工具，参数选项如下：

![1640680742473][]

测试：100个并发连接 100000请求

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

（端口1）启动redis服务端和客户端服务

![1640681422643][]

（端口2）查看Redis进程是否存在，并进入 /usr/local/bin 进行测试

![1640681680042][]

![1640681999084][]

#### 六、基础知识 ####

redis默认有16个数据库

（端口2）查看Redis默认总共有多少个数据库（16个）

![1640682258014][]

![1640682323301][]

默认使用的是第0个

（端口1）切换数据库和查看当前数据库大小

![1640682475962][]

![1640682692716][]

keys * ：查看当前数据库中所有的key。
    
    flushdb：清空当前数据库中的键值对。
    
    flushall：清空所有数据库的键值对。

(端口1)查看数据库所有的key

127.0.0.1:6379[3]> keys *
    1) "name"

![1640682820674][]

(端口1)清除\*\*当前（本数据库）\*\*数据库中所有的key flushdb

![1640682906473][]

（端口1）清除\*\*全部（16个数据库）\*\*数据库的key flushall

127.0.0.1:6379[3]> flushall
    OK

Redis5是单线程的，Redis6是多线程的 (Redis是C语言写的)

核心：Redis是将所有的数据放在内存中的，所以说使用单线程去操作效率就是最高的，多线程（CPU上下文会切换：耗时的操作！），对于内存系统来说，如果没有上下文切换效率就是最高的，多次读写都是在一个CPU上的，在内存存储数据情况下，就是最佳的方案。

### 三、五大数据类型 ###

Redis官网简介：https://redis.io/

![1640684116954][]

Redis中文网简介：http://redis.cn/

![1640684139562][]

#### 一、Redis-key ####

（端口1）启动Redis并清空数据库

![1640684585662][]

（端口2）确保Redis进程启动

![1640684605216][]

1、exists key：判断键是否存在  
2、del key：删除键值对  
3、move key db：将键值对移动到指定数据库  
4、expire key second：设置键值对的过期时间（在此second之下使用 ttl name 查看是否过期了）  
5、type key：查看value的数据类型

127.0.0.1:6379> keys *			#查看当前数据库所有key
    (empty array)
    127.0.0.1:6379> set name Jin	#set key
    OK
    127.0.0.1:6379> set age 1
    OK
    127.0.0.1:6379> keys *
    1) "age"
    2) "name"
    127.0.0.1:6379> exists name		#判断当前的key是否存在
    (integer) 1				# 存在
    127.0.0.1:6379> exists name1	#判断当前的key是否存在
    (integer) 0				# 不存在
    127.0.0.1:6379> move name 1		# 将键值对移动到指定数据库
    (integer) 1
    127.0.0.1:6379> keys *
    1) "age"
    127.0.0.1:6379> set name Jin
    OK
    127.0.0.1:6379> keys *
    1) "age"
    2) "name"
    127.0.0.1:6379> get name
    "Jin"
    127.0.0.1:6379> get age
    "1"
    127.0.0.1:6379> expire name 10	  # 设置键值对的过期时间（10s）
    (integer) 1					     # 设置成功 开始计数
    127.0.0.1:6379> ttl name		  # 查看key的过期剩余时间
    (integer) 7
    127.0.0.1:6379> ttl name
    (integer) 5
    127.0.0.1:6379> ttl name
    (integer) 3
    127.0.0.1:6379> ttl name
    (integer) -2				   # -2 表示key过期，-1表示key未设置过期时间
    127.0.0.1:6379> get name		# 过期的key 会被自动delete
    (nil)
    127.0.0.1:6379> keys *
    1) "age"
    127.0.0.1:6379> del age			# 删除键值对
    (integer) 1					   # 删除个数
    127.0.0.1:6379> keys *
    (empty array)
    127.0.0.1:6379> type name		#查看当前value的数据类型
    string

#### 二、String（字符串） ####

<table> 
 <thead> 
  <tr> 
   <th align="center">**命令原型 **</th> 
   <th align="center"><strong>时间复杂度</strong></th> 
   <th align="center"><strong>命令描述</strong></th> 
   <th align="center"><strong>返回值</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>APPEND</strong>keyvalue</td> 
   <td align="center">O(1)</td> 
   <td align="center">如果该Key已经存在，APPEND命令将参数Value的数据追加到已存在Value的末尾。如果该Key不存在，APPEND命令将会创建一个新的Key/Value。</td> 
   <td align="center">追加后Value的长度。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>DECR</strong>key</td> 
   <td align="center">O(1)</td> 
   <td align="center">将指定Key的Value原子性的递减1。如果该Key不存在，其初始值为0，在decr之后其值为-1。如果Value的值不能转换为整型值，如Hello，该操作将执行失败并返回相应的错误信息。注意：该操作的取值范围是64位有符号整型。</td> 
   <td align="center">递减后的Value值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>INCR</strong>key</td> 
   <td align="center">O(1)</td> 
   <td align="center">将指定Key的Value原子性的递增1。如果该Key不存在，其初始值为0，在incr之后其值为1。如果Value的值不能转换为整型值，如Hello，该操作将执行失败并返回相应的错误信息。注意：该操作的取值范围是64位有符号整型。</td> 
   <td align="center">递增后的Value值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>DECRBY</strong>key decrement</td> 
   <td align="center">O(1)</td> 
   <td align="center">将指定Key的Value原子性的减少decrement。如果该Key不存在，其初始值为0，在decrby之后其值为-decrement。如果Value的值不能转换为整型值，如Hello，该操作将执行失败并返回相应的错误信息。注意：该操作的取值范围是64位有符号整型。</td> 
   <td align="center">减少后的Value值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>INCRBY</strong>key increment</td> 
   <td align="center">O(1)</td> 
   <td align="center">将指定Key的Value原子性的增加increment。如果该Key不存在，其初始值为0，在incrby之后其值为increment。如果Value的值不能转换为整型值，如Hello，该操作将执行失败并返回相应的错误信息。注意：该操作的取值范围是64位有符号整型。</td> 
   <td align="center">增加后的Value值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>GET</strong>key</td> 
   <td align="center">O(1)</td> 
   <td align="center">获取指定Key的Value。如果与该Key关联的Value不是string类型，Redis将返回错误信息，因为GET命令只能用于获取string Value。</td> 
   <td align="center">与该Key相关的Value，如果该Key不存在，返回nil。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>SET</strong>key value</td> 
   <td align="center">O(1)</td> 
   <td align="center">设定该Key持有指定的字符串Value，如果该Key已经存在，则覆盖其原有值。</td> 
   <td align="center">总是返回"OK"。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>GETSET</strong>key value</td> 
   <td align="center">O(1)</td> 
   <td align="center">原子性的设置该Key为指定的Value，同时返回该Key的原有值。和GET命令一样，该命令也只能处理string Value，否则Redis将给出相关的错误信息。</td> 
   <td align="center">返回该Key的原有值，如果该Key之前并不存在，则返回nil。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>STRLEN</strong>key</td> 
   <td align="center">O(1)</td> 
   <td align="center">返回指定Key的字符值长度，如果Value不是string类型，Redis将执行失败并给出相关的错误信息。</td> 
   <td align="center">返回指定Key的Value字符长度，如果该Key不存在，返回0。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>SETEX</strong>key seconds value</td> 
   <td align="center">O(1)</td> 
   <td align="center">原子性完成两个操作，一是设置该Key的值为指定字符串，同时设置该Key在Redis服务器中的存活时间(秒数)。该命令主要应用于Redis被当做Cache服务器使用时。</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center"><strong>SETNX</strong>key value</td> 
   <td align="center">O(1)</td> 
   <td align="center">如果指定的Key不存在，则设定该Key持有指定字符串Value，此时其效果等价于SET命令。相反，如果该Key已经存在，该命令将不做任何操作并返回。</td> 
   <td align="center">1表示设置成功，否则0。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>SETRANGE</strong>key offset value</td> 
   <td align="center">O(1)</td> 
   <td align="center">替换指定Key的部分字符串值。从offset开始，替换的长度为该命令第三个参数value的字符串长度，其中如果offset的值大于该Key的原有值Value的字符串长度，Redis将会在Value的后面补齐(offset - strlen(value))数量的0x00，之后再追加新值。如果该键不存在，该命令会将其原值的长度假设为0，并在其后添补offset个0x00后再追加新值。鉴于字符串Value的最大长度为512M，因此offset的最大值为536870911。最后需要注意的是，如果该命令在执行时致使指定Key的原有值长度增加，这将会导致Redis重新分配足够的内存以容纳替换后的全部字符串，因此就会带来一定的性能折损。</td> 
   <td align="center">修改后的字符串Value长度。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>GETRANGE</strong>key start end</td> 
   <td align="center">O(1)</td> 
   <td align="center">如果截取的字符串长度很短，我们可以该命令的时间复杂度视为O(1)，否则就是O(N)，这里N表示截取的子字符串长度。该命令在截取子字符串时，将以闭区间的方式同时包含start*(0表示第一个字符)*和end所在的字符，如果end值超过Value的字符长度，该命令将只是截取从start开始之后所有的字符数据。</td> 
   <td align="center">子字符串</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>SETBIT</strong>key offset value</td> 
   <td align="center">O(1)</td> 
   <td align="center">设置在指定Offset上BIT的值，该值只能为1或0，在设定后该命令返回该Offset上原有的BIT值。如果指定Key不存在，该命令将创建一个新值，并在指定的Offset上设定参数中的BIT值。如果Offset大于Value的字符长度，Redis将拉长Value值并在指定Offset上设置参数中的BIT值，中间添加的BIT值为0。最后需要说明的是Offset值必须大于0。</td> 
   <td align="center">在指定Offset上的BIT原有值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>GETBIT</strong>key offset</td> 
   <td align="center">O(1)</td> 
   <td align="center">返回在指定Offset上BIT的值，0或1。如果Offset超过string value的长度，该命令将返回0，所以对于空字符串始终返回0。</td> 
   <td align="center">在指定Offset上的BIT值。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>MGET</strong>key [key …]</td> 
   <td align="center">O(N)</td> 
   <td align="center">N表示获取Key的数量。返回所有指定Keys的Values，如果其中某个Key不存在，或者其值不为string类型，该Key的Value将返回nil。</td> 
   <td align="center">返回一组指定Keys的Values的列表。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>MSET</strong>key value [key value …]</td> 
   <td align="center">O(N)</td> 
   <td align="center">N表示指定Key的数量。该命令原子性的完成参数中所有key/value的设置操作，其具体行为可以看成是多次迭代执行SET命令。</td> 
   <td align="center">该命令不会失败，始终返回OK。</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>MSETNX</strong>key value [key value …]</td> 
   <td align="center">O(N)</td> 
   <td align="center">N表示指定Key的数量。该命令原子性的完成参数中所有key/value的设置操作，其具体行为可以看成是多次迭代执行SETNX命令。然而这里需要明确说明的是，<em>如果在这一批Keys中有任意一个Key已经存在了，那么该操作将全部回滚，即所有的修改都不会生效。</em></td> 
   <td align="center">1表示所有Keys都设置成功，0则表示没有任何Key被修改。</td> 
  </tr> 
 </tbody> 
</table>

![1640742550009][]

###########################################################################################
    127.0.0.1:6379> set key1 v1				#设置值
    OK
    127.0.0.1:6379> get key1				#获得值
    "v1"
    127.0.0.1:6379> keys *					#获得所有的key
    1) "age"
    2) "name"
    3) "key1"
    127.0.0.1:6379> exists key1
    (integer) 1
    127.0.0.1:6379> append key1 "hello"		#追加字符串，如果当前key不存在，就相当于setkey
    (integer) 7
    127.0.0.1:6379> get key1
    "v1hello"
    127.0.0.1:6379> strlen key1				#获取字符串的长度
    (integer) 7
    127.0.0.1:6379> append key1 ",Jin"
    (integer) 11
    127.0.0.1:6379> get key1
    "v1hello,Jin"
    ##############################################################################################

##############################################################################################
    127.0.0.1:6379> set views 0		#初始浏览量为0
    OK
    127.0.0.1:6379> get views
    "0"
    127.0.0.1:6379> incr views		#自增1
    (integer) 1
    127.0.0.1:6379> incr views
    (integer) 2
    127.0.0.1:6379> incr views
    (integer) 3
    127.0.0.1:6379> incr views
    (integer) 4
    127.0.0.1:6379> incr views
    (integer) 5
    127.0.0.1:6379> get views
    "5"
    127.0.0.1:6379> decr views		#自减1
    (integer) 4
    127.0.0.1:6379> decr views
    (integer) 3
    127.0.0.1:6379> get views
    "3"
    127.0.0.1:6379> incrby views 10		#可以设置步长，指定增量
    (integer) 13
    127.0.0.1:6379> incrby views 10
    (integer) 23
    127.0.0.1:6379> get views
    "23"
    127.0.0.1:6379> decrby views 5		#可以设置步长，指定减量
    (integer) 18
    127.0.0.1:6379> decrby views 5
    (integer) 13
    
    127.0.0.1:6379> decrby view 5		#可以设置步长，指定减量（从没有进行创建）
    (integer) -5
    127.0.0.1:6379> decrby view 5
    (integer) -10
    ##############################################################################################

##############################################################################################
    127.0.0.1:6379> set key1 "Hello,Jin"	#设置key1的值
    OK
    127.0.0.1:6379> get key1
    "Hello,Jin"
    127.0.0.1:6379> getrange key1 0 5		#截取字符串【start，end】
    "Hello,"
    127.0.0.1:6379> getrange key1 0 -1		#截取全部的字符串【0，-1】
    "Hello,Jin"
    
    127.0.0.1:6379> set key2 "abcdefg"		#设置key2的值
    OK
    127.0.0.1:6379> get key2
    "abcdefg"
    127.0.0.1:6379> setrange key2 1 xx		#替换指定位置的字符串【start，String类型】
    (integer) 7
    127.0.0.1:6379> get key2
    "axxdefg"
    ##############################################################################################

##############################################################################################
    # setex (set with expire) #设置过期时间
    # setnx （set if no exist）#不存在在设置（分布式锁中使用）
    ##############################################################################################
    127.0.0.1:6379> clear
    127.0.0.1:6379> setex key3 30 "hello"	#设置key3的值为hello，30s后过期
    OK
    127.0.0.1:6379> ttl key3
    (integer) 23
    127.0.0.1:6379> setnx mykey "redis"		#如果mykey不存在，创建mykey
    (integer) 1
    127.0.0.1:6379> keys *
    1) "mykey"
    2) "key3"
    3) "key2"
    4) "key1"
    127.0.0.1:6379> ttl key3
    (integer) -2
    127.0.0.1:6379> setnx mykey "MongoDB"	#如果mykey存在，创建失败
    (integer) 0
    127.0.0.1:6379> get mykey
    "redis"
    ##############################################################################################

##############################################################################################
    mset（原子性操作）
    mget
    ##############################################################################################
    127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3	#同时设置多个值
    OK
    127.0.0.1:6379> keys *
    1) "k3"
    2) "k2"
    3) "k1"
    127.0.0.1:6379> mget k1 k2 k3			#同时获取多个值
    1) "v1"
    2) "v2"
    3) "v3"
    127.0.0.1:6379> msetnx k4 v4			#msetnx 是一个原子性操作，要么一起成功，要么一起失败
    (integer) 1
    127.0.0.1:6379> keys *
    1) "k3"
    2) "k4"
    3) "k2"
    4) "k1"
    127.0.0.1:6379> msetnx k1 v1 k5 v5		#msetnx 是一个原子性操作，要么一起成功，要么一起失败
    (integer) 0
    127.0.0.1:6379> keys *
    1) "k3"
    2) "k4"
    3) "k2"
    4) "k1"
    127.0.0.1:6379> get key5
    (nil)
    ##############################################################################################

##############################################################################################
    set 对象名：对象序列：json字符        uesr：{
        id}：{
        field}，Redis这样可设置对象
    ##############################################################################################
    127.0.0.1:6379> mset user:1:name Jin user:1:age 20	#设置一个user：1 对象，值为json字符保存一个对象
    OK
    127.0.0.1:6379> keys *
    1) "k3"
    2) "k4"
    3) "user:1:age"
    4) "k2"
    5) "k1"
    6) "user:1:name"
    127.0.0.1:6379> mget user:1:name user:1:age
    1) "Jin"
    2) "20"
    ##############################################################################################

##############################################################################################
    #getset 先get然后set
    ##############################################################################################
    127.0.0.1:6379> getset db redis			#如果不存在值，则返回nil
    (nil)
    127.0.0.1:6379> get db
    "redis"
    127.0.0.1:6379> getset db mongodb		#如果存在值，则获取原来的值，并设置新的值
    "redis"
    127.0.0.1:6379> get db
    "mongodb"
    ##############################################################################################

String类似的使用场景：value除了是字符串还可以是数字，用途举例：

*  计数器
 *  统计多单位的数量：uid:123666：follow 0
 *  粉丝数
 *  对象存储缓存

#### 三、List(列表) ####

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
    
    一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

<table> 
 <thead> 
  <tr> 
   <th align="center"><strong>命令原型</strong></th> 
   <th align="center"><strong>时间复杂度</strong></th> 
   <th align="center"><strong>命令描述</strong></th> 
   <th align="center"><strong>返回值</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">LPUSH key value [value …]</td> 
   <td align="center">O(1)</td> 
   <td align="center">在指定Key所关联的List Value的头部插入参数中给出的所有Values。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，之后再将数据从链表的头部插入。如果该键的Value不是链表类型，该命令将返回相关的错误信息。</td> 
   <td align="center">插入后链表中元素的数量。</td> 
  </tr> 
  <tr> 
   <td align="center">LPUSHX key value</td> 
   <td align="center">O(1)</td> 
   <td align="center">仅有当参数中指定的Key存在时，该命令才会在其所关联的List Value的头部插入参数中给出的Value，否则将不会有任何操作发生。</td> 
   <td align="center">插入后链表中元素的数量。</td> 
  </tr> 
  <tr> 
   <td align="center">LRANGE key start stop</td> 
   <td align="center">O(S+N)</td> 
   <td align="center">时间复杂度中的S为start参数表示的偏移量，N表示元素的数量。该命令的参数start和end都是0-based。即0表示链表头部(leftmost)的第一个元素。其中start的值也可以为负值，-1将表示链表中的最后一个元素，即尾部元素，-2表示倒数第二个并以此类推。该命令在获取元素时，start和end位置上的元素也会被取出。如果start的值大于链表中元素的数量，空链表将会被返回。如果end的值大于元素的数量，该命令则获取从start(包括start)开始，链表中剩余的所有元素。</td> 
   <td align="center">返回指定范围内元素的列表。</td> 
  </tr> 
  <tr> 
   <td align="center">LPOP key</td> 
   <td align="center">O(1)</td> 
   <td align="center">返回并弹出指定Key关联的链表中的第一个元素，即头部元素，。如果该Key不存，返回nil。</td> 
   <td align="center">链表头部的元素。</td> 
  </tr> 
  <tr> 
   <td align="center">LLEN key</td> 
   <td align="center">O(1)</td> 
   <td align="center">返回指定Key关联的链表中元素的数量，如果该Key不存在，则返回0。如果与该Key关联的Value的类型不是链表，则返回相关的错误信息。</td> 
   <td align="center">链表中元素的数量。</td> 
  </tr> 
  <tr> 
   <td align="center">LREM key count value</td> 
   <td align="center">O(N)</td> 
   <td align="center">时间复杂度中N表示链表中元素的数量。在指定Key关联的链表中，删除前count个值等于value的元素。如果count大于0，从头向尾遍历并删除，如果count小于0，则从尾向头遍历并删除。如果count等于0，则删除链表中所有等于value的元素。如果指定的Key不存在，则直接返回0。</td> 
   <td align="center">返回被删除的元素数量。</td> 
  </tr> 
  <tr> 
   <td align="center">LSET key index value</td> 
   <td align="center">O(N)</td> 
   <td align="center">时间复杂度中N表示链表中元素的数量。但是设定头部或尾部的元素时，其时间复杂度为O(1)。设定链表中指定位置的值为新值，其中0表示第一个元素，即头部元素，-1表示尾部元素。如果索引值Index超出了链表中元素的数量范围，该命令将返回相关的错误信息。</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">LINDEX key index</td> 
   <td align="center">O(N)</td> 
   <td align="center">时间复杂度中N表示在找到该元素时需要遍历的元素数量。对于头部或尾部元素，其时间复杂度为O(1)。该命令将返回链表中指定位置(index)的元素，index是0-based，表示头部元素，如果index为-1，表示尾部元素。如果与该Key关联的不是链表，该命令将返回相关的错误信息。</td> 
   <td align="center">返回请求的元素，如果index超出范围，则返回nil。</td> 
  </tr> 
  <tr> 
   <td align="center">LTRIM key start stop</td> 
   <td align="center">O(N)</td> 
   <td align="center">N表示被删除的元素数量。该命令将仅保留指定范围内的元素，从而保证链接中的元素数量相对恒定。start和stop参数都是0-based，0表示头部元素。和其他命令一样，start和stop也可以为负值，-1表示尾部元素。如果start大于链表的尾部，或start大于stop，该命令不错报错，而是返回一个空的链表，与此同时该Key也将被删除。如果stop大于元素的数量，则保留从start开始剩余的所有元素。</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">LINSERT key BEFORE|AFTER pivot value</td> 
   <td align="center">O(N)</td> 
   <td align="center">时间复杂度中N表示在找到该元素pivot之前需要遍历的元素数量。这样意味着如果pivot位于链表的头部或尾部时，该命令的时间复杂度为O(1)。该命令的功能是在pivot元素的前面或后面插入参数中的元素value。如果Key不存在，该命令将不执行任何操作。如果与Key关联的Value类型不是链表，相关的错误信息将被返回。</td> 
   <td align="center">成功插入后链表中元素的数量，如果没有找到pivot，返回-1，如果key不存在，返回0。</td> 
  </tr> 
  <tr> 
   <td align="center">RPUSH key value [value …]</td> 
   <td align="center">O(1)</td> 
   <td align="center">在指定Key所关联的List Value的尾部插入参数中给出的所有Values。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，之后再将数据从链表的尾部插入。如果该键的Value不是链表类型，该命令将返回相关的错误信息。</td> 
   <td align="center">插入后链表中元素的数量</td> 
  </tr> 
  <tr> 
   <td align="center">RPUSHX key value</td> 
   <td align="center">O(1)</td> 
   <td align="center">仅有当参数中指定的Key存在时，该命令才会在其所关联的List Value的尾部插入参数中给出的Value，否则将不会有任何操作发生。</td> 
   <td align="center">插入后链表中元素的数量。</td> 
  </tr> 
  <tr> 
   <td align="center">RPOP key</td> 
   <td align="center">O(1)</td> 
   <td align="center">返回并弹出指定Key关联的链表中的最后一个元素，即尾部元素，。如果该Key不存，返回nil。</td> 
   <td align="center">链表尾部的元素。</td> 
  </tr> 
  <tr> 
   <td align="center">RPOPLPUSH source destination</td> 
   <td align="center">O(1)</td> 
   <td align="center">原子性的从与source键关联的链表尾部弹出一个元素，同时再将弹出的元素插入到与destination键关联的链表的头部。如果source键不存在，该命令将返回nil，同时不再做任何其它的操作了。如果source和destination是同一个键，则相当于原子性的将其关联链表中的尾部元素移到该链表的头部。</td> 
   <td align="center">返回弹出和插入的元素。</td> 
  </tr> 
 </tbody> 
</table>

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lwNtQ3jo-1679539496793)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1640743735256.png)\]

lpush key value
    rpush key value
    lrange key start stop
    ##############################################################################################
    127.0.0.1:6379> lpush list one		#将一个或多个值，插入到列表头部（左）
    (integer) 1
    127.0.0.1:6379> lpush list two
    (integer) 2
    127.0.0.1:6379> lpush list three
    (integer) 3
    127.0.0.1:6379> lrange list 0 -1	#获取list中所有的值
    1) "three"
    2) "two"
    3) "one"
    127.0.0.1:6379> lrange list 0 1		#获取区间中的值
    1) "three"
    2) "two"
    127.0.0.1:6379> keys *				#查看这个list
    1) "list"
    127.0.0.1:6379> rpush list 0 1		#将一个或多个值，插入到列表尾部（右）
    (integer) 5
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "two"
    3) "one"
    4) "0"
    5) "1"
    127.0.0.1:6379> keys *
    1) "list"
    ##############################################################################################

lpop key
    rpop key
    ##############################################################################################
    127.0.0.1:6379> keys *
    1) "list"
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "two"
    3) "one"
    4) "0"
    5) "1"
    127.0.0.1:6379> lpop list		#移除list列表的第一个元素（左）
    "three"
    127.0.0.1:6379> rpop list		#移除list列表的第一个元素（右）
    "1"
    127.0.0.1:6379> lrange list 0 -1
    1) "two"
    2) "one"
    3) "0"
    ##############################################################################################

lindex key index
    ##############################################################################################
    127.0.0.1:6379> lrange list 0 -1
    1) "two"
    2) "one"
    3) "0"
    127.0.0.1:6379> lindex list 1		#通过下标获得list中的某个值
    "one"
    127.0.0.1:6379> lindex list 0
    "two"
    ##############################################################################################

llen key
    ##############################################################################################
    127.0.0.1:6379> keys *
    (empty array)
    127.0.0.1:6379> lpush list one
    (integer) 1
    127.0.0.1:6379> lpush list two
    (integer) 2
    127.0.0.1:6379> lpush list three
    (integer) 3
    127.0.0.1:6379> llen list		#返回列表长度
    (integer) 3
    ##############################################################################################

lrem key count element
    ##############################################################################################
    127.0.0.1:6379> lpush list one
    (integer) 1
    127.0.0.1:6379> lpush list two
    (integer) 2
    127.0.0.1:6379> lpush list three
    (integer) 3
    127.0.0.1:6379> lpush list three
    (integer) 4
    127.0.0.1:6379> lpush list three
    (integer) 5
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "three"
    3) "three"
    4) "two"
    5) "one"
    127.0.0.1:6379> lrem list 1 one		#移除list集合中指定个数的value，精确匹配
    (integer) 1
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "three"
    3) "three"
    4) "two"
    127.0.0.1:6379> lrem list 2 three
    (integer) 2
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "two"
    ##############################################################################################

ltrim key start stop
    ##############################################################################################
    127.0.0.1:6379> lpush list "hello1"
    (integer) 1
    127.0.0.1:6379> lpush list "hello2"
    (integer) 2
    127.0.0.1:6379> lpush list "hello3"
    (integer) 3
    127.0.0.1:6379> lpush list "hello4"
    (integer) 4
    127.0.0.1:6379> lpush list "hello5"
    (integer) 5
    127.0.0.1:6379> lrange list 0 -1
    1) "hello5"
    2) "hello4"
    3) "hello3"
    4) "hello2"
    5) "hello1"
    127.0.0.1:6379> ltrim list 1 2		#通过下表截取指定的长度，这个list已经被改变了，截断了只剩下的元素！
    OK
    127.0.0.1:6379> lrange list 0 -1
    1) "hello4"
    2) "hello3"
    ##############################################################################################

rpoplpush source destinaion
    ##############################################################################################
    127.0.0.1:6379> lpush list "hello1"
    (integer) 1
    127.0.0.1:6379> lpush list "hello2"
    (integer) 2
    127.0.0.1:6379> lpush list "hello3"
    (integer) 3
    127.0.0.1:6379> rpoplpush list otherlist	#移除列表的最后一个元素，将它移动到新的列表当中
    "hello1"
    127.0.0.1:6379> lrange list 0 -1			#查看原来的列表
    1) "hello3"
    2) "hello2"
    127.0.0.1:6379> lrange otherlist 0 -1		#查看目标列表，确实存在此值
    1) "hello1"
    ##############################################################################################

exists key
    lset key index element
    ##############################################################################################
    127.0.0.1:6379> exists list			#判断这个列表是否存在
    (integer) 0
    127.0.0.1:6379> keys *
    (empty array)
    127.0.0.1:6379> lset list 0 item	#如果不存在此列表，进行更新就会报错
    (error) ERR no such key
    127.0.0.1:6379> lpush list "value"
    (integer) 1
    127.0.0.1:6379> lrange list 0 -1
    1) "value"
    127.0.0.1:6379> lset list 0 item	#将列表中指定下标的值替换为另外一个值，更新操作
    OK
    127.0.0.1:6379> lrange list 0 -1
    1) "item"
    127.0.0.1:6379> lset list 1 intem	#将列表中不存在此元素，也会报错
    (error) ERR index out of range
    ##############################################################################################

linsert key before|after pivot element
    ##############################################################################################
    127.0.0.1:6379> lpush list "hello"
    (integer) 1
    127.0.0.1:6379> lpush list "world"
    (integer) 2
    127.0.0.1:6379> lrange list 0 -1
    1) "world"
    2) "hello"
    127.0.0.1:6379> linsert list before "world" my	#将某一个具体的value插入到list列表中某个元素的前面或者后面
    (integer) 3
    127.0.0.1:6379> lrange list 0 -1
    1) "my"
    2) "world"
    3) "hello"
    127.0.0.1:6379> linsert list after "world" new
    (integer) 4
    127.0.0.1:6379> lrange list 0 -1
    1) "my"
    2) "world"
    3) "new"
    4) "hello"
    ##############################################################################################

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HnTJJwlQ-1679539496793)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1640761223241.png)\]

---------------------------LPUSH---RPUSH---LRANGE--------------------------------
    
    127.0.0.1:6379> LPUSH mylist k1 # LPUSH mylist=>{1}
    (integer) 1
    127.0.0.1:6379> LPUSH mylist k2 # LPUSH mylist=>{2,1}
    (integer) 2
    127.0.0.1:6379> RPUSH mylist k3 # RPUSH mylist=>{2,1,3}
    (integer) 3
    127.0.0.1:6379> get mylist # 普通的get是无法获取list值的
    (error) WRONGTYPE Operation against a key holding the wrong kind of value
    127.0.0.1:6379> LRANGE mylist 0 4 # LRANGE 获取起止位置范围内的元素
    1) "k2"
    2) "k1"
    3) "k3"
    127.0.0.1:6379> LRANGE mylist 0 2
    1) "k2"
    2) "k1"
    3) "k3"
    127.0.0.1:6379> LRANGE mylist 0 1
    1) "k2"
    2) "k1"
    127.0.0.1:6379> LRANGE mylist 0 -1 # 获取全部元素
    1) "k2"
    2) "k1"
    3) "k3"
    
    ---------------------------LPUSHX---RPUSHX-----------------------------------
    
    127.0.0.1:6379> LPUSHX list v1 # list不存在 LPUSHX失败
    (integer) 0
    127.0.0.1:6379> LPUSHX list v1 v2  
    (integer) 0
    127.0.0.1:6379> LPUSHX mylist k4 k5 # 向mylist中 左边 PUSH k4 k5
    (integer) 5
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k5"
    2) "k4"
    3) "k2"
    4) "k1"
    5) "k3"
    
    ---------------------------LINSERT--LLEN--LINDEX--LSET----------------------------
    
    127.0.0.1:6379> LINSERT mylist after k2 ins_key1 # 在k2元素后 插入ins_key1
    (integer) 6
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k5"
    2) "k4"
    3) "k2"
    4) "ins_key1"
    5) "k1"
    6) "k3"
    127.0.0.1:6379> LLEN mylist # 查看mylist的长度
    (integer) 6
    127.0.0.1:6379> LINDEX mylist 3 # 获取下标为3的元素
    "ins_key1"
    127.0.0.1:6379> LINDEX mylist 0
    "k5"
    127.0.0.1:6379> LSET mylist 3 k6 # 将下标3的元素 set值为k6
    OK
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k5"
    2) "k4"
    3) "k2"
    4) "k6"
    5) "k1"
    6) "k3"
    
    ---------------------------LPOP--RPOP--------------------------
    
    127.0.0.1:6379> LPOP mylist # 左侧(头部)弹出
    "k5"
    127.0.0.1:6379> RPOP mylist # 右侧(尾部)弹出
    "k3"
    
    ---------------------------RPOPLPUSH--------------------------
    
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k4"
    2) "k2"
    3) "k6"
    4) "k1"
    127.0.0.1:6379> RPOPLPUSH mylist newlist # 将mylist的最后一个值(k1)弹出，加入到newlist的头部
    "k1"
    127.0.0.1:6379> LRANGE newlist 0 -1
    1) "k1"
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k4"
    2) "k2"
    3) "k6"
    
    ---------------------------LTRIM--------------------------
    
    127.0.0.1:6379> LTRIM mylist 0 1 # 截取mylist中的 0~1部分
    OK
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "k4"
    2) "k2"
    
    # 初始 mylist: k2,k2,k2,k2,k2,k2,k4,k2,k2,k2,k2
    ---------------------------LREM--------------------------
    
    127.0.0.1:6379> LREM mylist 3 k2 # 从头部开始搜索 至多删除3个 k2
    (integer) 3
    # 删除后：mylist: k2,k2,k2,k4,k2,k2,k2,k2
    
    127.0.0.1:6379> LREM mylist -2 k2 #从尾部开始搜索 至多删除2个 k2
    (integer) 2
    # 删除后：mylist: k2,k2,k2,k4,k2,k2
    
    
    ---------------------------BLPOP--BRPOP--------------------------
    
    mylist: k2,k2,k2,k4,k2,k2
    newlist: k1
    
    127.0.0.1:6379> BLPOP newlist mylist 30 # 从newlist中弹出第一个值，mylist作为候选
    1) "newlist" # 弹出
    2) "k1"
    127.0.0.1:6379> BLPOP newlist mylist 30
    1) "mylist" # 由于newlist空了 从mylist中弹出
    2) "k2"
    127.0.0.1:6379> BLPOP newlist 30
    (30.10s) # 超时了
    
    127.0.0.1:6379> BLPOP newlist 30 # 我们连接另一个客户端向newlist中push了test, 阻塞被解决。
    1) "newlist"
    2) "test"
    (12.54s)

小结：

*  list实际上是一个链表，before Node after , left, right 都可以插入值
 *  **如果key不存在，则创建新的链表**
 *  如果key存在，新增内容
 *  如果移除了所有值，空链表，也代表不存在
 *  在两边插入或者改动值，效率最高！修改中间元素，效率相对较低

**应用：**

**消息排队！消息队列（Lpush Rpop）,栈（Lpush Lpop）**

#### 四、Set（集合） ####

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
    
    Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
    
    集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

![1640756580614][]

![1640756308838][]

---------------SADD--SCARD--SMEMBERS--SISMEMBER--------------------
    
    127.0.0.1:6379> SADD myset m1 m2 m3 m4 # 向myset中增加成员 m1~m4
    (integer) 4
    127.0.0.1:6379> SCARD myset # 获取集合的成员数目
    (integer) 4
    127.0.0.1:6379> smembers myset # 获取集合中所有成员
    1) "m4"
    2) "m3"
    3) "m2"
    4) "m1"
    127.0.0.1:6379> SISMEMBER myset m5 # 查询m5是否是myset的成员
    (integer) 0 # 不是，返回0
    127.0.0.1:6379> SISMEMBER myset m2
    (integer) 1 # 是，返回1
    127.0.0.1:6379> SISMEMBER myset m3
    (integer) 1
    
    ---------------------SRANDMEMBER--SPOP----------------------------------
    
    127.0.0.1:6379> SRANDMEMBER myset 3 # 随机返回3个成员
    1) "m2"
    2) "m3"
    3) "m4"
    127.0.0.1:6379> SRANDMEMBER myset # 随机返回1个成员
    "m3"
    127.0.0.1:6379> SPOP myset 2 # 随机移除并返回2个成员
    1) "m1"
    2) "m4"
    # 将set还原到{m1,m2,m3,m4}
    
    ---------------------SMOVE--SREM----------------------------------------
    
    127.0.0.1:6379> SMOVE myset newset m3 # 将myset中m3成员移动到newset集合
    (integer) 1
    127.0.0.1:6379> SMEMBERS myset
    1) "m4"
    2) "m2"
    3) "m1"
    127.0.0.1:6379> SMEMBERS newset
    1) "m3"
    127.0.0.1:6379> SREM newset m3 # 从newset中移除m3元素
    (integer) 1
    127.0.0.1:6379> SMEMBERS newset
    (empty list or set)
    
    # 下面开始是多集合操作,多集合操作中若只有一个参数默认和自身进行运算
    # setx=>{m1,m2,m4,m6}, sety=>{m2,m5,m6}, setz=>{m1,m3,m6}
    
    -----------------------------SDIFF------------------------------------
    
    127.0.0.1:6379> SDIFF setx sety setz # 等价于setx-sety-setz
    1) "m4"
    127.0.0.1:6379> SDIFF setx sety # setx - sety
    1) "m4"
    2) "m1"
    127.0.0.1:6379> SDIFF sety setx # sety - setx
    1) "m5"
    
    
    -------------------------SINTER---------------------------------------
    # 共同关注（交集）
    
    127.0.0.1:6379> SINTER setx sety setz # 求 setx、sety、setx的交集
    1) "m6"
    127.0.0.1:6379> SINTER setx sety # 求setx sety的交集
    1) "m2"
    2) "m6"
    
    -------------------------SUNION---------------------------------------
    
    127.0.0.1:6379> SUNION setx sety setz 	# setx sety setz的并集
    1) "m4"
    2) "m6"
    3) "m3"
    4) "m2"
    5) "m1"
    6) "m5"
    127.0.0.1:6379> SUNION setx sety 		# setx sety 并集
    1) "m4"
    2) "m6"
    3) "m2"
    4) "m1"
    5) "m5"

##############################################################################################
    127.0.0.1:6379> sadd set "hello"	#set集合中添加元素
    (integer) 1
    127.0.0.1:6379> sadd set "Jin"
    (integer) 1
    127.0.0.1:6379> sadd set "love "
    (integer) 1
    127.0.0.1:6379> smembers set		#查看指定set的所有值
    1) "Jin"
    2) "love "
    3) "hello"
    127.0.0.1:6379> sismember set "hello"	#判断某一个值是不是在set集合中
    (integer) 1
    127.0.0.1:6379> sismember set "world"
    (integer) 0
    127.0.0.1:6379> smembers set
    1) "Jin"
    2) "love "
    3) "hello"
    127.0.0.1:6379> scard set			#获取set集合中的内容元素个数
    (integer) 3
    127.0.0.1:6379> srem set "hello"	#移除set集合中的指定元素
    (integer) 1
    127.0.0.1:6379> smembers set
    1) "Jin"
    2) "love "
    ##############################################################################################

##############################################################################################
    127.0.0.1:6379> srandmember set		#随机获取set集合中的元素
    "Jin"
    127.0.0.1:6379> srandmember set
    "Jin"
    127.0.0.1:6379> srandmember set
    "love "
    127.0.0.1:6379> srandmember set
    "Jin"
    127.0.0.1:6379> srandmember set 2	#随机获取set集合中指定个数的的元素
    1) "Ji"
    2) "Yang"
    127.0.0.1:6379> srandmember set 2
    1) "Jin"
    2) "love "
    127.0.0.1:6379> srandmember set 2
    1) "Jin"
    2) "Ji"
    ##############################################################################################

##############################################################################################
    127.0.0.1:6379> smembers set
    1) "Jin"
    2) "Ji"
    3) "love "
    4) "Yang"
    127.0.0.1:6379> spop set	#随机删除一些set集合中的元素
    "Ji"
    127.0.0.1:6379> spop set
    "Yang"
    127.0.0.1:6379> smembers set
    1) "Jin"
    2) "love " ##############################################################################################

##############################################################################################
    127.0.0.1:6379> sadd set "hello"
    (integer) 1
    127.0.0.1:6379> sadd set "world"
    (integer) 1
    127.0.0.1:6379> sadd set "Jin"
    (integer) 1
    127.0.0.1:6379> sadd otherset "otherset of set"
    (integer) 1
    127.0.0.1:6379> smembers set
    1) "Jin"
    2) "world"
    3) "hello"
    127.0.0.1:6379> smembers otherset
    1) "otherset of set"
    127.0.0.1:6379> smove set otherset "Jin" 	#将一个指定的值，移动到另外一个集合中
    (integer) 1
    127.0.0.1:6379> smembers set
    1) "world"
    2) "hello"
    127.0.0.1:6379> smembers otherset
    1) "Jin"
    2) "otherset of set"
    ##############################################################################################

##############################################################################################
    127.0.0.1:6379> sadd set1 a
    (integer) 1
    127.0.0.1:6379> sadd set1 b
    (integer) 1
    127.0.0.1:6379> sadd set1 c
    (integer) 1
    127.0.0.1:6379> sadd set2 b
    (integer) 1
    127.0.0.1:6379> sadd set2 c
    (integer) 1
    127.0.0.1:6379> sadd set2 d
    (integer) 1
    127.0.0.1:6379> sdiff set1 set2		#差集：以set1为参照，找出set2中与其不同的元素
    1) "a"
    127.0.0.1:6379> sinter set1 set2	#交集：共同好友可以这样实现
    1) "c"
    2) "b"
    127.0.0.1:6379> sunion set1 set2	#并集：
    1) "b"
    2) "c"
    3) "d"
    4) "a"
    ##############################################################################################

#### 五、Hash（哈希） ####

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
    
    Set就是一种简化的Hash,只变动key,而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息。
    Hash更适合于对象的存储，Sring更加适合字符串存储！

![1640756679859][]

![1640756845540][]

------------------------HSET--HMSET--HSETNX----------------
    127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象，设置name为sakura
    (integer) 1
    127.0.0.1:6379> HSET studentx name gyc # 重复设置field进行覆盖，并返回0
    (integer) 0
    127.0.0.1:6379> HSET studentx age 20 # 设置studentx的age为20
    (integer) 1
    127.0.0.1:6379> HMSET studentx sex 1 tel 15623667886 # 设置sex为1，tel为15623667886
    OK
    127.0.0.1:6379> HSETNX studentx name gyc # HSETNX 设置已存在的field
    (integer) 0 # 失败
    127.0.0.1:6379> HSETNX studentx email 12345@qq.com
    (integer) 1 # 成功
    
    ----------------------HEXISTS--------------------------------
    127.0.0.1:6379> HEXISTS studentx name # name字段在studentx中是否存在
    (integer) 1 # 存在
    127.0.0.1:6379> HEXISTS studentx addr
    (integer) 0 # 不存在
    
    -------------------HGET--HMGET--HGETALL-----------
    127.0.0.1:6379> HGET studentx name # 获取studentx中name字段的value
    "gyc"
    127.0.0.1:6379> HMGET studentx name age tel # 获取studentx中name、age、tel字段的value
    1) "gyc"
    2) "20"
    3) "15623667886"
    127.0.0.1:6379> HGETALL studentx # 获取studentx中所有的field及其value
     1) "name"
     2) "gyc"
     3) "age"
     4) "20"
     5) "sex"
     6) "1"
     7) "tel"
     8) "15623667886"
     9) "email"
    10) "12345@qq.com"
    
    
    --------------------HKEYS--HLEN--HVALS--------------
    127.0.0.1:6379> HKEYS studentx # 查看studentx中所有的field
    1) "name"
    2) "age"
    3) "sex"
    4) "tel"
    5) "email"
    127.0.0.1:6379> HLEN studentx # 查看studentx中的字段数量
    (integer) 5
    127.0.0.1:6379> HVALS studentx # 查看studentx中所有的value
    1) "gyc"
    2) "20"
    3) "1"
    4) "15623667886"
    5) "12345@qq.com"
    
    -------------------------HDEL--------------------------
    127.0.0.1:6379> HDEL studentx sex tel # 删除studentx 中的sex、tel字段
    (integer) 2
    127.0.0.1:6379> HKEYS studentx
    1) "name"
    2) "age"
    3) "email"
    
    -------------HINCRBY--HINCRBYFLOAT------------------------
    127.0.0.1:6379> HINCRBY studentx age 1 # studentx的age字段数值+1
    (integer) 21
    127.0.0.1:6379> HINCRBY studentx name 1 # 非整数字型字段不可用
    (error) ERR hash value is not an integer
    127.0.0.1:6379> HINCRBYFLOAT studentx weight 0.6 # weight字段增加0.6
    "90.8"

##############################################################################################
    127.0.0.1:6379> hset hash field1 Jin				#hset一个key-value
    (integer) 1
    127.0.0.1:6379> hget hash field1					#hget一个key-value
    "Jin"
    127.0.0.1:6379> hmset hash field1 hello field2 world  #hmset多个key-value
    OK
    127.0.0.1:6379> hmget hash field1 field2			 #hmget多个key-value
    1) "hello"
    2) "world"
    127.0.0.1:6379> hgetall hash				#hgetall获取全部key-value
    1) "field1"
    2) "hello"
    3) "field2"
    4) "world"
    127.0.0.1:6379> hdel hash field1			#删除hash指定的key字段，对应的value值也删除了
    (integer) 1
    127.0.0.1:6379> hgetall hash
    1) "field2"
    2) "world"
    127.0.0.1:6379> hmset hash field1 hello field2 world field3 Jin
    OK
    127.0.0.1:6379> hgetall hash
    1) "field2"
    2) "world"
    3) "field1"
    4) "hello"
    5) "field3"
    6) "Jin"
    127.0.0.1:6379> hlen hash			#获得hash表的字段数量
    (integer) 3
    127.0.0.1:6379> hexists hash field1	 #判断hash表中指定字段是否存在，存在为1，不存在为0
    (integer) 1
    127.0.0.1:6379> hexists hash field4
    (integer) 0
    127.0.0.1:6379> hkeys hash			#获得所有的field
    1) "field2"
    2) "field1"
    3) "field3"
    127.0.0.1:6379> hvals hash			#获得所有的值
    1) "world"
    2) "hello"
    3) "Jin"
    ##############################################################################################

#### 六、Zset（有序集合） ####

不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序。
    
    score相同：按字典顺序排序
    
    有序集合的成员是唯一的,但分数(score)却可以重复。

![1640759748303][]

![1640759763770][]

##############################################################################################
    -------------------ZADD--ZCARD--ZCOUNT--------------
    127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 	 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2
    (integer) 2
    127.0.0.1:6379> ZCARD myzset 				# 获取有序集合的成员数
    (integer) 2
    127.0.0.1:6379> ZCOUNT myzset 0 1 			# 获取score在 [0,1]区间的成员数量
    (integer) 1
    127.0.0.1:6379> ZCOUNT myzset 0 2
    (integer) 2
    
    ----------------ZINCRBY--ZSCORE--------------------------
    127.0.0.1:6379> ZINCRBY myzset 5 m2 		# 将成员m2的score +5
    "7"
    127.0.0.1:6379> ZSCORE myzset m1			 # 获取成员m1的score
    "1"
    127.0.0.1:6379> ZSCORE myzset m2
    "7"
    
    --------------ZRANK--ZRANGE-----------------------------------
    127.0.0.1:6379> ZRANK myzset m1	    # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
    (integer) 0
    127.0.0.1:6379> ZRANK myzset m2
    (integer) 2
    127.0.0.1:6379> ZRANGE myzset 0 1 	# 获取索引在 0~1的成员
    1) "m1"
    2) "m3"
    127.0.0.1:6379> ZRANGE myzset 0 -1 	# 获取全部成员
    1) "m1"
    2) "m3"
    3) "m2"
    
    #testset=>{abc,add,amaze,apple,back,java,redis} score均为0
    ------------------ZRANGEBYLEX---------------------------------
    127.0.0.1:6379> ZRANGEBYLEX testset - + 			# 返回所有成员
    1) "abc"
    2) "add"
    3) "amaze"
    4) "apple"
    5) "back"
    6) "java"
    7) "redis"
    127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 		# 分页 按索引显示查询结果的 0,1,2条记录
    1) "abc"
    2) "add"
    3) "amaze"
    127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 		# 显示 3,4,5条记录
    1) "apple"
    2) "back"
    3) "java"
    127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
    1) "abc"
    2) "add"
    3) "amaze"
    4) "apple"
    127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
    1) "apple"
    2) "back"
    3) "java"
    
    -----------------------ZRANGEBYSCORE---------------------
    127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 			# 返回score在 [1,10]之间的的成员
    1) "m1"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
    1) "m1"
    2) "m3"
    
    --------------------ZLEXCOUNT-----------------------------
    127.0.0.1:6379> ZLEXCOUNT testset - +
    (integer) 7
    127.0.0.1:6379> ZLEXCOUNT testset [apple [java
    (integer) 3
    
    ------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
    127.0.0.1:6379> ZREM testset abc 							# 移除成员abc
    (integer) 1
    127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java 		  # 移除字典区间[apple,java]中的所有成员
    (integer) 3
    127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1					 # 移除排名0~1的所有成员
    (integer) 2
    127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 				 # 移除score在 [0,3]的成员
    (integer) 2
    
    
    # testset=> {abc,add,apple,amaze,back,java,redis} score均为0
    # myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
    ----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
    127.0.0.1:6379> ZREVRANGE myzset 0 3 			# 按score递减排序，然后按索引，返回结果的 0~3
    1) "m9"
    2) "m7"
    3) "m4"
    4) "m3"
    127.0.0.1:6379> ZREVRANGE myzset 2 4 			# 返回排序结果的 索引的2~4
    1) "m4"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 	 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
    1) "m4"
    2) "m3"
    3) "m2"
    127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add 		# 按字典倒序 返回集合中(add,java]字典区间的成员
    1) "java"
    2) "back"
    3) "apple"
    4) "amaze"
    
    -------------------------ZREVRANK------------------------------
    127.0.0.1:6379> ZREVRANK myzset m7 			# 按score递减顺序，返回成员m7索引
    (integer) 1
    127.0.0.1:6379> ZREVRANK myzset m2
    (integer) 4
    
    
    # mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
    # enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
    -------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
    127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore 	# 将mathscore enscore进行合并 结果存放到sumscore
    (integer) 3
    127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores 			# 合并后的score是之前集合中所有score的和
    1) "xm"
    2) "160"
    3) "xg"
    4) "177"
    5) "xh"
    6) "188"
    
    127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
    (integer) 3
    127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
    1) "xm"
    2) "70"
    3) "xg"
    4) "87"
    5) "xh"
    6) "93"                                    ##############################################################################################

### 四、三种特殊数据类型 ###

#### 一、Geospatial(地理位置) ####

使用经纬度定位地理坐标并用一个有序集合zset保存，所以zset命令也可以使用

![1640761559299][]

**有效经纬度**

有效的经度从-180度到180度。
    有效的纬度从-85.05112878度到85.05112878度。

指定单位的参数 **unit** 必须是以下单位的其中一个：

*  **m** 表示单位为米。
 *  **km** 表示单位为千米。
 *  **mi** 表示单位为英里。
 *  **ft** 表示单位为英尺。

**关于GEORADIUS的参数**

通过georadius就可以完成 附近的人功能
    
    withcoord:带上坐标
    
    withdist:带上距离，单位与半径单位相同
    
    COUNT n : 只显示前n个(按距离递增排序)

##############################################################################################
    127.0.0.1:6379> geoadd China:city 116.40 39.90 beijing
    (integer) 1
    127.0.0.1:6379> geoadd China:city 121.47 31.23  shanghai
    (integer) 1
    127.0.0.1:6379> geoadd China:city 106.50 29.53 chongqing 114.05 22.52 shenzhen
    (integer) 2
    127.0.0.1:6379> geoadd China:city 120.16 30.24 hangzhou 108.96 34.26 xian
    (integer) 2
    127.0.0.1:6379> geopos China:city beijing			
    1) 1) "116.39999896287918091"
       2) "39.90000009167092543"
    127.0.0.1:6379> geopos China:city beijing chongqing	
    1) 1) "116.39999896287918091"
       2) "39.90000009167092543"
    2) 1) "106.49999767541885376"
       2) "29.52999957900659211"
    127.0.0.1:6379> geodist China:city beijing shanghai km		#查看上海到北京的直线距离
    "1067.3788"
    127.0.0.1:6379> geodist China:city beijing chongqing km	 	#查看重庆到北京的直线距离
    "1464.0708"
    127.0.0.1:6379> georadius China:city 110 30 1000 km 	#以100，30这个经纬度为中心，寻找方圆1000km的城市
    1) "chongqing"
    2) "xian"
    3) "shenzhen"
    4) "hangzhou"
    127.0.0.1:6379> georadius China:city 110 30 500 km
    1) "chongqing"
    2) "xian"
    127.0.0.1:6379> georadius China:city 110 30 500 km withdist		#显示到中心距离的位置
    1) 1) "chongqing"
       2) "341.9374"
    2) 1) "xian"
       2) "483.8340"
    127.0.0.1:6379> georadius China:city 110 30 500 km withcoord	#显示到他人的定位信息
    1) 1) "chongqing"
       2) 1) "106.49999767541885376"
          2) "29.52999957900659211"
    2) 1) "xian"
       2) 1) "108.96000176668167114"
          2) "34.25999964418929977"
    127.0.0.1:6379> georadius China:city 110 30 500 km withdist withcoord count 1	#筛选出指定的结果
    1) 1) "chongqing"
       2) "341.9374"
       3) 1) "106.49999767541885376"
          2) "29.52999957900659211"
    127.0.0.1:6379> georadius China:city 110 30 500 km withdist withcoord count 2
    1) 1) "chongqing"
       2) "341.9374"
       3) 1) "106.49999767541885376"
          2) "29.52999957900659211"
    2) 1) "xian"
       2) "483.8340"
       3) 1) "108.96000176668167114"
          2) "34.25999964418929977"
    127.0.0.1:6379> georadiusbymember China:city beijing 1000 km		#找出位于指定元素周围到的其他元素
    1) "beijing"
    2) "xian"
    127.0.0.1:6379> georadiusbymember China:city shanghai 400 km
    1) "hangzhou"
    2) "shanghai"
    127.0.0.1:6379> geohash China:city beijing chongqin				#将二维的经纬度转换为一维的字符串，
    1) "wx4fbxxfke0"											  如果两个字符串越接近则距离就越近
    2) "wm5xzrybty0"
    127.0.0.1:6379> zrange China:city 0 -1				#查看地图中的全部元素
    1) "chongqing"
    2) "xian"
    3) "shenzhen"
    4) "hangzhou"
    5) "shanghai"
    6) "beijing"
    127.0.0.1:6379> zrem China:city beijing				#移除地图中的指定元素
    (integer) 1
    127.0.0.1:6379> zrange China:city 0 -1
    1) "chongqing"
    2) "xian"
    3) "shenzhen"
    4) "hangzhou"
    5) "shanghai" ##############################################################################################

#### 二、Hyperloglog(基数统计) ####

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GD1rQuY6-1679539496796)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1640762670052.png)\]

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。
    
    花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。
    
    因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。
    
    其底层使用string数据类型
    
    基数是数据集中不重复的元素的个数。

**应用场景：**

网页的访问量（UV）：一个用户多次访问，也只能算作一个人。

传统实现，存储用户的id,然后每次进行比较。当用户变多之后这种方式及其浪费空间，而我们的目的只是计数，Hyperloglog就能帮助我们利用最小的空间完成。

如果允许容错，那么一定可以使用Hyperloglog !

如果不允许容错，就使用set或者自己的数据类型即可 ！

##############################################################################################
    127.0.0.1:6379> pfadd key1 a b c d e f g h i j		#创建第一组元素
    (integer) 1
    127.0.0.1:6379> pfcount key1					   #统计第一组元素数量
    (integer) 10
    127.0.0.1:6379> pfadd key2 i j a d e w q p n m
    (integer) 1
    127.0.0.1:6379> pfcount key2
    (integer) 10
    127.0.0.1:6379> pfmerge key3 key1 key2				#并集：合并两组元素的数据
    OK
    127.0.0.1:6379> pfcount key3					   #查看并集的数量
    (integer) 15
    ##############################################################################################

#### 三、BitMaps(位图) ####

使用位存储，信息状态只有 0 和 1
    
    Bitmap是一串连续的2进制数字（0或1），每一位所在的位置为偏移(offset)，在bitmap上可执行AND,OR,XOR,NOT以及其它位操作。

**应用场景**

签到统计、状态统计

![1640762764253][]

bitmaps的底层

这样设置以后你能get到的值是：\\xA2\\x80，所以bitmaps是一串从左到右的二进制串\`

##############################################################################################
    127.0.0.1:6379> setbit sign 0 1
    (integer) 0
    127.0.0.1:6379> setbit sign 1 0
    (integer) 0
    127.0.0.1:6379> setbit sign 2 0
    (integer) 0
    127.0.0.1:6379> setbit sign 3 1
    (integer) 0
    127.0.0.1:6379> setbit sign 4 1
    (integer) 0
    127.0.0.1:6379> setbit sign 5 0
    (integer) 0
    127.0.0.1:6379> setbit sign 6 0
    (integer) 0
    127.0.0.1:6379> getbit sign 3
    (integer) 1
    127.0.0.1:6379> getbit sign 6
    (integer) 0
    127.0.0.1:6379> bitcount sign 		#统计这周的打卡记录
    (integer) 3
    ##############################################################################################

### 五、事务 ###

**Redis的单条命令是保证原子性的，但是redis事务不能保证原子性**

Redis事务的本质是一组命令的集合，一次执行多个指令，事务中所有命令都被序列化，其他客户端提交的命令请求不会插入到事务执行命令序列中
    
    一次性
    顺序性
    排他性
    
    单条命令是原子性执行的，但事务不保证原子性，且没有回滚，事务中任意命令执行失败，其余命令仍会被执行.
    1、Redis事务没有隔离级别的概念
    2、Redis单条命令是保证原子性的，但是事务不保证原子性！

开启事务（multi）  
命令入队（。。。）  
执行事务（exec）  
取消事务（discard）  
监视、加锁（watch）  
取消监视、解锁（unwatch）

#### 一、Redis事务 ####

##############################################################################################
     exec 正常执行事务
    ##############################################################################################
    127.0.0.1:6379> multi				#开启事务
    OK
    127.0.0.1:6379(TX)> set k1 v1		#命令入队
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> get k2
    QUEUED
    127.0.0.1:6379(TX)> set k3 v3
    QUEUED
    127.0.0.1:6379(TX)> exec			#执行事务
    1) OK
    2) OK
    3) "v2"
    4) OK
    ##############################################################################################

##############################################################################################
     discard 取消事务
    ##############################################################################################
    127.0.0.1:6379> multi			#开启事务
    OK
    127.0.0.1:6379(TX)> set k1 v1
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> set k4 v4
    QUEUED
    127.0.0.1:6379(TX)> discard		#取消事务
    OK
    127.0.0.1:6379> get k4			#事务中的命令都不会被执行
    (nil)
    ##############################################################################################

#### 二、事务错误 ####

代码语法错误（编译时异常）,事务中的所有的命令都不执行

##############################################################################################
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> set k1 v1
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> set k3 v3
    QUEUED
    127.0.0.1:6379(TX)> getset k3		#错误的命令
    (error) ERR wrong number of arguments for 'getset' command
    127.0.0.1:6379(TX)> set k4 v4
    QUEUED
    127.0.0.1:6379(TX)> set k5 v5
    QUEUED
    127.0.0.1:6379(TX)> exec			#执行事务报错
    (error) EXECABORT Transaction discarded because of previous errors.
    127.0.0.1:6379> get k5				#所有的命令都不会被执行
    (nil)
    ##############################################################################################

代码逻辑错误 (运行时异常) \*\*其他命令可以正常执行 \*\* >>> 所以不保证事务原子性

##############################################################################################
    127.0.0.1:6379> set k1 "v1"
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> incr k1							#单个执行可放如队列，整个事务执行时报错
    QUEUED
    127.0.0.1:6379(TX)> set k2 v2
    QUEUED
    127.0.0.1:6379(TX)> set k3 v3
    QUEUED
    127.0.0.1:6379(TX)> get k3
    QUEUED
    127.0.0.1:6379(TX)> exec
    1) (error) ERR value is not an integer or out of range		#虽然第一条命令报错，但依旧执行成功
    2) OK
    3) OK
    4) "v3"
    127.0.0.1:6379> get k2
    "v2"
    127.0.0.1:6379> get k3
    "v3"
    ##############################################################################################

#### 三、监控（悲观锁、乐观锁） ####

悲观锁：很悲观，认为什么时候都会出现问题，无论做什么都会加锁。

乐观锁：

*  很乐观，认为什么时候都不会出现问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据获取version。
 *  更新的时候比较version。
 *  使用watch key监控指定数据，相当于乐观锁加锁。

##############################################################################################
     正常执行
    ##############################################################################################
    127.0.0.1:6379> set money 100
    OK
    127.0.0.1:6379> set outmoney 20
    OK
    127.0.0.1:6379> watch money			#监视money对象
    OK
    127.0.0.1:6379> multi				#事务正常结束，数据期间没有发送变动，正常执行。
    OK
    127.0.0.1:6379(TX)> decrby money 20
    QUEUED
    127.0.0.1:6379(TX)> incrby outmoney 20
    QUEUED
    127.0.0.1:6379(TX)> exec
    1) (integer) 80
    2) (integer) 40
    ##############################################################################################

测试多线程修改值，使用watch可以当做redis的乐观锁操作（相当于getversion）

线程1：监控事务，money事务处理

![1640788659152][]

线程2：在线程1money事务处理时间（还未执行）内改变money

![1640788792588][]

回归线程1：执行事务，提示为空

![1640788916651][]

解决方法：线程1使用unwatch解除监控

![1640789818104][]

\*\*注意：每次提交执行exec后都会自动释放锁，不管是否成功 \*\*

### 六、Jedis ###

使用Java来操作Redis，Jedis是Redis官方推荐使用的Java连接redis的客户端。

#### 一、测试： ####

1、导入对应的依赖

<dependencies>
        
        
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.0.0</version>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.67</version>
        </dependency>
    </dependencies>

2、编码测试

*  连接数据库
 *  操作命令
 *  断开连接
 *  测试结果

![1640914846906][]

public class TestPing {
        
        public static void main(String[] args) {
        
            //1、new Jedis对象即可
            Jedis jedis = new Jedis("127.0.0.1",6379);
            //Jedis 所有的命令
            System.out.println(jedis.ping());
        }
    }

![1640915245113][]

#### 二、常用的API ####

key

public class TestKey {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("127.0.0.1", 6379);
            System.out.println("清空数据库:"+jedis.flushDB());
            System.out.println(jedis.exists("判断这个键是否存在:"+"username"));
            //新增两组键
            System.out.println(jedis.set("username", "Jin"));
            System.out.println(jedis.set("password", "password"));
            System.out.println("系统中所有的键如下:");
            Set<String> keys = jedis.keys("*");
            System.out.println(keys);
            System.out.println("删除键password:"+jedis.del("password"));
            System.out.println("判断这个键是否存在:"+jedis.exists("password"));
            System.out.println("查看键的类型:"+jedis.type("username"));
            System.out.println("随机获取一个键:"+jedis.randomKey());
            System.out.println("重命名键:"+jedis.rename("username", "name"));
            System.out.println("取出重命名的键:"+jedis.get("name"));
            System.out.println("清空当前数据库中的key:"+jedis.flushDB());
            System.out.println("返回当前数据库中的key的数目:"+jedis.dbSize());
            System.out.println("清空所有数据库中的所有key:"+jedis.flushAll());
        }
    }

![1640916406886][]

String

public class TestString {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("127.0.0.1", 6379);
            System.out.println("清空数据库:"+jedis.flushDB());
    
            System.out.println("===========增加数据=============");
            System.out.println(jedis.set("key1", "value1"));
            System.out.println(jedis.set("key2", "value2"));
            System.out.println(jedis.set("key3", "value3"));
            System.out.println("删除键key2:"+jedis.del("key2"));
            System.out.println("获取键key2:"+jedis.get("key2"));
            System.out.println("修改key1:"+jedis.set("key1", "Jin"));
            System.out.println("获取key1的值:"+jedis.get("key1"));
            System.out.println("在key3后面加入值:"+jedis.append("key3", "end"));
            System.out.println("key3的值:"+jedis.get("key3"));
            System.out.println("增加多对键值对:"+jedis.mset("key01", "value01", "key02", "value02", "key03", "value03"));
            System.out.println("获得多对键值对:"+jedis.mget("key01", "key01", "key03"));
            System.out.println("获得多对键值对:"+jedis.mget("key01", "key01", "key03","key04"));
            System.out.println("删除多对键值对:"+jedis.del("key01", "key02"));
            System.out.println("获得多对键值对:"+jedis.mget("key01", "key01", "key03"));
    
            System.out.println("清空数据库:"+jedis.flushDB());
            System.out.println(jedis.setnx("key1", "value1"));
            System.out.println(jedis.setnx("key1", "value1"));
            System.out.println(jedis.setnx("key1", "value1"));
            System.out.println(jedis.get("key1"));
            System.out.println(jedis.get("key2"));
    
            System.out.println("==========新增键值并对设置有效时间==============");
            System.out.println(jedis.setex("key3", 2, "value3"));
            System.out.println(jedis.get("key3"));
            try {
        
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println(jedis.get("key3"));
    
            System.out.println("=========获取原值，更新新值===========");
            System.out.println(jedis.getSet("key2", "key2getset"));
            System.out.println(jedis.get("key2"));
            System.out.println("获得key2的值的字符串:"+jedis.getrange("key2", 2, 4));
        }
    }

List

public class TestList {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("127.0.0.1", 6379);
            System.out.println("清空数据库:"+jedis.flushDB());
            System.out.println("==========添加一个list==============");
            jedis.lpush("collections","ArrayList","Vetor","Stack","HashMap","WeakHashMap","LinkList");
            jedis.lpush("collections","HashSet");
            jedis.lpush("collections","TreeSet");
            jedis.lpush("collections","TreeMap");
            System.out.println("collections的内容:"+jedis.lrange("collections", 0, -1));
            System.out.println("collections区间的0-3的元素:"+jedis.lrange("collections", 0, 3));
            System.out.println("===================================");
            System.out.println("删除指定元素的个数："+jedis.lrem("collections", 2, "HashMap"));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("删除下标0-3区间之外的元素:"+jedis.ltrim("collections", 0, 3));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "Keys"));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "Linux"));
            System.out.println("collections中的内容："+jedis.lrange("collections", 0, -1));
            System.out.println("===================================");
            jedis.lpush("sortedList","3","6","2","4","9");
            System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
            System.out.println(jedis.sort("sortedList"));
            System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
        }
    }

#### 三、事务 ####

public class Testtransaction {
        
        public static void main(String[] args) {
        
            Jedis jedis = new Jedis("127.0.0.1", 6379);
    
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("Hello","world");
            jsonObject.put("name","Jin");
            // 开启事务
            Transaction multi = jedis.multi();
            String result = jsonObject.toString();
            // jedis.watch(result);
            try {
        
                multi.set("user1",result);
                multi.set("user2",result);
                // 执行事务
                multi.exec();
            }catch (Exception e){
        
                // 放弃事务
                multi.discard();
                e.printStackTrace();
            }finally {
        
                // 关闭连接
                System.out.println(jedis.get("user1"));
                System.out.println(jedis.get("user2"));
                jedis.close();
            }
        }
    }

![1640928835433][]

### 七、Springboot整合 ###

#### 一、测试 ####

1、pom.xml导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

2、源码分析、配置连接

![1640931012440][]

3、测试

@SpringBootTest
    class Redis02SpringbootApplicationTests {
        
    
        @Autowired
        private RedisTemplate redisTemplate;
    
        @Test
        void contextLoads() {
        
            // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
            // opsForValue 操作字符串 类似String
            // opsForList 操作List 类似List
            // opsForHash
    
            // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
    
            // 获取连接对象
            //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
            //connection.flushDb();
            //connection.flushAll();
    
            redisTemplate.opsForValue().set("mykey","Jin");
            System.out.println(redisTemplate.opsForValue().get("mykey"));
        }
    }

#### 二、对象序列化方法 ####

方法一：

1、新建一个pojo包，新建一个User.java

@Component
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class User {
        
        private String name;
        private int age;
    }

2、在Redis02SpringbootApplicationTests中编写一个teset方法测试

@Test
    public void test() throws JsonProcessingException {
        
        User user = new User("Jin", 23);
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",jsonUser);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

方法二：

1、新建一个User.java，直接implements Serializable（默认的序列化是jdk的序列化）

@Component
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class User implements Serializable {
        
        private String name;
        private int age;
    }

2、在 Redis02SpringbootApplicationTests 中注销对象转json字符串的方法

@Test
    public void test() throws JsonProcessingException {
        
        User user = new User("Jin", 23);
    //        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

3、输出

![1640933193697][]

#### 三、序列化配置（重写RedisTemplate） ####

1、新建一个config包，新建一个RedisConfig存放Redis配置方法，重写springboot默认的RedisTemplate (序列化）

@Configuration
    public class RedisConfig {
        
        //编写自己的RedisTemplate
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
            //Json的序列化
            Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            //        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);  方法过时
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);
            //String的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    
            //配置具体序列化的方式
            // key、hash的key 采用 String序列化方式
            template.setKeySerializer(stringRedisSerializer);
            template.setHashKeySerializer(stringRedisSerializer);
            // value、hash的value 采用 Jackson 序列化方式
            template.setValueSerializer(objectJackson2JsonRedisSerializer);
            template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
            template.afterPropertiesSet();
    
            return template;
        }
    }

2、在 Redis02SpringbootApplicationTests 中确定 redisTemplate 跳转的配置类是自己写的 RedisConfig

package com.jin;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.jin.pojo.User;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.redis.core.RedisTemplate;
    
    @SpringBootTest
    class Redis02SpringbootApplicationTests {
        
    
        @Autowired
        @Qualifier("redisTemplate")				//指定自己写的redisTemplate 
        private RedisTemplate redisTemplate;
    
        @Test
        void contextLoads() {
        
            // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
            // opsForValue 操作字符串 类似String
            // opsForList 操作List 类似List
            // opsForHash
    
            // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD
    
            // 获取连接对象
            //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
            //connection.flushDb();
            //connection.flushAll();
    
            redisTemplate.opsForValue().set("mykey","Jin");
            System.out.println(redisTemplate.opsForValue().get("mykey"));
        }
    
        @Test
        public void test() throws JsonProcessingException {
        
            User user = new User("Jin", 23);
    //        String jsonUser = new ObjectMapper().writeValueAsString(user);
            redisTemplate.opsForValue().set("user",user);
            System.out.println(redisTemplate.opsForValue().get("user"));
        }
    }

3、查看控制台和redis-cli，不再乱码

![1640935900223][]

#### 四、工具类 ####

##### 1、RedisUtil #####

直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注解注入。

package com.jin.util;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
    
    @Component
    public final class RedisUtil {
        
    	
    	@Autowired
    	private RedisTemplate<String, Object> redisTemplate;
    
    	// =============================common============================
    	/**
    	 * 指定缓存失效时间
    	 * @param key 键
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean expire(String key, long time) {
        
    		try {
        
    			if (time > 0) {
        
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 根据key 获取过期时间
    	 * @param key 键 不能为null
    	 * @return 时间(秒) 返回0代表为永久有效
    	 */
    	public long getExpire(String key) {
        
    		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    	}
    
    	/**
    	 * 判断key是否存在
    	 * @param key 键
    	 * @return true 存在 false不存在
    	 */
    	public boolean hasKey(String key) {
        
    		try {
        
    			return redisTemplate.hasKey(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 删除缓存
    	 * @param key 可以传一个值 或多个
    	 */
    	@SuppressWarnings("unchecked")
    	public void del(String... key) {
        
    		if (key != null && key.length > 0) {
        
    			if (key.length == 1) {
        
    				redisTemplate.delete(key[0]);
    			} else {
        
    				redisTemplate.delete(String.valueOf(CollectionUtils.arrayToList(key)));
    			}
    		}
    	}
    
    	// ============================String=============================
    	/**
    	 * 普通缓存获取
    	 * @param key 键
    	 * @return 值
    	 */
    	public Object get(String key) {
        
    		return key == null ? null : redisTemplate.opsForValue().get(key);
    	}
    
    	/**
    	 * 普通缓存放入
    	 * @param key 键
    	 * @param value 值
    	 * @return true成功 false失败
    	 */
    	public boolean set(String key, Object value) {
        
    		try {
        
    			redisTemplate.opsForValue().set(key, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    
    	}
    
    	/**
    	 * 普通缓存放入并设置时间
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    	 * @return true成功 false 失败
    	 */
    	public boolean set(String key, Object value, long time) {
        
    		try {
        
    			if (time > 0) {
        
    				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    			} else {
        
    				set(key, value);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 递增
    	 * @param key 键
    	 * @param delta 要增加几(大于0)
    	 * @return
    	 */
    	public long incr(String key, long delta) {
        
    		if (delta < 0) {
        
    			throw new RuntimeException("递增因子必须大于0");
    		}
    		return redisTemplate.opsForValue().increment(key, delta);
    	}
    
    	/**
    	 * 递减
    	 * @param key 键
    	 * @param delta 要减少几(小于0)
    	 * @return
    	 */
    	public long decr(String key, long delta) {
        
    		if (delta < 0) {
        
    			throw new RuntimeException("递减因子必须大于0");
    		}
    		return redisTemplate.opsForValue().increment(key, -delta);
    	}
    
    	// ================================Map=================================
    	/**
    	 * HashGet
    	 * @param key 键 不能为null
    	 * @param item 项 不能为null
    	 * @return 值
    	 */
    	public Object hget(String key, String item) {
        
    		return redisTemplate.opsForHash().get(key, item);
    	}
    
    	/**
    	 * 获取hashKey对应的所有键值
    	 * @param key 键
    	 * @return 对应的多个键值
    	 */
    	public Map<Object, Object> hmget(String key) {
        
    		return redisTemplate.opsForHash().entries(key);
    	}
    
    	/**
    	 * HashSet
    	 * @param key 键
    	 * @param map 对应多个键值
    	 * @return true 成功 false 失败
    	 */
    	public boolean hmset(String key, Map<String, Object> map) {
        
    		try {
        
    			redisTemplate.opsForHash().putAll(key, map);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * HashSet 并设置时间
    	 * @param key 键
    	 * @param map 对应多个键值
    	 * @param time 时间(秒)
    	 * @return true成功 false失败
    	 */
    	public boolean hmset(String key, Map<String, Object> map, long time) {
        
    		try {
        
    			redisTemplate.opsForHash().putAll(key, map);
    			if (time > 0) {
        
    				expire(key, time);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 向一张hash表中放入数据,如果不存在将创建
    	 * @param key 键
    	 * @param item 项
    	 * @param value 值
    	 * @return true 成功 false失败
    	 */
    	public boolean hset(String key, String item, Object value) {
        
    		try {
        
    			redisTemplate.opsForHash().put(key, item, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 向一张hash表中放入数据,如果不存在将创建
    	 * @param key 键
    	 * @param item 项
    	 * @param value 值
    	 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    	 * @return true 成功 false失败
    	 */
    	public boolean hset(String key, String item, Object value, long time) {
        
    		try {
        
    			redisTemplate.opsForHash().put(key, item, value);
    			if (time > 0) {
        
    				expire(key, time);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 删除hash表中的值
    	 * @param key 键 不能为null
    	 * @param item 项 可以使多个 不能为null
    	 */
    	public void hdel(String key, Object... item) {
        
    		redisTemplate.opsForHash().delete(key, item);
    	}
    
    	/**
    	 * 判断hash表中是否有该项的值
    	 * @param key 键 不能为null
    	 * @param item 项 不能为null
    	 * @return true 存在 false不存在
    	 */
    	public boolean hHasKey(String key, String item) {
        
    		return redisTemplate.opsForHash().hasKey(key, item);
    	}
    
    	/**
    	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要增加几(大于0)
    	 * @return
    	 */
    	public double hincr(String key, String item, double by) {
        
    		return redisTemplate.opsForHash().increment(key, item, by);
    	}
    
    	/**
    	 * hash递减
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要减少记(小于0)
    	 * @return
    	 */
    	public double hdecr(String key, String item, double by) {
        
    		return redisTemplate.opsForHash().increment(key, item, -by);
    	}
    
    	// ============================set=============================
    	/**
    	 * 根据key获取Set中的所有值
    	 * @param key 键
    	 * @return
    	 */
    	public Set<Object> sGet(String key) {
        
    		try {
        
    			return redisTemplate.opsForSet().members(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    
    	/**
    	 * 根据value从一个set中查询,是否存在
    	 * @param key 键
    	 * @param value 值
    	 * @return true 存在 false不存在
    	 */
    	public boolean sHasKey(String key, Object value) {
        
    		try {
        
    			return redisTemplate.opsForSet().isMember(key, value);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 将数据放入set缓存
    	 * @param key 键
    	 * @param values 值 可以是多个
    	 * @return 成功个数
    	 */
    	public long sSet(String key, Object... values) {
        
    		try {
        
    			return redisTemplate.opsForSet().add(key, values);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    
    	/**
    	 * 将set数据放入缓存
    	 * @param key 键
    	 * @param time 时间(秒)
    	 * @param values 值 可以是多个
    	 * @return 成功个数
    	 */
    	public long sSetAndTime(String key, long time, Object... values) {
        
    		try {
        
    			Long count = redisTemplate.opsForSet().add(key, values);
    			if (time > 0)
    				expire(key, time);
    			return count;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    
    	/**
    	 * 获取set缓存的长度
    	 * @param key 键
    	 * @return
    	 */
    	public long sGetSetSize(String key) {
        
    		try {
        
    			return redisTemplate.opsForSet().size(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    
    	/**
    	 * 移除值为value的
    	 * @param key 键
    	 * @param values 值 可以是多个
    	 * @return 移除的个数
    	 */
    	public long setRemove(String key, Object... values) {
        
    		try {
        
    			Long count = redisTemplate.opsForSet().remove(key, values);
    			return count;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    	// ===============================list=================================
    
    	/**
    	 * 获取list缓存的内容
    	 * @param key 键
    	 * @param start 开始
    	 * @param end 结束 0 到 -1代表所有值
    	 * @return
    	 */
    	public List<Object> lGet(String key, long start, long end) {
        
    		try {
        
    			return redisTemplate.opsForList().range(key, start, end);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    
    	/**
    	 * 获取list缓存的长度
    	 * @param key 键
    	 * @return
    	 */
    	public long lGetListSize(String key) {
        
    		try {
        
    			return redisTemplate.opsForList().size(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    
    	/**
    	 * 通过索引 获取list中的值
    	 * @param key 键
    	 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    	 * @return
    	 */
    	public Object lGetIndex(String key, long index) {
        
    		try {
        
    			return redisTemplate.opsForList().index(key, index);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, Object value) {
        
    		try {
        
    			redisTemplate.opsForList().rightPush(key, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, Object value, long time) {
        
    		try {
        
    			redisTemplate.opsForList().rightPush(key, value);
    			if (time > 0)
    				expire(key, time);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, List<Object> value) {
        
    		try {
        
    			redisTemplate.opsForList().rightPushAll(key, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 将list放入缓存
    	 * 
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, List<Object> value, long time) {
        
    		try {
        
    			redisTemplate.opsForList().rightPushAll(key, value);
    			if (time > 0)
    				expire(key, time);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 根据索引修改list中的某条数据
    	 * @param key 键
    	 * @param index 索引
    	 * @param value 值
    	 * @return
    	 */
    	public boolean lUpdateIndex(String key, long index, Object value) {
        
    		try {
        
    			redisTemplate.opsForList().set(key, index, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    
    	/**
    	 * 移除N个值为value
    	 * @param key 键
    	 * @param count 移除多少个
    	 * @param value 值
    	 * @return 移除的个数
    	 */
    	public long lRemove(String key, long count, Object value) {
        
    		try {
        
    			Long remove = redisTemplate.opsForList().remove(key, count, value);
    			return remove;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    }

##### 2、RedisUtil #####

package com.Jin;
    
    import org.springframework.data.redis.connection.DataType;
    import org.springframework.data.redis.core.Cursor;
    import org.springframework.data.redis.core.ScanOptions;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
    
    import java.util.Collection;
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Redis工具类*/
    public class RedisUtil {
        
        private StringRedisTemplate redisTemplate;
    
        public void setRedisTemplate(StringRedisTemplate redisTemplate) {
        
            this.redisTemplate = redisTemplate;
        }
    
        public StringRedisTemplate getRedisTemplate() {
        
            return this.redisTemplate;
        }
    
        /** -------------------key相关操作--------------------- */
    
        /**
         * 删除key
         * 
         * @param key
         */
        public void delete(String key) {
        
            redisTemplate.delete(key);
        }
    
        /**
         * 批量删除key
         * 
         * @param keys
         */
        public void delete(Collection<String> keys) {
        
            redisTemplate.delete(keys);
        }
    
        /**
         * 序列化key
         * 
         * @param key
         * @return
         */
        public byte[] dump(String key) {
        
            return redisTemplate.dump(key);
        }
    
        /**
         * 是否存在key
         * 
         * @param key
         * @return
         */
        public Boolean hasKey(String key) {
        
            return redisTemplate.hasKey(key);
        }
    
        /**
         * 设置过期时间
         * 
         * @param key
         * @param timeout
         * @param unit
         * @return
         */
        public Boolean expire(String key, long timeout, TimeUnit unit) {
        
            return redisTemplate.expire(key, timeout, unit);
        }
    
        /**
         * 设置过期时间
         * 
         * @param key
         * @param date
         * @return
         */
        public Boolean expireAt(String key, Date date) {
        
            return redisTemplate.expireAt(key, date);
        }
    
        /**
         * 查找匹配的key
         * 
         * @param pattern
         * @return
         */
        public Set<String> keys(String pattern) {
        
            return redisTemplate.keys(pattern);
        }
    
        /**
         * 将当前数据库的 key 移动到给定的数据库 db 当中
         * 
         * @param key
         * @param dbIndex
         * @return
         */
        public Boolean move(String key, int dbIndex) {
        
            return redisTemplate.move(key, dbIndex);
        }
    
        /**
         * 移除 key 的过期时间，key 将持久保持
         * 
         * @param key
         * @return
         */
        public Boolean persist(String key) {
        
            return redisTemplate.persist(key);
        }
    
        /**
         * 返回 key 的剩余的过期时间
         * 
         * @param key
         * @param unit
         * @return
         */
        public Long getExpire(String key, TimeUnit unit) {
        
            return redisTemplate.getExpire(key, unit);
        }
    
        /**
         * 返回 key 的剩余的过期时间
         * 
         * @param key
         * @return
         */
        public Long getExpire(String key) {
        
            return redisTemplate.getExpire(key);
        }
    
        /**
         * 从当前数据库中随机返回一个 key
         * 
         * @return
         */
        public String randomKey() {
        
            return redisTemplate.randomKey();
        }
    
        /**
         * 修改 key 的名称
         * 
         * @param oldKey
         * @param newKey
         */
        public void rename(String oldKey, String newKey) {
        
            redisTemplate.rename(oldKey, newKey);
        }
    
        /**
         * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
         * 
         * @param oldKey
         * @param newKey
         * @return
         */
        public Boolean renameIfAbsent(String oldKey, String newKey) {
        
            return redisTemplate.renameIfAbsent(oldKey, newKey);
        }
    
        /**
         * 返回 key 所储存的值的类型
         * 
         * @param key
         * @return
         */
        public DataType type(String key) {
        
            return redisTemplate.type(key);
        }
    
        /** -------------------string相关操作--------------------- */
    
        /**
         * 设置指定 key 的值
         * @param key
         * @param value
         */
        public void set(String key, String value) {
        
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 获取指定 key 的值
         * @param key
         * @return
         */
        public String get(String key) {
        
            return redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 返回 key 中字符串值的子字符
         * @param key
         * @param start
         * @param end
         * @return
         */
        public String getRange(String key, long start, long end) {
        
            return redisTemplate.opsForValue().get(key, start, end);
        }
    
        /**
         * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
         * 
         * @param key
         * @param value
         * @return
         */
        public String getAndSet(String key, String value) {
        
            return redisTemplate.opsForValue().getAndSet(key, value);
        }
    
        /**
         * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
         * 
         * @param key
         * @param offset
         * @return
         */
        public Boolean getBit(String key, long offset) {
        
            return redisTemplate.opsForValue().getBit(key, offset);
        }
    
        /**
         * 批量获取
         * 
         * @param keys
         * @return
         */
        public List<String> multiGet(Collection<String> keys) {
        
            return redisTemplate.opsForValue().multiGet(keys);
        }
    
        /**
         * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
         * 
         * @param key 位置
         * @param value
         *            值,true为1, false为0
         * @return
         */
        public boolean setBit(String key, long offset, boolean value) {
        
            return redisTemplate.opsForValue().setBit(key, offset, value);
        }
    
        /**
         * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
         * 
         * @param key
         * @param value
         * @param timeout
         *            过期时间
         * @param unit
         *            时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
         *            秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
         */
        public void setEx(String key, String value, long timeout, TimeUnit unit) {
        
            redisTemplate.opsForValue().set(key, value, timeout, unit);
        }
    
        /**
         * 只有在 key 不存在时设置 key 的值
         * 
         * @param key
         * @param value
         * @return 之前已经存在返回false,不存在返回true
         */
        public boolean setIfAbsent(String key, String value) {
        
            return redisTemplate.opsForValue().setIfAbsent(key, value);
        }
    
        /**
         * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
         * 
         * @param key
         * @param value
         * @param offset
         *            从指定位置开始覆写
         */
        public void setRange(String key, String value, long offset) {
        
            redisTemplate.opsForValue().set(key, value, offset);
        }
    
        /**
         * 获取字符串的长度
         * 
         * @param key
         * @return
         */
        public Long size(String key) {
        
            return redisTemplate.opsForValue().size(key);
        }
    
        /**
         * 批量添加
         * 
         * @param maps
         */
        public void multiSet(Map<String, String> maps) {
        
            redisTemplate.opsForValue().multiSet(maps);
        }
    
        /**
         * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
         * 
         * @param maps
         * @return 之前已经存在返回false,不存在返回true
         */
        public boolean multiSetIfAbsent(Map<String, String> maps) {
        
            return redisTemplate.opsForValue().multiSetIfAbsent(maps);
        }
    
        /**
         * 增加(自增长), 负数则为自减
         * 
         * @param key
         * @return
         */
        public Long incrBy(String key, long increment) {
        
            return redisTemplate.opsForValue().increment(key, increment);
        }
    
        /**
         * 
         * @param key
         * @return
         */
        public Double incrByFloat(String key, double increment) {
        
            return redisTemplate.opsForValue().increment(key, increment);
        }
    
        /**
         * 追加到末尾
         * 
         * @param key
         * @param value
         * @return
         */
        public Integer append(String key, String value) {
        
            return redisTemplate.opsForValue().append(key, value);
        }
    
        /** -------------------hash相关操作------------------------- */
    
        /**
         * 获取存储在哈希表中指定字段的值
         * 
         * @param key
         * @param field
         * @return
         */
        public Object hGet(String key, String field) {
        
            return redisTemplate.opsForHash().get(key, field);
        }
    
        /**
         * 获取所有给定字段的值
         * 
         * @param key
         * @return
         */
        public Map<Object, Object> hGetAll(String key) {
        
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 获取所有给定字段的值
         * 
         * @param key
         * @param fields
         * @return
         */
        public List<Object> hMultiGet(String key, Collection<Object> fields) {
        
            return redisTemplate.opsForHash().multiGet(key, fields);
        }
    
        public void hPut(String key, String hashKey, String value) {
        
            redisTemplate.opsForHash().put(key, hashKey, value);
        }
    
        public void hPutAll(String key, Map<String, String> maps) {
        
            redisTemplate.opsForHash().putAll(key, maps);
        }
    
        /**
         * 仅当hashKey不存在时才设置
         * 
         * @param key
         * @param hashKey
         * @param value
         * @return
         */
        public Boolean hPutIfAbsent(String key, String hashKey, String value) {
        
            return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
        }
    
        /**
         * 删除一个或多个哈希表字段
         * 
         * @param key
         * @param fields
         * @return
         */
        public Long hDelete(String key, Object... fields) {
        
            return redisTemplate.opsForHash().delete(key, fields);
        }
    
        /**
         * 查看哈希表 key 中，指定的字段是否存在
         * 
         * @param key
         * @param field
         * @return
         */
        public boolean hExists(String key, String field) {
        
            return redisTemplate.opsForHash().hasKey(key, field);
        }
    
        /**
         * 为哈希表 key 中的指定字段的整数值加上增量 increment
         * 
         * @param key
         * @param field
         * @param increment
         * @return
         */
        public Long hIncrBy(String key, Object field, long increment) {
        
            return redisTemplate.opsForHash().increment(key, field, increment);
        }
    
        /**
         * 为哈希表 key 中的指定字段的整数值加上增量 increment
         * 
         * @param key
         * @param field
         * @param delta
         * @return
         */
        public Double hIncrByFloat(String key, Object field, double delta) {
        
            return redisTemplate.opsForHash().increment(key, field, delta);
        }
    
        /**
         * 获取所有哈希表中的字段
         * 
         * @param key
         * @return
         */
        public Set<Object> hKeys(String key) {
        
            return redisTemplate.opsForHash().keys(key);
        }
    
        /**
         * 获取哈希表中字段的数量
         * 
         * @param key
         * @return
         */
        public Long hSize(String key) {
        
            return redisTemplate.opsForHash().size(key);
        }
    
        /**
         * 获取哈希表中所有值
         * 
         * @param key
         * @return
         */
        public List<Object> hValues(String key) {
        
            return redisTemplate.opsForHash().values(key);
        }
    
        /**
         * 迭代哈希表中的键值对
         * 
         * @param key
         * @param options
         * @return
         */
        public Cursor<Entry<Object, Object>> hScan(String key, ScanOptions options) {
        
            return redisTemplate.opsForHash().scan(key, options);
        }
    
        /** ------------------------list相关操作---------------------------- */
    
        /**
         * 通过索引获取列表中的元素
         * 
         * @param key
         * @param index
         * @return
         */
        public String lIndex(String key, long index) {
        
            return redisTemplate.opsForList().index(key, index);
        }
    
        /**
         * 获取列表指定范围内的元素
         * 
         * @param key
         * @param start
         *            开始位置, 0是开始位置
         * @param end
         *            结束位置, -1返回所有
         * @return
         */
        public List<String> lRange(String key, long start, long end) {
        
            return redisTemplate.opsForList().range(key, start, end);
        }
    
        /**
         * 存储在list头部
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lLeftPush(String key, String value) {
        
            return redisTemplate.opsForList().leftPush(key, value);
        }
    
        /**
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lLeftPushAll(String key, String... value) {
        
            return redisTemplate.opsForList().leftPushAll(key, value);
        }
    
        /**
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lLeftPushAll(String key, Collection<String> value) {
        
            return redisTemplate.opsForList().leftPushAll(key, value);
        }
    
        /**
         * 当list存在的时候才加入
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lLeftPushIfPresent(String key, String value) {
        
            return redisTemplate.opsForList().leftPushIfPresent(key, value);
        }
    
        /**
         * 如果pivot存在,再pivot前面添加
         * 
         * @param key
         * @param pivot
         * @param value
         * @return
         */
        public Long lLeftPush(String key, String pivot, String value) {
        
            return redisTemplate.opsForList().leftPush(key, pivot, value);
        }
    
        /**
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lRightPush(String key, String value) {
        
            return redisTemplate.opsForList().rightPush(key, value);
        }
    
        /**
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lRightPushAll(String key, String... value) {
        
            return redisTemplate.opsForList().rightPushAll(key, value);
        }
    
        /**
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lRightPushAll(String key, Collection<String> value) {
        
            return redisTemplate.opsForList().rightPushAll(key, value);
        }
    
        /**
         * 为已存在的列表添加值
         * 
         * @param key
         * @param value
         * @return
         */
        public Long lRightPushIfPresent(String key, String value) {
        
            return redisTemplate.opsForList().rightPushIfPresent(key, value);
        }
    
        /**
         * 在pivot元素的右边添加值
         * 
         * @param key
         * @param pivot
         * @param value
         * @return
         */
        public Long lRightPush(String key, String pivot, String value) {
        
            return redisTemplate.opsForList().rightPush(key, pivot, value);
        }
    
        /**
         * 通过索引设置列表元素的值
         * 
         * @param key
         * @param index
         *            位置
         * @param value
         */
        public void lSet(String key, long index, String value) {
        
            redisTemplate.opsForList().set(key, index, value);
        }
    
        /**
         * 移出并获取列表的第一个元素
         * 
         * @param key
         * @return 删除的元素
         */
        public String lLeftPop(String key) {
        
            return redisTemplate.opsForList().leftPop(key);
        }
    
        /**
         * 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
         * 
         * @param key
         * @param timeout
         *            等待时间
         * @param unit
         *            时间单位
         * @return
         */
        public String lBLeftPop(String key, long timeout, TimeUnit unit) {
        
            return redisTemplate.opsForList().leftPop(key, timeout, unit);
        }
    
        /**
         * 移除并获取列表最后一个元素
         * 
         * @param key
         * @return 删除的元素
         */
        public String lRightPop(String key) {
        
            return redisTemplate.opsForList().rightPop(key);
        }
    
        /**
         * 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
         * 
         * @param key
         * @param timeout
         *            等待时间
         * @param unit
         *            时间单位
         * @return
         */
        public String lBRightPop(String key, long timeout, TimeUnit unit) {
        
            return redisTemplate.opsForList().rightPop(key, timeout, unit);
        }
    
        /**
         * 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
         * 
         * @param sourceKey
         * @param destinationKey
         * @return
         */
        public String lRightPopAndLeftPush(String sourceKey, String destinationKey) {
        
            return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
                    destinationKey);
        }
    
        /**
         * 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
         * 
         * @param sourceKey
         * @param destinationKey
         * @param timeout
         * @param unit
         * @return
         */
        public String lBRightPopAndLeftPush(String sourceKey, String destinationKey,
                long timeout, TimeUnit unit) {
        
            return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
                    destinationKey, timeout, unit);
        }
    
        /**
         * 删除集合中值等于value得元素
         * 
         * @param key
         * @param index
         *            index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
         *            index<0, 从尾部开始删除第一个值等于value的元素;
         * @param value
         * @return
         */
        public Long lRemove(String key, long index, String value) {
        
            return redisTemplate.opsForList().remove(key, index, value);
        }
    
        /**
         * 裁剪list
         * 
         * @param key
         * @param start
         * @param end
         */
        public void lTrim(String key, long start, long end) {
        
            redisTemplate.opsForList().trim(key, start, end);
        }
    
        /**
         * 获取列表长度
         * 
         * @param key
         * @return
         */
        public Long lLen(String key) {
        
            return redisTemplate.opsForList().size(key);
        }
    
        /** --------------------set相关操作-------------------------- */
    
        /**
         * set添加元素
         * 
         * @param key
         * @param values
         * @return
         */
        public Long sAdd(String key, String... values) {
        
            return redisTemplate.opsForSet().add(key, values);
        }
    
        /**
         * set移除元素
         * 
         * @param key
         * @param values
         * @return
         */
        public Long sRemove(String key, Object... values) {
        
            return redisTemplate.opsForSet().remove(key, values);
        }
    
        /**
         * 移除并返回集合的一个随机元素
         * 
         * @param key
         * @return
         */
        public String sPop(String key) {
        
            return redisTemplate.opsForSet().pop(key);
        }
    
        /**
         * 将元素value从一个集合移到另一个集合
         * 
         * @param key
         * @param value
         * @param destKey
         * @return
         */
        public Boolean sMove(String key, String value, String destKey) {
        
            return redisTemplate.opsForSet().move(key, value, destKey);
        }
    
        /**
         * 获取集合的大小
         * 
         * @param key
         * @return
         */
        public Long sSize(String key) {
        
            return redisTemplate.opsForSet().size(key);
        }
    
        /**
         * 判断集合是否包含value
         * 
         * @param key
         * @param value
         * @return
         */
        public Boolean sIsMember(String key, Object value) {
        
            return redisTemplate.opsForSet().isMember(key, value);
        }
    
        /**
         * 获取两个集合的交集
         * 
         * @param key
         * @param otherKey
         * @return
         */
        public Set<String> sIntersect(String key, String otherKey) {
        
            return redisTemplate.opsForSet().intersect(key, otherKey);
        }
    
        /**
         * 获取key集合与多个集合的交集
         * 
         * @param key
         * @param otherKeys
         * @return
         */
        public Set<String> sIntersect(String key, Collection<String> otherKeys) {
        
            return redisTemplate.opsForSet().intersect(key, otherKeys);
        }
    
        /**
         * key集合与otherKey集合的交集存储到destKey集合中
         * 
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long sIntersectAndStore(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForSet().intersectAndStore(key, otherKey,
                    destKey);
        }
    
        /**
         * key集合与多个集合的交集存储到destKey集合中
         * 
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long sIntersectAndStore(String key, Collection<String> otherKeys,
                String destKey) {
        
            return redisTemplate.opsForSet().intersectAndStore(key, otherKeys,
                    destKey);
        }
    
        /**
         * 获取两个集合的并集
         * 
         * @param key
         * @param otherKeys
         * @return
         */
        public Set<String> sUnion(String key, String otherKeys) {
        
            return redisTemplate.opsForSet().union(key, otherKeys);
        }
    
        /**
         * 获取key集合与多个集合的并集
         * 
         * @param key
         * @param otherKeys
         * @return
         */
        public Set<String> sUnion(String key, Collection<String> otherKeys) {
        
            return redisTemplate.opsForSet().union(key, otherKeys);
        }
    
        /**
         * key集合与otherKey集合的并集存储到destKey中
         * 
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long sUnionAndStore(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
        }
    
        /**
         * key集合与多个集合的并集存储到destKey中
         * 
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long sUnionAndStore(String key, Collection<String> otherKeys,
                String destKey) {
        
            return redisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
        }
    
        /**
         * 获取两个集合的差集
         * 
         * @param key
         * @param otherKey
         * @return
         */
        public Set<String> sDifference(String key, String otherKey) {
        
            return redisTemplate.opsForSet().difference(key, otherKey);
        }
    
        /**
         * 获取key集合与多个集合的差集
         * 
         * @param key
         * @param otherKeys
         * @return
         */
        public Set<String> sDifference(String key, Collection<String> otherKeys) {
        
            return redisTemplate.opsForSet().difference(key, otherKeys);
        }
    
        /**
         * key集合与otherKey集合的差集存储到destKey中
         * 
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long sDifference(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForSet().differenceAndStore(key, otherKey,
                    destKey);
        }
    
        /**
         * key集合与多个集合的差集存储到destKey中
         * 
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long sDifference(String key, Collection<String> otherKeys,
                String destKey) {
        
            return redisTemplate.opsForSet().differenceAndStore(key, otherKeys,
                    destKey);
        }
    
        /**
         * 获取集合所有元素
         * 
         * @param key
         * @return
         */
        public Set<String> setMembers(String key) {
        
            return redisTemplate.opsForSet().members(key);
        }
    
        /**
         * 随机获取集合中的一个元素
         * 
         * @param key
         * @return
         */
        public String sRandomMember(String key) {
        
            return redisTemplate.opsForSet().randomMember(key);
        }
    
        /**
         * 随机获取集合中count个元素
         * 
         * @param key
         * @param count
         * @return
         */
        public List<String> sRandomMembers(String key, long count) {
        
            return redisTemplate.opsForSet().randomMembers(key, count);
        }
    
        /**
         * 随机获取集合中count个元素并且去除重复的
         * 
         * @param key
         * @param count
         * @return
         */
        public Set<String> sDistinctRandomMembers(String key, long count) {
        
            return redisTemplate.opsForSet().distinctRandomMembers(key, count);
        }
    
        /**
         * 
         * @param key
         * @param options
         * @return
         */
        public Cursor<String> sScan(String key, ScanOptions options) {
        
            return redisTemplate.opsForSet().scan(key, options);
        }
    
        /**------------------zSet相关操作--------------------------------*/
        
        /**
         * 添加元素,有序集合是按照元素的score值由小到大排列
         * 
         * @param key
         * @param value
         * @param score
         * @return
         */
        public Boolean zAdd(String key, String value, double score) {
        
            return redisTemplate.opsForZSet().add(key, value, score);
        }
    
        /**
         * 
         * @param key
         * @param values
         * @return
         */
        public Long zAdd(String key, Set<TypedTuple<String>> values) {
        
            return redisTemplate.opsForZSet().add(key, values);
        }
    
        /**
         * 
         * @param key
         * @param values
         * @return
         */
        public Long zRemove(String key, Object... values) {
        
            return redisTemplate.opsForZSet().remove(key, values);
        }
    
        /**
         * 增加元素的score值，并返回增加后的值
         * 
         * @param key
         * @param value
         * @param delta
         * @return
         */
        public Double zIncrementScore(String key, String value, double delta) {
        
            return redisTemplate.opsForZSet().incrementScore(key, value, delta);
        }
    
        /**
         * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
         * 
         * @param key
         * @param value
         * @return 0表示第一位
         */
        public Long zRank(String key, Object value) {
        
            return redisTemplate.opsForZSet().rank(key, value);
        }
    
        /**
         * 返回元素在集合的排名,按元素的score值由大到小排列
         * 
         * @param key
         * @param value
         * @return
         */
        public Long zReverseRank(String key, Object value) {
        
            return redisTemplate.opsForZSet().reverseRank(key, value);
        }
    
        /**
         * 获取集合的元素, 从小到大排序
         * 
         * @param key
         * @param start
         *            开始位置
         * @param end
         *            结束位置, -1查询所有
         * @return
         */
        public Set<String> zRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().range(key, start, end);
        }
    
        /**
         * 获取集合元素, 并且把score值也获取
         * 
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<TypedTuple<String>> zRangeWithScores(String key, long start,
                long end) {
        
            return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
        }
    
        /**
         * 根据Score值查询集合元素
         * 
         * @param key
         * @param min
         *            最小值
         * @param max
         *            最大值
         * @return
         */
        public Set<String> zRangeByScore(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().rangeByScore(key, min, max);
        }
    
        /**
         * 根据Score值查询集合元素, 从小到大排序
         * 
         * @param key
         * @param min
         *            最小值
         * @param max
         *            最大值
         * @return
         */
        public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
                double min, double max) {
        
            return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
        }
    
        /**
         * 
         * @param key
         * @param min
         * @param max
         * @param start
         * @param end
         * @return
         */
        public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
                double min, double max, long start, long end) {
        
            return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
                    start, end);
        }
    
        /**
         * 获取集合的元素, 从大到小排序
         * 
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<String> zReverseRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRange(key, start, end);
        }
    
        /**
         * 获取集合的元素, 从大到小排序, 并返回score值
         * 
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<TypedTuple<String>> zReverseRangeWithScores(String key,
                long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
                    end);
        }
    
        /**
         * 根据Score值查询集合元素, 从大到小排序
         * 
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Set<String> zReverseRangeByScore(String key, double min,
                double max) {
        
            return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
        }
    
        /**
         * 根据Score值查询集合元素, 从大到小排序
         * 
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
                String key, double min, double max) {
        
            return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
                    min, max);
        }
    
        /**
         * 
         * @param key
         * @param min
         * @param max
         * @param start
         * @param end
         * @return
         */
        public Set<String> zReverseRangeByScore(String key, double min,
                double max, long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
                    start, end);
        }
    
        /**
         * 根据score值获取集合元素数量
         * 
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Long zCount(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().count(key, min, max);
        }
    
        /**
         * 获取集合大小
         * 
         * @param key
         * @return
         */
        public Long zSize(String key) {
        
            return redisTemplate.opsForZSet().size(key);
        }
    
        /**
         * 获取集合大小
         * 
         * @param key
         * @return
         */
        public Long zZCard(String key) {
        
            return redisTemplate.opsForZSet().zCard(key);
        }
    
        /**
         * 获取集合中value元素的score值
         * 
         * @param key
         * @param value
         * @return
         */
        public Double zScore(String key, Object value) {
        
            return redisTemplate.opsForZSet().score(key, value);
        }
    
        /**
         * 移除指定索引位置的成员
         * 
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Long zRemoveRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().removeRange(key, start, end);
        }
    
        /**
         * 根据指定的score值的范围来移除成员
         * 
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Long zRemoveRangeByScore(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
        }
    
        /**
         * 获取key和otherKey的并集并存储在destKey中
         * 
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long zUnionAndStore(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
        }
    
        /**
         * 
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long zUnionAndStore(String key, Collection<String> otherKeys,
                String destKey) {
        
            return redisTemplate.opsForZSet()
                    .unionAndStore(key, otherKeys, destKey);
        }
    
        /**
         * 交集
         * 
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long zIntersectAndStore(String key, String otherKey,
                String destKey) {
        
            return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,
                    destKey);
        }
    
        /**
         * 交集
         * 
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long zIntersectAndStore(String key, Collection<String> otherKeys,
                String destKey) {
        
            return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
                    destKey);
        }
    
        /**
         * 
         * @param key
         * @param options
         * @return
         */
        public Cursor<TypedTuple<String>> zScan(String key, ScanOptions options) {
        
            return redisTemplate.opsForZSet().scan(key, options);
        }
    }

##### 3、测试 #####

@Autowired
    private RedisUtil redisUtil;
    
    @Test
    public void testutil(){
        
        redisUtil.set("name","Ji");
        System.out.println(redisUtil.get("user"));
    }

### 八、Redis.config ###

#绑定的ip
    bind 127.0.0.1
    #保护模式
    protected-mode yes
    #端口
    port 6379
    #这些配置之后可能会经常使用
    
    #以守护线程的方式开启
    daemonize yes 
    
    #日志
    #debug、verbose、notice、warning
    #设置日志等级
    loglevel notice
    
    #设置日志文件位置
    logfile “”
    
    #16个数据库
    database 16
    
    #永远显示logo
    always-show-logo yes 
    
    snapshotting#快照
    #三个方法，在规定时间内，执行了多少次操作，则会持久化到文件  .rdb  .aof
    #redis是内存数据库，没有持久化，数据就会丢失
    save 900 1  #900秒内，至少有一个key进行了修改，就进行持久化操作
    save 300 10  #300秒内，至少有一个key进行了修改，就进行持久化操作
    save 60 10000  #同理
    
    #持久化错误之后是否要继续工作，默认开启
    stop-writes-on-bgseve-error yes
    #是否压缩rdb文件，需要消耗cpu资源
    rdbcompression yes
    #保存rdb文件是否要进行错误检查校验
    rdbchecksum yes
    #rdb文件保存的目录
    dir 	./
    	
    	
    replication #主从复制，需要搭建多个redis
    
    
    Security #安全设置
    #默认没有密码
    requirepass foobared
    #通过命令config set requirepass 可以设置密码
    #auth password   进行登录
    
    ########################################################################
    127.0.0.1:6379> ping 
    PONG
    127.0.0.1:6379> config get requirepass				#获取redis的密码
    1) "requirepass"
    2) ""
    127.0.0.1:6379> config set requirepass "123456"		#设置redis的密码
    OK
    127.0.0.1:6379> ping								#发现所有的命令就不能显示了
    (error) NOAUTH Authentication required.
    127.0.0.1:6379> auth 123456							#使用密码登录
    OK
    127.0.0.1:6379> config get requirepass
    1) "requirepass"
    2) "123456"
    127.0.0.1:6379> ping
    PONG
    127.0.0.1:6379> config set requirepass ""		#设置redis的密码为空的
    OK
    ########################################################################
    
    #设置能连接上redis的最大客户端数量
    maxlients 10000 
    #redis配置最大的内存数
    maxmemory <bytes>
    #内存到达上限之后的处理策略
    maxmemory-policy noeviction
    		#移除一些过期的key
    		#报错、、、
    		#六种机制
    		volatile-lru：设置了过期时间的key进行lru移除
    		allkeys-lru：删除
    		volatile-random：删除即将过期的key
    		allkeys-random：随机删除
    		volatile-ttl：删除即将过期的
    		noeviction：永远不过期，直接报错
    		
    
    #持久化的两种方式之一RDB、AOF
    Append only模式  aof模式
    #默认是不开启AOF模式的，默认使用RDB持久化，大部分情况下RDB完全够用
    appendonly no
    #aof持计划文件名
    appendfilename "appendonly.aof"
    
    #每次修改都会synch 消耗性能
    appendfsync always 
    #每秒执行一次 synch，可能会丢失那1s的数据
    appendfsync everysec 
    #不执行sync 这时候操作系统自己同步数据，速度是最快的，一般也不用
    appendfsync no

### 九、Redis持久化 ###

#### 一、 RDB（Redis DataBase）----- 保存的文件是dump.rdb ####

在指定的时间 间隔内将内存中的数据集快照写入到磁盘中，Snapshot快照，恢复时将快照文件直接读到内存中

*  单独创建一个子进程，fork分支
 *  将内存内容写入临时RDB文件
 *  再用临时文件替换上次持久化完成的文件

整个过程主进程不进行任何io操作，保证了性能，如果进行大规模数据恢复，RDB和AOP都可以进行数据恢复，RDB数据恢复完整性不敏感，RDB更加高效，缺点时最后一次持久化后的数据可能丢失，默认使用的就是RDB，一般情况不需要修改这个配置

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hSirw4uf-1679539496802)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1640942443737.png)\]

*  ##### 触发机制 #####
    
     *  save规则触发，会自动触发rdb规则
     *  执行flushall命令，会触发rdb规则
     *  关闭redis，也会触发rdb规则
 *  备份会自动生成dump.rdb文件

如何恢复备份文件？

只要将rdb文件放在redis规定的目录，redis启动时会自动检查dump.rdb文件恢复数据
    
    查看位置，config get dir，在生产环境中最好对dump.rdb文件进行备份

RDB优缺点  
优点：父进程正常处理用户请求，fork分支一个子进程进行备份，适合大规模的数据恢复，如果服务器宕机了，不要删除rdb文件，重启自然在目录下，自动会读取。  
缺点：需要一定的时间间隔，可以自行修改设置，如果redis意外宕机，最后一次的修改数据会丢失，fork进程的时候，会占用一定的内存空间。

#### 二、 AOF （Append Only File）----- 保存的文件是appendonly.aof ####

将所执行的所有命令都记录下来，处读操作以外，恢复时重新执行一次，如果是大数据就需要写很久

**aof默认是文件无限追加，大小会不断扩张。在主从复制中，rdb是备用的，在从机上使用，aof一般不使用**

*  fork分支出子进程
 *  根据内存中的数据子进程创建临时aof文件
 *  父进程执行的命令存放在缓存中，并且写入原aof文件
 *  子进程完成新aof文件通知父进程
 *  父进程将缓存中的命令写入临时文件
 *  父进程用临时文件替换旧aof文件并重命名
 *  后面的命令都追加到新的aof文件中

![1640943756162][]

以日志的形式记录每个写的操作，将Redis执行的所有指令记录下来（读操作不记录），只许追加文件但不可以更改文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

什么是AOF
     快照功能（RDB）并不是非常耐久（durable）： 如果 Redis 因为某些原因而造成故障停机， 那么服务器将丢失最近写入、以及未保存到快照中的那些数据。 从 1.1 版本开始， Redis 增加了一种完全耐久的持久化方式： AOF 持久化。
    
    如果要使用AOF，需要修改配置文件：
    appendonly no yes则表示启用AOF
    
    默认是不开启的，我们需要手动配置，然后重启redis，就可以生效了！
    
    如果这个aof文件有错位，这时候redis是启动不起来的，我需要修改这个aof文件
    
    redis给我们提供了一个工具redis-check-aof --fix

appendonly yes  # 默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分的情况下，rdb完全够用
    appendfilename "appendonly.aof"
    # appendfsync always # 每次修改都会sync 消耗性能
    appendfsync everysec # 每秒执行一次 sync 可能会丢失这一秒的数据
    # appendfsync no # 不执行 sync ,这时候操作系统自己同步数据，速度最快

**优点**

1.  每一次修改都会同步，文件的完整性会更加好
2.  没秒同步一次，可能会丢失一秒的数据
3.  从不同步，效率最高

**缺点**

1.  相对于数据文件来说，aof远远大于rdb，修复速度比rdb慢！
2.  Aof运行效率也要比rdb慢，所以我们redis默认的配置就是rdb持久化

#### 三、RDB和AOP选择 ####

**RDB 和 AOF 对比**

<table> 
 <thead> 
  <tr> 
   <th>RDB</th> 
   <th>AOF</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>启动优先级</td> 
   <td>低</td> 
   <td>高</td> 
  </tr> 
  <tr> 
   <td>体积</td> 
   <td>小</td> 
   <td>大</td> 
  </tr> 
  <tr> 
   <td>恢复速度</td> 
   <td>快</td> 
   <td>慢</td> 
  </tr> 
  <tr> 
   <td>数据安全性</td> 
   <td>丢数据</td> 
   <td>根据策略决定</td> 
  </tr> 
 </tbody> 
</table>

**如何选择使用哪种持久化方式？**

一般来说， 如果想达到足以媲美 PostgreSQL 的数据安全性， 你应该同时使用两种持久化功能。

如果你非常关心你的数据， 但仍然可以承受数分钟以内的数据丢失， 那么你可以只使用 RDB 持久化。

有很多用户都只使用 AOF 持久化， 但并不推荐这种方式： 因为定时生成 RDB 快照（snapshot）非常便于进行数据库备份， 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快。

**扩展**

1、rdb持久化方式能够在指定的时间间隔内对数据进行快照存储
    2、aof持久化方式记录每次对服务器写的操作，服务器重启时，重新执行命令来恢复原始数据，追加在文件末尾，能对aof文件进行重写，避免体积过大
    3、如果只做缓存不需要使用任何持久化
    4、同时开启两种持计划方式
    	重启时优先载入aof文件来恢复数据
    	只会找aof文件，但是推荐只使用rdb用于备份，能快速重启，并且不会有aof可能潜在的bug	
    5、性能建议
    	5.1、rdb文件只做后背用途，建议只在slave上持久化rdb文件，15分钟备份一次，使用save 900 1 规则
    	5.2、使用aof，即便在最恶劣的环境下也不会丢失超过2秒的数据
    			代价：持续的io
    			rewrite 过程中产生的新数据写到新文件造成的阻塞不可避免，尽量减少rewrite的频率
    	5.3、不使用aof，也可以通过Master-Slave Replication 实现高可用性也可以，能省去一大笔io，减少rewrite带来的		系统波动
    			代价：如果Master-Slave 同时倒掉，回丢失十几分钟的数据，启动脚本也要比较Master-Slave中的rdb文件，					选择最新的文件，载入新的，微博就是这种架构

### 十、Redis发布订阅 ###

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

![1641213955677][]

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

![1641214025134][]

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

![1641214076100][]

#### 一、命令 ####

这些命令被广泛应用于构建即使通信时使用，比如网络聊天室（Chatroom）和实时广播、实时提醒等。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LUbmpmYg-1679539496804)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1641214166323.png)\]

#### 二、测试 ####

（端口一）（订阅端）启动redis服务，并订阅一个频道

![1641214971658][]

（端口二）（发送端）另起端口二，将消息发送到指定的频道

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nP0RtiQE-1679539496805)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1641215021067.png)\]

（端口一）返回端口一，同步消息发送接受消息

![1641215048381][]

#### 三、原理 ####

每个 Redis 服务器进程都维持着一个表示服务器状态的 redis.h/redisServer 结构， 结构的 pubsub\_channels 属性是一个字典， 这个字典就用于保存订阅频道的信息，其中，字典的键为正在被订阅的频道， 而字典的值则是一个链表， 链表中保存了所有订阅这个频道的客户端。

![1641215428786][]

客户端订阅，就被链接到对应频道的链表的尾部，退订则就是将客户端节点从链表中移除。

缺点  
如果一个客户端订阅了频道，但自己读取消息的速度却不够快的话，那么不断积压的消息会使redis输出缓冲区的体积变得越来越大，这可能使得redis本身的速度变慢，甚至直接崩溃。  
这和数据传输可靠性有关，如果在订阅方断线，那么他将会丢失所有在短线期间发布者发布的消息。

应用  
消息订阅：公众号订阅，微博关注等等（起始更多是使用消息队列来进行实现）  
多人在线聊天室。

### 十一、主从复制 ###

#### 一、概念 ####

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点（Master/Leader）,后者称为从节点（Slave/Follower）， 数据的复制是单向的！只能由主节点复制到从节点（主节点以写为主、从节点以读为主）。

默认情况下，每台Redis服务器都是主节点，一个主节点可以有0个或者多个从节点，但每个从节点只能由一个主节点。

#### 二、作用 ####

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余的方式。  
故障恢复：当主节点故障时，从节点可以暂时替代主节点提供服务，是一种服务冗余的方式  
负载均衡：在主从复制的基础上，配合读写分离，由主节点进行写操作，从节点进行读操作，分担服务器的负载；尤其是在多读少写的场景下，通过多个从节点分担负载，提高并发量。  
高可用基石：主从复制还是哨兵和集群能够实施的基础。

#### 三、为什么使用集群 ####

从结构上讲，单个redis服务器会发生单点故障，一台服务器需要处理所有请求，压力大  
从容量上讲，单个redis服务器内存容量有限，并且不能完全使用全部的内存，单台redis的最大内存不应该超过20g压力过大。

*  单台服务器难以负载大量的请求。
 *  单台服务器故障率高，系统崩坏概率大。
 *  单台服务器内存容量有限。

通常的电商网站都是一次上传吗，无数次浏览，读多写少 ，主从复制，读写分离，80%的情况都在进行读操作，起码一主二从。

![1641215999299][]

#### 四、环境配置（至少需要三个端口） ####

只配置从库，不需要配置主库。

##### 一、(端口1)查看当前信息和复制多个redis.conf #####

127.0.0.1:6379> info replication		#查看当前信息
    # Replication
    role:master
    connected_slaves:0
    master_failover_state:no-failover
    master_replid:e256be26bd8b7520a8f50ecda6aeba1936768807
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:0
    second_repl_offset:-1
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0
    127.0.0.1:6379> shutdown			#关闭redis服务
    not connected> exit					#退出
    [root@Jin bin]# cd Jinconfig/		#配置多个redis.conf和修改其中的配置端口
    [root@Jin Jinconfig]# ls
    redis.conf
    [root@Jin Jinconfig]# cp redis.conf redis79.conf
    [root@Jin Jinconfig]# cp redis.conf redis80.conf
    [root@Jin Jinconfig]# cp redis.conf redis81.conf
    [root@Jin Jinconfig]# ls
    redis79.conf  redis80.conf  redis81.conf  redis.conf
    [root@Jin Jinconfig]# vim redis79.conf 
    [root@Jin Jinconfig]# vim redis80.conf 
    [root@Jin Jinconfig]# vim redis81.conf

##### 二、修改多个配置文件 #####

既然需要启动多个服务，就需要多个配置文件。每个配置文件对应修改以下信息：

*  端口号(port)
 *  pid文件名(pidfile)
 *  日志文件名(logfile)
 *  rdb文件名(dbfilename)

（端口1）配置多个redis.conf和修改其中的配置端口

0、vim redis79.conf  vim redis80.conf  vim redis81.conf 
    1、port 6379 -->port 6379  port 6380  port 6381
    2、pidfile /var/run/redis_6379.pid -->
       pidfile /var/run/redis_6379.pid
       pidfile /var/run/redis_6380.pid
       pidfile /var/run/redis_6381.pid
    3、logfile "" -->
       logfile "6379.log"
       logfile "6380.log"
       logfile "6381.log"
    4、dbfilename dump.rdb -->
       dbfilename dump6379.rdb
       dbfilename dump6380.rdb
       dbfilename dump6381.rdb

##### 三、启动单机多服务集群 #####

(端口1)启动端口1

![1641260093562][]

（端口2）启动端口2

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xf2GN6rM-1679539496807)(https://gitee.com/happy\_sad/typora-image/raw/master/images/1641260148832.png)\]

（端口3）启动端口3

![1641260262385][]

（端口4）测试是否启动成功

![1641260362734][]

#### 五、一主二从 ####

##### 一、确认端口开放 #####

首先打开阿里云的安全组（6379-6381）

![1641260948835][]

宝塔面板安全里放行端口6380-6381

![1641261059632][]

##### 二、默认情况下，每台Redis服务器都是主节点 #####

（端口1）

![1641260729222][]

（端口2）

![1641261150590][]

（端口3）

![1641261232735][]

##### 三、主机不配，配从机（任选主机） #####

1、我们一般情况下只用配置从机就好了！认老大！一主（6379）二从（6380，6381）

2、使用==`SLAVEOF host port`==就可以为从机配置主机了。

3、\#先端口1、2、3进行clear清屏

（端口2）slaveof 主机地址 端口号

![1641261693435][]

（端口3）slaveof 主机地址 端口号

![1641261860831][]

（端口1）返回端口1查看配置

![1641261952676][]

注意： 我们这里是使用命令搭建，是暂时的，==真实开发中应该在从机的配置文件中进行配置，==这样的话是永久的。

![1641262509082][]

##### 四、测试 #####

（端口1）主机可写可读

![1641262825382][]

（端口2）从机只可读不可写

![1641262873910][]

##### 五、使用规则 #####

1.  从机只能读，不能写，主机可读可写但是多用于写。
2.  当主机断电宕机后，默认情况下从机的角色不会发生变化 ，还是可以读取数据，集群中只是失去了写操作，当主机恢复以后，又会连接上从机恢复原状。
3.  当从机断电宕机后，若不是使用配置文件配置的从机，再次启动后作为主机是无法获取之前主机的数据的，若此时重新配置为其从机，又可以获取到主机的所有数据。这里就要提到一个同步原理。
4.  第二条中提到，默认情况下，主机故障后，不会出现新的主机，有两种方式可以产生新的主机：
    
     *  从机手动执行命令==`slaveof no one`,这样执行以后从机会独立出来成为一个主机，其他从机也是手动执行命令`slaveof 主机host 端口号`==连接这个主节点。
     *  使用哨兵模式（自动选举）
5.  注： 1、主机崩溃，从机是否还能读取 ： 从机能读取，还是不能写 ，希望改进为从slave中选出一个master 。
    
    2、从机崩溃，主机继续写入数据，从机恢复，能否get到恢复时段主机读取的值，分两两种情况 ：
    
    ·没在redis.conf中设置的slave， 读取不到崩溃时master set的数据 。
    
    ·在 redis.conf中配置的slave，能读取到 。
    
    ·只要变为从机就会立马从主机中获取值 。

##### 六、复制原理 #####

1、slave启动成功连接到master后会发送一个sync同步命令  
2、master接到命令，启动后台的存盘进程，同时收集所接收到的用于修改数据集命令，后台执行完毕之后，master将传送整个数据文件到slave，并完成一次同步，成为增量复制  
3、专有名词  
全量复制  
slave服务在接受到数据库文件数据后，将其存盘并加载到内存中  
增量复制  
master继续将新的所有收集到的修改命令依次传给slave，完成同步  
4、只要重新连接master，一次完全同步（全量复制）将被自动执行，数据一定能在从机中看到

##### 七、结构 #####

*  两种结构，星型结构，链式结构
 *  链式结构的slave81 点master设置为slave 80 ，实现的功能也是一样，当master 79 崩溃，slave 80也不会变成master，依旧是slave 80，但是info replication信息里有slave 81的配置。

![1641264290663][]

### 十二、哨兵模式 ###

#### 一、概念 ####

**主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式**， redis2.8 开始正确提供sentinel（哨兵 ） 。

哨兵模式：能够监控后台的主机是否故障，**根据投票自动将从库专为主库**。哨兵模式是一种特殊模式，哨兵是一个独立的进程，作为进程独立运行，原理是哨兵通过发送命令，等待redis服务器响应，从而监控多个redis实例。

#### 二、哨兵的作用 ####

*  通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
 *  当哨兵监测到master宕机，会自动将slave切换成master，然后通过**发布订阅模式**通知其他的从服务器，修改配置文件，让它们切换主机。

##### 一、单及哨兵模式 #####

单机哨兵模式：当单个哨兵也宕机也会有风险，创建多个哨兵是个不错的选择，称为多哨兵模式。

![1641265784351][]

##### 二、多哨兵模式 #####

多哨兵模式：假设master宕机，sentinel先检测到这个结果，系统并不会马上进行failover（故障切换、失效备援）这个现象称为主观下线，当后面的哨兵也检测到主服务器不可用，sentinel之间会发起一次投票，投票的结果由随机一个sentinel发起，进行failover操作，得到sentinel票数多的slave能成功切换为master，切换成功后，通过发布订阅模式，让各个哨兵把自己监控的服务器实现切换主机，这个过程称为客观下线。

![1641266408771][]

#### 三、测试 ####

1、配置哨兵的配置文件sentinel.conf

![1641267415828][]

sentinel monitor 被监控的名称 host port 1

最后面的1代表主机挂了，slave投票看让谁接替主机，票数最多，就会成为主机。

sentinel monitor <master-name> <ip> <redis-port> <quorum>
    
    #quorum（法定人数）至少需要<quorum>个哨兵同意的情况下，能确定处于客观关闭状态
    
    #(Objectively Down) state only if at least <quorum> sentinels agree.

![1641267534633][]

2、启动哨兵

redis-sentinel Jinconfig/sentinel.conf

![1641267903454][]

*  默认端口为26379，默认pid为69427
 *  当master 79 宕机，sentinel选举了81为newmaster
 *  master节点断开，这时候从slave中选择一个座位master，其中有投票算法，自行了解
 *  当79重新启动后，是以80作为master的slave role存在

![1641268776171][]

#### 四、哨兵模式优缺点 ####

优点

1、基于集群，基于主从复制，所有的主从配置的优点，它全有
    2、主从可以切换，故障可以切换，系统的可用性提高
    3、哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点

1、redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦
    2、哨兵模式需要很多配置，选择过多
    3、多哨兵，多端口配置复杂，一般由运维来配置

#### 五、完整的哨兵模式配置 ####

# Example sentinel.conf
     
    # 哨兵sentinel实例运行的端口 默认26379
    port 26379
     
    # 哨兵sentinel的工作目录
    dir /tmp
     
    # 哨兵sentinel监控的redis主节点的 ip port 
    # master-name  可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
    # quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
    # sentinel monitor <master-name> <ip> <redis-port> <quorum>
    sentinel monitor mymaster 127.0.0.1 6379 1
     
    # 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
    # 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
    # sentinel auth-pass <master-name> <password>
    sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
     
     
    # 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
    # sentinel down-after-milliseconds <master-name> <milliseconds>
    sentinel down-after-milliseconds mymaster 30000
     
    # 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，
    这个数字越小，完成failover所需的时间就越长，
    但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。
    可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
    # sentinel parallel-syncs <master-name> <numslaves>
    sentinel parallel-syncs mymaster 1
     
     
     
    # 故障转移的超时时间 failover-timeout 可以用在以下这些方面： 
    #1. 同一个sentinel对同一个master两次failover之间的间隔时间。
    #2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
    #3.当想要取消一个正在进行的failover所需要的时间。  
    #4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
    # 默认三分钟
    # sentinel failover-timeout <master-name> <milliseconds>
    sentinel failover-timeout mymaster 180000
     
    # SCRIPTS EXECUTION
     
    #配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
    #对于脚本的运行结果有以下规则：
    #若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
    #若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
    #如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
    #一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
     
    #通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，
    #这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，
    #一个是事件的类型，
    #一个是事件的描述。
    #如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
    #通知脚本
    # sentinel notification-script <master-name> <script-path>
      sentinel notification-script mymaster /var/redis/notify.sh
     
    # 客户端重新配置主节点参数脚本
    # 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
    # 以下参数将会在调用脚本时传给脚本:
    # <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
    # 目前<state>总是“failover”,
    # <role>是“leader”或者“observer”中的一个。 
    # 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
    # 这个脚本应该是通用的，能被多次调用，不是针对性的。
    # sentinel client-reconfig-script <master-name> <script-path>
    sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

### 十三、缓存穿透、击穿、雪崩 ###

都是服务的三高问题

*  高并发
 *  高可用
 *  高性能

redis缓存的使用极大的提升了应用程序的性能和效率，特别是数据查询方面，但同时，它也带来了一些问题，数据一致性问题，严格意义上来讲，问题无解，对一致性要求极高，不推荐使用缓存。

布隆过滤器、缓存空对象

#### 一、缓存穿透(查不到) ####

在默认情况下，用户请求数据时，会先在缓存(Redis)中查找，若没找到即缓存未命中，再在数据库中进行查找，数量少可能问题不大，可是一旦大量的请求数据（例如秒杀场景）缓存都没有命中的话，就会全部转移到数据库上，造成数据库极大的压力，就有可能导致数据库崩溃。网络安全中也有人恶意使用这种手段进行攻击被称为洪水攻击。

##### 布隆过滤器 #####

*  布隆过滤器是一种数据结构，对所有可能的查询参数以hash形式存储，在控制层进行校验，不符合则丢弃，从而避免了对底层存储系统查询压力

![1641273370152][]

##### 缓存空对象 #####

*  当持久化层不命中后，将返回的空对象存储起来，同时设置一个过期时间，之后再访问这个数据就从缓存中获取，保护持久层数据源
 *  一次请求若在缓存和数据库中都没找到，就在缓存中方一个空对象用于处理后续这个请求。

![1641273405163][]

*  需要面临的问题
    
     *  存储空的key也需要空间, 大量的空对象会耗费一定的空间，存储效率并不高。解决这个缺陷的方式就是设置较短过期时间
     *  对空值设置了过期时间，还会存在缓存层和存储层的数据有一段时间窗口不一致，对于需要保持一致性的业务会有影响

#### 二、缓存击穿（查太多，量太大，缓存过期） ####

例子微博服务器热搜，巨大访问量访问同一个key
    
    一个key非常热点，不停扛着大并发，集中对一个点进行访问，当个key失效的瞬间，持续大并发导致穿破缓存，直接请求数据库。某个key在过期的瞬间，大量的访问会同时访问数据库来查询最新的数据，并且回写缓存，导致数据库瞬间压力过大

解决方案

*  设置热点数据不过期
    
     *  一直缓存也会浪费空间
 *  加互斥锁
    
     *  分布式锁：使用分布式锁，保证对于每个key同时只有一个线程查询后端服务，其他线程没有获得分布式锁的权限，只需要等 待即可，这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大

#### 三、缓存雪崩 ####

在某一个时间段，缓存集中过期失效，redis宕机
    
    产生雪崩的原因之一，设置缓存的存活时间较短，大并发访问时刚好都过期，直接访问了数据库，对数据库而言，会产生周期性压力波峰，暴增时数据库可能会宕机
    
    双十一时会停掉一些服务，保证主要的一些服务可用，springcloud中说明过

![1641273536729][]

解决方案：

*  redis高可用、增加集群中服务器数量
    
     *  异地多活，这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。
 *  限流降级
    
     *  缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量，对某个key只允许一个线程查询数据和写缓存，其他线程等待。
 *  数据预热
    
     *  正式部署之前，把可能的数据提前访问一遍，可能大量访问的数据就会加载到缓存中，加载不同的key，设置不同的过期时间，让缓存时间尽量均匀。

[KuangStudy]: https://www.kuangstudy.com/course
[Redis]: https://www.bilibili.com/video/BV1S54y1R7SB/?p=1
[1640596516728]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d5143ed10e604ac396dd4a239da74b45.png
[1640597548690]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/67258565873f40c091629a1f7a84a049.png
[1640598325081]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7d4ae610b5164e618266b0138ccac231.png
[1640599170445]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/64e6cac536004276ba67ccf5136545e6.png
[1640658307465]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a8c750e2c620442aa383caec5fc95840.png
[1640668419781]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/586c6988ba854504bf4a5d08b79772bc.png
[1640671079919]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b343208f855f4cbd8f253e47ec5913a7.png
[1640670817326]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0b95bb88b040446b92a2c6ed6d831f47.png
[1640677332349]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0dbb60d6d94e45ae869945b7908572c8.png
[1640677824044]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/32d2d9235b5b45b38260ae5e5e3c73d6.png
[1640677988447]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8b3dc29ae6d64895b11a8aae424632e0.png
[1640678134043]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ed49e503505f4f7e94ebce177819f760.png
[1640678520553]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ce3a744ffddd412d96c836ef499b1204.png
[1640678581333]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/db50d68ce34d4d66a830e82fbbec4dd5.png
[1640678917371]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/cf35804d98224430907290265b1cc83f.png
[1640679155606]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/79e23646e6d04d7fbb8f91bb217b6b2d.png
[1640679506711]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/46d18bbd16ba4c699b8d4dbcbd2cb7e4.png
[1640679627567]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e2248dfc6989413fb7baf74c7f8fa95d.png
[1640679790581]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b01af5bb04554d6e92168a2f89848d5c.png
[1640679978542]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bcbcd93fa1b748f79981a8984a6366d8.png
[1640680220700]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bf42fe19a36947b39d5d3838d3fef52e.png
[1640680319790]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4dd000d774da4f68be115c99c0fd4a56.png
[1640680742473]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e37d2b258b6b4c84b8753089b14a591d.png
[1640681422643]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bd00378cb8f54091b6fb447d6c832b4b.png
[1640681680042]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/12add9caba564e74881f19d0c3a4b653.png
[1640681999084]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0a9613fee0c34f00b422544d017e0fee.png
[1640682258014]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/996363060f4e49499c5dd6b299875871.png
[1640682323301]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b3b7e0f2d4214e93bafea818e4f3c7fe.png
[1640682475962]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1fb8b86e48b7407eaaaecfdd5a0ffb58.png
[1640682692716]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/80419258775a4d62a49367c67f6f5850.png
[1640682820674]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6f75c45513834291b6dc8bc7255cb49c.png
[1640682906473]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/95fe7c82d3934afc85f1af57d9d7f421.png
[1640684116954]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/1dfe8b49db4d4bde9476bbe679c29b61.png
[1640684139562]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/8ca98cdd24f6491db19e18693e566afa.png
[1640684585662]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a593131097f046a8978b7d9c9e80ec34.png
[1640684605216]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/145000f1ebef40c0bb7001ec98cacf84.png
[1640742550009]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0dbb44baa63640f18a7de4dd4de420c8.png
[1640756580614]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/80695fe9956c4e3291d6ae17353a6570.png
[1640756308838]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5794f70fec99415893f4f95118654c37.png
[1640756679859]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/db784b9771a14ea39f55dc52335ae8ae.png
[1640756845540]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f167c6be95564febaa9f3a36e991d698.png
[1640759748303]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/17b7904eddb14abcb378c52d660e25c2.png
[1640759763770]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fed10b0b685045f8bb99c06ed5b7deab.png
[1640761559299]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/bb745817db364428bc936a6a30072bc2.png
[1640762764253]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f3afda7ccdf6466e933288a8f32a36ac.png
[1640788659152]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7c5854ec0c51405eb26ddc3c4b19fbe7.png
[1640788792588]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4f8e25b53d1043b6b444d8d74d886978.png
[1640788916651]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0e03518414704480b5afdf84e585709b.png
[1640789818104]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f7385fe099be466c9d307b9a9fc2194c.png
[1640914846906]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/2ad19d516d6f4fc3ac92ddef90eb4520.png
[1640915245113]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/cda3ec3c715a4cee9c1abd4658c96269.png
[1640916406886]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7a486bd3a9e348a4a94a1fb20e051159.png
[1640928835433]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3cc7c01927d44915843a1f11eb0b6bea.png
[1640931012440]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/187d99fef09b4ee8a0d1bd92454c7313.png
[1640933193697]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/16a407d8219c4a7a85a7d1c4f9fb17e8.png
[1640935900223]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/9c4fac8e7f9249a7b0595780b66a141b.png
[1640943756162]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0bf4a7af9d7940cd9bb1721fd6c83cdb.png
[1641213955677]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/42fe4bf4e0534d43b03c554c34569af1.png
[1641214025134]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/325a141b071c442ba56f465118c264f8.png
[1641214076100]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/93998cadc27b46e1847376ffd8812406.png
[1641214971658]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6f1a4fa619984de389f02c1c57d2d46f.png
[1641215048381]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/5e834c57d652463680eeda9a0ceb4761.png
[1641215428786]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/26b030d4df5e4dcd82bc6b783c0ca084.png
[1641215999299]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/ddd7fced4e1a47dfb52c5bf8bf0dc8c2.png
[1641260093562]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b329b51739ae459e96be5aacd7d65a7d.png
[1641260262385]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b6260cd431f04dd1a7803334303a505d.png
[1641260362734]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f81d93f332f74084a39be5ba57d2d7f2.png
[1641260948835]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/7a794a3851ba4d7aa8930709f28d7555.png
[1641261059632]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c40055bd4e194467b960f11019a0a743.png
[1641260729222]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d0af749117c141f7a6efc7e93c8f8ef7.png
[1641261150590]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f83819d433a54d049fc489b59b48ab3c.png
[1641261232735]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0472497ff84e4d079fcde40c87b08735.png
[1641261693435]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b8b5523dbb4e40a79ed360daf8bf888b.png
[1641261860831]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/71cda4555c264e8d89fb05b2cf75e385.png
[1641261952676]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/052a9b9cf9264c82b320b2cae3afee2e.png
[1641262509082]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/4abd8e58b53e4293adb5b852f2eabbb6.png
[1641262825382]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/f864a75e8bf1409e8143ece17bfb6200.png
[1641262873910]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/453b3eae04d04db69dc2d6071bdfca30.png
[1641264290663]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/fb09532800c54a9ab125b375288d1f8c.png
[1641265784351]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/c397cc3368934fb1a507140ed9bb054e.png
[1641266408771]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/6ad3725865434b67836f18fffd0fda40.png
[1641267415828]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/90303eed28be47d88544dc7bf5e60a14.png
[1641267534633]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/d2f03062da8b46e7959e1a7d00546fa6.png
[1641267903454]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/26d99dc748754f448b11074d0c9d9cbd.png
[1641268776171]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/53144684f6b54b289a2e6109061df231.png
[1641273370152]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/887e5692fbf9406bb180517c61d221b8.png
[1641273405163]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/3799276f139b40cd9002b1aa388b08ea.png
[1641273536729]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0f4c6bcc39044982a059d37672ad26ef.png