Redis知识总结[一]

---

Redis安装及基本操作

• 获取安装包
  https://pan.baidu.com/s/12hqZ1Y6ZKONoyqiRFo8BMg
  提取码：afav
• 将安装包上传至linux，依次执行下面命令

//解压
tar -zxvf redis-6.2.4.tar.gz
//安装C语言编译环境
dnf group install "Development Tools"
//验证 GCC 编译器是否被成功安装
gcc --version
//编译Redis，在redis-6.2.4目录下执行
make
//安装Redis，在redis-6.2.4目录下执行
make install

• 安装目录： /usr/local/bin
  

redis-benchmark：Redis自带的基准性能测试工具
redis-check-aof：对有问题的 AOF 文件进行修复
redis-check-rdb：对有问题的 RDB文件进行修复
redis-sentinel：Redis集群使用
redis-cli：客户端
redis-server：服务器启动

• redis服务端启动

一、前台启动：在/usr/local/bin下执行
./redis-server

二、后台启动：
1.拷贝redis-6.2.4目录中的redis.conf文件到其他目录
mkdir /usr/local/myredis
cp redis.conf /usr/local/myredis/redis.conf
2.设置/usr/local/myredis/redis.conf文件中的daemonize属性，由no改为yes
3.在/usr/local/bin下执行
./redis-server /usr/local/myredis/redis.conf

• redis客户端启动

/usr/local/bin下执行
./redis-cli

Redis数据类型

key键

• 查看当前库中所有的key

keys *

• 判断某个key是否存在

exists key

• 将当前数据库的key移动到给定的数据库db当中

move key db

例如 ：move k1 8 是将k1从当前数据库移动到8号数据库中

• 查看当前key所存储的值的类型

type key

• 删除已存在的key

del key

• 给key设置time秒的过期时间

expire key time

设置成功返回1，当 key 不存在返回 0

五大数据类型

String(字符串)

• 设置给定 key 的值，如果key已经存储其他值set会将其覆盖

set key value

• 获取指定key的值。如果key不存在，返回 nil

get key

• 将给定的value追加到key原值末尾。

如果 key 已经存在并且是一个字符串， append 命令将 value 追加到 key 原来的值的末尾。
如果 key 不存在， append 就简单地将给定 key 设为 value ，就像执行 set key value 一样。

append key value

• 获取指定 key 所储存的字符串值的长度。

strlen key

• 给指定的 key 设置值及time 秒的过期时间。

如果key已经存在， setex命令将会替换旧的值，并设置过期时间。

setex key time value

• 向指定key设置值

当key不存在时，设置给定key的值。如果key存在，则没有任何影响。

setnx key value

• 将 key 中储存的数字值增一。

如果key不存在，那么key的值会先被初始化为0，然后再执行incr操作。
如字符串类型的值不能表示为数字、或者是其他类型，那么返回一个错误。

incr key

• 将 key 中储存的数字值减一。(规则与增一类似)

decr key

• 将key存储的数字值按照step进行增减。

如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 incrby/decrby 命令。
如字符串类型的值不能表示为数字、或者是其他类型，那么返回一个错误。

incrby/decrby key step

• 同时设置一个或多个 key-value 。

mset key1 value1 key2 value2 ……

• 返回一个或多个给定 key 的值。

mget k1 k2 

• 所有给定key都不存在时，同时设置一个或多个key-value。

msetnx具有原子性特性，有一个失败，则都失败。

msetnx key1 value1 key2 value2 ……

• 获取存储在指定 key 中字符串的子字符串。

字符串的截取范围由start 和 end 两个偏移量决定(包括 start 和 end 在内)。起始索引为0。

getrange key start end

• 用指定的字符串重写给定 key 所储存的字符串值，重写的位置从偏移量 offset 开始。起始位置索引为0。

setrange key offset value

List(列表)

List是简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）。

• 从左边（头部）/右边（尾部）插入一个或多个值。

 lpush/ rpush key1 value1 value2 value3……

• 返回key列表中的start和end之间的元素（包含start和end）。

0 表示列表的第一个元素，-1表示最后一个元素。

 lrange key start end

• 移除并返回第一个值/最后一个值。

lpop/rpop key

• 获取列表index位置的值（从左开始）。

 lindex key index

• 获取列表长度。

llen key

• 从左边开始删除与value相同的count个元素。

 lrem key count value

• 在列表中value值的前边/后边插入一个newvalue值(从左开始)。

linsert key before/after value newvalue

• 将索引为index的值设置为value

 lset key index value

set(集合)

Set中不允许出现重复的元素。

• 将一个或多个元素添加到集合中，已经存在的元素将被忽略。

 sadd key value1 value2……

• 取出该集合的所有元素。

smembers key

• 判断集合key中是否含有value元素，如有返回1，否则返回0。

sismember k1 v1

• 返回该集合的元素个数。

scard key

• 删除集合中一个或多个元素，不存在的元素会被忽略。

srem key value1 value2……

• 随机删除集合中一个元素并返回该元素。

spop key

• 随机取出集合中count个元素，但不会删除。

srandmember key count

• 将value元素从sourcekey集合移动到destinationkey集合中。

如果 sourcekey集合不存在或不包含指定的 value元素，则 smove 命令不执行任何操作，仅返回 0。

smove sourcekey destinationkey value

• 返回两个集合的交集元素。

 sinter key1 key2

• 返回两个集合的并集元素。

 sunion key1 key2

• 返回两个集合的差集元素（key1中的，不包含key2）

 sdiff key1 key2

Hash(哈希)

• 给key集合中的field赋值value。

hset key field value

• 从key哈希中，取出field字段的值。

hget key field

• 批量设置哈希的字段及值。

hmset key field1 value1 field2 value2……

• 判断指定key中是否存在field

hexists key field

• 获取该哈希中所有的field。

 hkeys key

• 获取该哈希中所有的value。

hvals key

• 为哈希表key中的field字段的值加上增量increment。

增量也可以为负数，相当于对指定字段进行减法操作。
如果哈希表的 key 不存在，一个新的哈希表被创建并执行 hincrby 命令。
如果指定的字段不存在，那么在执行命令前，字段的值被初始化为0。

hincrby key field increment

• 删除哈希表 key 中的一个或多个指定字段，不存在的字段将被忽略。

hdel key field1 field2……

• 给key哈希表中不存在的的字段赋值 。

如果哈希表不存在，一个新的哈希表被创建并进行 hsetnx 操作。
如果字段已经存在于哈希表中，操作无效。
如果 key 不存在，一个新哈希表被创建并执行 hsetnx 命令。

 hsetnx key field value

Zset(有序集合)

1.Zset与Set非常相似，是一个没有重复元素的String集合。
2.不同之处是Zset的每个元素都关联了一个分数（score），这个分数被用来按照从低分到高分的方式排序集合中的元素。集合的元素是唯一的，但分数可以重复。
3.因为元素是有序的，所以可以根据分数（score）或者次序（position）来获取一个范围内的元素。

• 将一个或多个元素（value）及分数（score）加入到有序集key中。

如果存在，直接覆盖

zadd key score1 value1 score2 value2……

• 返回key集合中的索引start和索引end之间的元素（包含start和end）。

其中元素的位置按分数值递增(从小到大)来排序。 其中 0 表示列表的第一个元素，-1表示最后一个元素。
withscores是可选参数，是否返回分数。

zrange key start end [withscores]

• 返回key集合中的分数minscore 和分数maxscore 之间的元素（包含minscore 和maxscore ）。其中元素的位置按分数值递增。

zrangebyscore key minscore maxscore [withscores]

• 返回key集合中的分数maxscore和分数minxscore 之间的元素（包含maxscore和minxscore ）。其中元素的位置按分数值递减。

zrevrangebyscore key maxscore minscore [withscores]

• 为元素value的score加上increment的值。

zincrby key increment value

zincrby k1 50 java 给java元素加上50分

• 删除该集合下value的元素。

zrem key value

• 统计该集合在minscore 到maxscore分数区间中元素的个数。

 zcount key minscore maxscore

• 返回value在集合中的排名，从0开始。

zrank key value

新数据类型

Bitmaps

Redis提供了Bitmaps这个 “数据结构” 可以实现对位的操作：

1. Bitmaps 本身不是一种数据结构，实际上它就是字符串（key 对应的 value 就是上图中的一串二进制），但是它可以对字符串的位进行操作。
2. Bitmaps 单独提供了一套命令，所以在 Redis 中使用 Bitmaps 和使用字符串的方法不太相同。可以把 Bitmaps 想象成一个以位为单位的数组，数组的每个单元只能存储 0 和 1，数组的下标在Bitmaps中叫做偏移量。
   

• 设置Bitmaps中某个偏移量的值。

偏移量从0开始，且value值只能为0或1。

setbit key offset value

• 获取Bitmaps中某个偏移量的值。

如果偏移量未设置值，则也返回0。

获取key的offset 的值。

• 统计字符串被设置为1的bit数量。

bitcount key [start end]

• 将多个bitmaps通过求交集/并集方式合并成一个新的bitmaps。

bitop and/or destkey sourcekey1 sourcekey2……

Geospatia

该类型就是元素的二维坐标，在地图上就是经纬度。Redis基于该类型，提供了经纬度设置、查询、范围查询、距离查询、经纬度Hash等常见操作。

• 用于存储指定的地理空间位置，可以将一个或多个经度(longitude)、纬度(latitude)、位置名称(member)添加到指定的 key 中。

geoadd key longitude latitude member [longitude latitude member ..……]

//将北京的经纬度和名称添加到chinacity
geoadd chinacity 116.405285 39.904989 beijing 
//将成都和上海的经纬度、名称添加到chinacity
geoadd chinacity 104.065735 30.659462 chengdu 121.472644 31.231706 shanghai

• 从给定的 key 里返回所有指定名称(member)的位置（经度
  和纬度），不存在的返回 nil。

geopos key member [member ……]

//返回chinacity中名称为shanghai和beijing的经纬度
geopos chinacity shanghai beijing

• 用于返回两个给定位置之间的距离。

geodist key member1 member2 [m|km|ft|mi]

• 以给定的经纬度（longitudelatitude）为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离（radius ）的所有位置元素。

georadius key longitude latitude radius m|km|ft|mi 

//获取经纬度116 40为中心，在chinacity内1200公里范围内的所有元素。
georadius chinacity 116 40 1200 km

Hyperloglog

什么是基数？
数据集｛1，2，5，7，5，7，9｝，那么这个数据集的基数集为｛1，2，5，7，9｝，基数（不重复元素）为5，基数估计就是在误差可接受范围内，快速计算基数。

• 将所有元素参数添加到 Hyperloglog 数据结构中。

pfadd key element1 element2……

//添加两个元素，当前book1数量为2
pfadd book1 java c++
//添加一个元素，当前book1数量为3
pfadd book1 java php

• 计算Hyperloglog 近似基数，可以计算多个Hyperloglog ，统计基数总数。

 pfcount key1 key2……

//计算book1的基数，结果为3
pfcount book1
//添加两个元素到book2中
pfadd book2 chinese math
//统计两个key的基数总数，结果为5
pfcount book1 book2

• 将一个或多个Hyperloglog（sourcekey1）合并成一个Hyperloglog （destkey ）。

pfmerge destkey sourcekey1 sourcekey2……

//将book1和book2合并成book，结果为5
pfmerge book book1 book2

Redis配置文件详解

• bind：绑定redis服务器网卡IP，默认为127.0.0.1,即本地回环地址。访问redis服务只能通过本机的客户端连接，而无法通过远程连接。如果bind选项为空的话，那会接受所有来自于可用网络接口的连接。
  
• protected-mode：本机保护模式，值为yes时只能本机访问不能远程访问。
  
• port：指定redis运行的端口，默认是6379。
• timeout：设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接。默认值为0，表示不关闭。
• daemonize：设置为yes表示指定Redis以守护进程的方式启动（后台启动）。
  
• pidfile：配置PID文件路径，当redis作为守护进程运行时，它会把 pid 默认写到/var/redis/run/redis_6379.pid 文件里面。
• databases：设置数据库的数目。

Redis发布与订阅

一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。Redis 客户端可以订阅任意数量的频道。

• 订阅频道channel。

subscribe channel 

• 向频道channel 发送一条msg消息。

publish channel msg

• 演示：

订阅channel1以及channel2

向channel1发送消息

订阅channel1的客户端接收到消息

Redis持久化

由于Redis的数据都存放在内存中，如果没有配置持久化，Redis重启后数据就全丢失了，于是需要开启Redis的持久化功能，将数据保存到磁盘上，当Redis重启后，可以从磁盘中恢复数据。

持久化操作-RDB

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

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。

dump.rdb文件

• RDB保存的文件，在redis.conf中配置文件名称，默认为dump.rdb。
  

• rdb文件的保存位置，也可以修改。默认在Redis启动时命令行所在的目录下。
  

• 可以在redis.conf文件中配置路径
  

自动触发快照

• 修改配置文件
  

1. save 3600 1：表示3600秒内如果至少有1个key的值变化，则保存
2. save 300 100：表示300秒内如果至少有100个key 的值变化，则保存
3. save 60 10000：表示60秒内如果至少有10000个key的值变化，则保存
4. save 30 5：表示30秒内如果至少5个key的值发生变化，则保存

• 配置修改后，需要重启Redis服务。

自动触发快照测试

• 启动redis服务，并一次性添加6个key，然后关闭redis服务
  
• 重新启动之后仍然可以获取到值
  

手动触发快照

//手动触发Redis进行RDB持久化的命令有两种：(在客户端执行)

//该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令
save
//执行该命令时，Redis会在后台异步进行快照操作，同时还可以响应客户端请求。
bgsave

配置介绍

• stop-writes-on-bgsave-error：默认值是yes。当Redis无法写入磁盘的话，直接关闭Redis的写操作。
• rdbcompression：默认值是yes。对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，可以减小文件大小，但会消耗性能。
• rdbchecksum：默认值是yes。在存储快照后，我们还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加性能消耗。

持久化操作-AOF

以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来，只允许加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据。

AOF持久化流程

• 客户端的请求写命令会被append追加到AOF缓冲区内。
• AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作同步到磁盘的AOF文件中。
• AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量。
• Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的。

appendonly.aof

• 保存aof命令的文件，默认名叫appendonly.aof
• 在配置文件中将appendonly no—>修改为yes即开启aof
  

AOF启动/修复/恢复

• 正常启动:

1. 启动：设置Yes：修改默认的appendonly no，改为yes。
2. 恢复：重启Redis然后重新加载。

• 异常恢复

1. 启动：设置Yes：修改默认的appendonly no，改为yes。
2. 修复：如遇到AOF文件损坏，通过/user/local/bin/redis-check-aof --fix appendonly.aof进行恢复。
3. 恢复：重启Redis然后重新加载。

AOF同步频率设置

1. appendfsync always
   始终同步，每次Redis的写入都会立刻记入日志，性能较差但数据完整性比较好。
2. appendfsync everysec
   每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。
3. appendfsync no
   redis不主动进行同步，把同步时机交给操作系统。

AOF测试

• 开启redis，发现出现aof文件，设置3个key值，并关闭。
  
• 重新启动redis，可以获取到值
  

Redis事务

事务简介

1. Redis事务是一组命令的集合，一个事务中的所有命令都将被序列化，按照一次性、顺序性、排他性的执行一系列的命令。
2. Redis单条命令保证原子性，但是事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。
3. Redis事务没有隔离级别的概念。批量操作在执行前被放入缓存队列，并不会被实际执行。
4. Redis事务的三个阶段：
   1. 开始事务
   2. 命令入队
   3. 执行事务

Multi、Exec、discard

• 事务从输入Multi命令开始，输入的命令都会依次压入命令缓冲队列中，并不会执行，直到输入Exec后，Redis会将之前的命令缓冲队列中的命令依次执行。
• 组队过程中，可以通过discard来放弃组队。
• 例1:

//开始事务
multi 
//进行组队，并不执行
set k1 v1 
//进行组队，并不执行
set k2 v2 
//执行队列命令，依次设置k1 k2
exec 

• 例2:

//开始事务
multi 
//进行组队，并不执行
set k3 v3 
//进行组队，并不执行
set k4 v4 
//取消组队，都不执行
discard 

事务的错误处理

• 组队阶段某个命令出现了错误，整个队列中的命令都不执行。
• 执行阶段某个命令出现了错误，只有报错的命令不会执行，其他正常执行。

Redis中的乐观锁

• 在执行multi之前，先执行watch监视一个或多个key，如果在事务执行之前这个（或这些）key被其它命令所改动，那么事务将执行失败，返回nil。

watch key [key……]

• 取消对所有key的监视

unwatch

如果在执行watch命令之后，exec命令或discard命令先执行的话，那么就不需要再执行unwatch。

Redis主从复制

主从复制简介

• 主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(Master)，后者称为从节点(Slave)；数据的复制是单向的，只能由主节点到从节点。
• 默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。
• Master以写为主，Slave以读为主。

一主多从的搭建

环境搭建

• 在同一台虚拟机上配置一主二从Redis服务器，由于单台机器，同一个端口只允许一个进程占用，所以需要修改其他两台Redis的端口。
• 分别创建端口为6379，6380，6381的3个Redis服务器的配置文件。
  
  内容如下：
  
  其他两个文件类似
• 分别启动三个redis服务
  

目前三台Redis服务器没有关系，他们全都是master

配置主从关系

• 让6380，6381成为6379的从机
• 在6380，6381上分别执行命令

//成为某个实例的从服务器。
slaveof ip port

//成为本机的6379redis服务的从机
slaveof 127.0.0.1 6379

查看主从关系

info replication

可以看到它(6379)的两个从机为6380，6381

主从复制的其他问题

• 如果Master断开（宕机），Slave依然连接着Master，可以正常使用读操作，但是没有写操作。如果Master恢复正常，Slave依旧可以直接获取Master写的信息。
• 如果Slave断开（宕机），当该Slave重启成功，则会变为Master，需要重新通过slaveof 命令恢复成Slave，只要变为Slave，立刻可以从Master同步所有数据。
• 上一个Slave（从机）是下一个Slave（从机）的Master（主机）。信息是一步步的复制过去的。
  

缺点：一旦某个Slave宕机，后面的Slave都无法备份。

• 当一个Master宕机后，后面的Slave可以立刻升为Master，其后面的Slave不用做任何修改。
  

哨兵模式（Sentinel）

简介

• 能够后台监控Master是否故障，如果故障了，根据投票数自动将Slave转换为Master。

哨兵模式的使用

• 将服务器调整为一主多从（6379带6380、6381）。(前面已经配置好了)
• 创建sentinel.conf文件，文件内容如下：

//myredis 为监控对象起的服务器名称（随意）
//1代表至少有1个哨兵投票同意迁移
sentinel monitor myredis 127.0.0.1 
//如果Master存在密码，需要配置服务器名密码
//sentinel auth-pass myredis 123456(密码)

• 启动哨兵

//在/usr/local/bin下面执行
./redis-sentinel /usr/local/myredis/sentinel.conf

/usr/local/myredis/sentinel.conf为该文件的位置

• 杀死6379服务
  
• 观察sentinel(选择了6381作为新的master)
  
• 重启6379之后发现它变成了slave

Redis集群

集群简介

• Redis集群实现了对Redis的水平扩容，即启动N个Redis节点，将整个数据库分布存储在这N个节点当中，每个节点存储总数据的1/N。
• Redis集群通过分区来提供一定程度的可用性：即集群有一部分节点失效或者无法进行通讯，集群也可以继续处理命令。
• Redis集群采用无中心结构，每个节点保存数据和整个集群状态,每个节点都和其他所有节点连接，用来交换彼此的信息。
• 为了使得集群在一部分节点宕机或者无法与集群的大多数节点进行通讯的情况下， 仍然可以正常运作，Redis 集群对节点使用了主从复制功能。

集群搭建

环境搭建

这里是配置3个一主一从的节点构成的集群

• 创建6个Redis服务的配置文件，端口分别为6379，6380，6381，6389，6390，6391，内容如下：

//引入总配置文件，路径记得修改
include /usr/local/myredis/redis.conf
//存储pid信息的文件
pidfile /var/run/redis_6379.pid
//配置端口
port 6379
//存储rdb信息的文件
dbfilename dump6379.rdb
//是否打开集群
cluster-enabled yes
//节点配置的文件名
cluster-config-file nodes-6379.conf
//节点超时时间，超过该时间集群自动进行主从互换
cluster-node-timeout 15000

• 分别启动6个Redis服务
  
  
• 在redis的安装目录的src下执行以下命令：
  

redis-cli --cluster create --cluster-replicas 1 192.168.137.132:6379 192.168.137.132:6380 192.168.137.132:6381 192.168.137.132:6389 192.168.137.132:6390 192.168.137.132:6391

此处使用真实ip地址，-replicas 1代表采用最简单的方式配置集群，一台主机，一台从机。replicas表示每个master需要有几个slave。

• 在redis客户端中查看节点状态。

//连接至任意节点，-c一定不要忘记
./redis-cli -c -p 6379
//查看节点状态
cluster nodes

操作集群

• Slot：

1. 一个 Redis 集群包含 16384 个哈希槽（hash slot），每个键都属于这 16384 个哈希槽的其中一个。
2. 集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽， 其中 CRC16(key) 语句用于计算键 key的 CRC16 校验和。
3. 集群中的每个节点负责处理一部分哈希槽。

• 命令：

//储存一个值
set k1 v1

//不在一个slot下的键值，是不能使用mget、mset等多建操作。
//储存多个值，可以通过{}来定义组的概念
//从而使key中{}内相同内容的键值对放到同一个slot中
mset k1{test} v1 k2{test} v2 k3{test} v3

Java与Redis

首先要能使redis能够被远程连接，除了配置外还要关闭防火墙

Jedis操作Redis

• 导入依赖：

<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>3.6.0</version>
</dependency>

• 代码：

import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.137.132",6379);
        String msg = jedis.ping();
        System.out.println(msg);

        //String
        //设置一个key
        jedis.set("k1","v1");
        //设置一个key
        jedis.set("k2","1");
        //获取一个key
        String res = jedis.get("k1");
        //对某一个key自增
        Long ires = jedis.incr("k2");

        //keys
        //返回所有的key
        Set<String> keys = jedis.keys("*");
        //返回该key剩余过期时间
        Long time = jedis.ttl("k1");

        //List
        //向list中添加数据
        jedis.lpush("list1","v1","v2","v3");
        //返回list全部数据
        List<String> list = jedis.lrange("list1",0,-1 );

        //Set
        //向set中添加数据
        jedis.sadd("set1" ,"v1","v2","v2","v3");
        //查看该集合中有多少个元素
        jedis.smembers("set1");

        //Hash
        //设置一个hash
        jedis.hset("user","age","25");
        //获取该key的所有value
        jedis.hvals("user");

        //ZSet
        //向zset中添加一条数据
        jedis.zadd("zset1",100,"java");
        //获取所有的值
        jedis.zrange("zset1",0,-1);

        //Bitmaps
        //将b1偏移量为0的位设置为1
        jedis.setbit("b1",0, "1");
        //获取b1偏移量为0的位
        jedis.getbit("b1",0);

        //Geospatia
        //添加一条地理信息数据
        jedis.geoadd("chinacity",30,10,"beijing");

        //Hyperloglog
        //将所有元素参数添加到 Hyperloglog 数据结构中。
        jedis.pfadd("book","c++","java","php");


        jedis.close();
    }
}

JedisCluster操作Redis集群

• 代码如下：

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

public class JedisClusterDemo {
    public static void main(String[] args) {
        HostAndPort hp = new HostAndPort("192.168.137.132",6379);
        JedisCluster jedisCluster = new JedisCluster(hp);

        jedisCluster.set("k6","v6");
        String res = jedisCluster.get("k6");
        System.out.println(res);

        jedisCluster.close();
    }
}

SpringData整合Redis

• 导入依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>



        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>

• 配置文件：

spring:
  redis:
    host: 192.168.137.132
    port: 6379
    password:
    #连接超时时间（毫秒）
    timeout: 30000
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 0

• 配置类：

@Configuration
public class RedisConfig {
    /**
     * 常见序列化器：
     * StringRedisSerializer: 简单的字符串序列化，一般用于key键的序列化
     * GenericJackson2JsonRedisSerializer: 可以将任何对象泛化为字符串并序列化（对象必须有无参构造方法）
     * JdkSerializationRedisSerializer: 序列化java对象（需要序列化的类必须实现Serializable接口）
     * Jackson2JsonRedisSerializer：序列化对象（序列化带泛型的数据时，会以map的结构进行存储，反序列化是不能将map解析成对象）
     *
     */

    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory) {
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
        //给key设置StringRedisSerializer序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //给value设置GenericJackson2JsonRedisSerializer序列化器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }

}

• 代码如下：

@Controller
public class Testcontroller {

    @Autowired
    private RedisTemplate redisTemplate;

    @ResponseBody
    @RequestMapping("test")
    public User test(){
        User user = new User(15,"xqc");
        redisTemplate.opsForValue().set(user.getName(),user);

        User res = (User) redisTemplate.opsForValue().get("xqc");
        System.out.println(res);
        return res;
    }


}

• 结果如下：