史上最全的Redis整合

陆离a

已于 2022-11-18 13:50:18 修改

阅读量806

点赞数

文章标签： redis java shell

于 2021-06-27 19:09:33 首次发布

本文链接：https://blog.csdn.net/qq_43712538/article/details/118278262

版权

Redis学习

1. Nosql概述

为什么使用Nosql

现在属于大数据时代（大数据：一般的数据库无法分析处理）

用于大型数据的处理和分析。

什么是nosql

Nosql = not only sql（不仅仅是sql）

关系型数据库：表格，行，列

泛指非关系性数据库，随着web2.0互联网的诞生！传统的关系型数据库，很难对付web2.0时代！尤其是超大规模的高并发的社区！暴露出很多难以克服的问题。

2.redis作用

Redis是一个开源(BSD许可)的内存数据结构存储，用作数据库、缓存和消息代理。Redis提供数据结构，如字符串，散列，列表，集，排序集，范围查询，位图，超日志，地理空间索引和流。Redis具有内置的复制、Lua脚本、LRU逐出、事务和不同级别的磁盘持久性，并通过Redis Sentinel和Redis Cluster自动分区提供高可用性。

Nosql特点

解耦！

1.读写速度很快，方便扩张（数据至今啊没有关系）

2.大数据量性能（redis一秒写8万次，读取11万，Nosql的缓存记录级，是一种细粒度的缓存，性能会较高）

3.数据类型是多样性的！

五大几基本数据类型1.String 2.List 3.Set 4.Hash 5 Zset
三星红特殊数据类型：geo， hyperloglog，bitmap

4.传统的关系型数据库（RDBNS）和Nosql

传统的关系型数据库
- 结构化组织
- sql
- 数据和关系都存在单独的表中
- 操作，数据定义语言
- 基础的事务

Nosql
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储 ，列存储，文档存储，图形数据库（社交关系）
- 最终版一致性
- CAP定理和Base理论（异地多活！）
- 高性能，高可用，高可扩

3.Nosql四大分类

KV：键值对

新浪：redis
美团：Redis+Tair
阿里，百度：redis + memecache

文档型数据库（bson和json）：

MongoDB（一般必须掌握）
- 是一个居于分布式文件存储的数据，c++编写
- 是一个介于关系型数据库和非关系型数据库中间的产品

4.Redis入门

概述

Redis是什么？
远程字典服务

Redis能干嘛5

读写速度变快，读的速度是110000次/s，写的速度是81000次/s。

1.内存存储，持久化，内存中是断电即失，所以说持久化很重要（rdb和aof）

2.效率高，用于告诉缓存

3.发布订阅

4.地图信息分析

5.计时器，计数器（比如微信微博浏览量，即可以记录）

特性

1.多样化的数据类型

2.持久化

3.集群

4.事务

5.Redis安装

weindows安装

bin目录下

启动命令：redis-server.exe redis.windows.conf

在这里插入图片描述

Linux插件安装

yum  list   installed   lrzsz

#rz命令
yum install lrzsz -y
#安装压缩解压命令zip、unzip
yum install -y unzip zip

#vim编辑命令
yum -y install vim

Linux安装

虚拟机分配ip

给ens33分配ip，执行

sudo dhclient ens33

1.下载安装包

2.上传并解压（一般放在opt目录）

tar -zxvf 压缩包

3.进入解压后的文件，可以看到redis配置文件

4.基本环境安装

yum install gcc-c++

make

make install

5.redis的默认安装路径

cd /usr/local/bin

6.将redis配置文件拷贝到自己新建的目录下

mkdir redis-cof

cp /opt/redis/redis-6.2.3/redis.conf redis-cof

7.redis默认不是后天启动，修改配置文件

vim redis-cof

{

daemonize yes

}

8.启动redis服务

在bin目录下(/usr/local/bin)

redis-server redis-cof/redis.cof

redis-cli -p 6379 (连接)

ping （显示pong连接成功）

9.查看redis进程是否启动

ps -ef | grep redis

说明启动成功
[root@localhost ~]# ps -ef | grep redis
root       1400      1  0 17:13 ?        00:00:00 redis-server 127.0.0.1:6379
root       1600   1468  0 17:16 pts/0    00:00:00 redis-cli -p 6379
root       1706   1686  0 17:18 pts/1    00:00:00 grep --color=auto redis

10.退出redis

127.0.0.1:6379> shutdown

启动

[root@localhost bin]# redis-server redis-cof/redis-cof
[root@localhost bin]# redis-cli -p 6379

6.Redis测试性能（官方自带性能测试工具）

redis-benchmark 命令参数

在这里插入图片描述

7.五大基础的知识

redis默认16个数据库

默认使用的是第一个数据库，可以通过select进行切换

127.0.0.1:6379> select 2
OK

查看当前数据库大小

127.0.0.1:6379[2]> DBSIZE
(integer) 0

清除当前数据库 flushdb

清除全部数据库内容flushall

查看所有的key

keys *

判断某个key是否存在

127.0.0.1:6379[1]> EXISTS name
(integer) 1

设置保存时间

127.0.0.1:6379[1]> EXPIRE name 10 设置key过期时间
(integer) 1

127.0.0.1:6379[1]> ttl name 查看当前key的剩余时间
(integer) 8

查看当前key的类型

127.0.0.1:6379[1]> type name
string

String类型

清除key值

127.0.0.1:6379[2]> DEL key3
(integer) 1
清除当前库所有key 值

127.0.0.1:6379[2]> flushdb
OK
清除所有库库所有key 值

127.0.0.1:6379[2]> flushall
OK
字符串追加

127.0.0.1:6379[1]> APPEND name " hello"

(integer) 9
127.0.0.1:6379[1]> get name
“lzp hello”
递增（比如说访问量，每次有人进行访问，访问量就会+1） i++

127.0.0.1:6379[1]> set view 0
OK
127.0.0.1:6379[1]> get view
“0”

127.0.0.1:6379[1]> incr view

(integer) 1
127.0.0.1:6379[1]> incr view
(integer) 2
递减 i –

127.0.0.1:6379[1]> decr view

(integer) 3
127.0.0.1:6379[1]> decr view
(integer) 2
设置自增或者自减的阈值 i = i +5

127.0.0.1:6379[1]> INCRBY view 5

(integer) 7
127.0.0.1:6379[1]> INCRBY view 5
(integer) 12
127.0.0.1:6379[1]> INCRBY view 5
(integer) 17
截取字符

127.0.0.1:6379[2]> set name I LOVE lzp
(error) ERR syntax error
127.0.0.1:6379[2]> set name “I LOVE LZP”
OK
127.0.0.1:6379[2]> get name
“I LOVE LZP”
127.0.0.1:6379[2]> GETRANGE name 2 5
“LOVE”
截取全部字符

127.0.0.1:6379[2]> GETRANGE name 0 -1
“I LOVE LZP”
替换字符

127.0.0.1:6379[2]> set key2 “abcde”
OK
127.0.0.1:6379[2]> get key2
“abcde”

127.0.0.1:6379[2]> SETRANGE key2 2 “***” #指定某个key值从第几位开始替换

(integer) 5

127.0.0.1:6379[2]> get key2
“ab***”
设置过期时间（设置key3的值为hellw，10秒过期）

127.0.0.1:6379[2]> setex key3 10 “hellw”

OK
不存在设置（在分布式锁使用，如果key4存在，创建失败，如果不存在则创建成功）

127.0.0.1:6379[2]> setnx key4 “test”

(integer) 0
127.0.0.1:6379[2]> get key4
" 4565"
批量写入key值
127.0.0.1:6379> mset k1 a1 k2 a2 k3 a3

OK
127.0.0.1:6379> keys *
1. “k1”
2. “k3”
批量读取key值
127.0.0.1:6379> mget k1 k2
1. “a1”
2. “a2”
保证原子性，要么同时成功，要么同时失败

127.0.0.1:6379> MSETNX B1 2 B2 3 B3 4

(integer) 1
使用json去保存（批量插入json 批量获取json）
set user:1 {name: zhangsan age:18} 设置一个user:1 对象值为json来保存对象！

key值存在巧妙设计 user:{id}:{filed} ,

127.0.0.1:6379> mset user:1:name lzp user:1:age 18 user:2:name ljj user:2:age 17

OK
127.0.0.1:6379> MGET user:1:name user:2:name
1. “lzp”
2. “ljj”
127.0.0.1:6379> MGET user:1:name user:1:age user:2:name user:2:age
1. “lzp”
2. “18”
3. “ljj”
getset (先get 再set)

127.0.0.1:6379> GETSET 66 66 如果不存在返回null

(nil)

127.0.0.1:6379> set name lzp
OK
127.0.0.1:6379> get name
“lzp”

127.0.0.1:6379> GETSET name “lll” 如果存在返回原始值再赋新值

“lzp”
127.0.0.1:6379> get name
“lll”

List类型

list基本的数据类型，列表，先进后出的形式

所有的list命令都是以“L”开头

list添加元素 (将runoobkey 这个list集合中添加元素)

127.0.0.1:6379> LPUSH runoobkey redis

(integer) 1
127.0.0.1:6379> LPUSH runoobkey mongodb
(integer) 2
127.0.0.1:6379> LPUSH runoobkey mysql
(integer) 3
获取list集合中的元素(获取从第0个到第10个的元素)
127.0.0.1:6379> LRANGE runoobkey 0 10
1. “mysql”
2. “mongodb”
3. “redis”
将list中添加元素

127.0.0.1:6379> LPUSH data a

(integer) 1
127.0.0.1:6379> LPUSH data b
(integer) 2
127.0.0.1:6379> LPUSH data c
(integer) 3
获取上方list中的元素(由于遵循现金后出的原则，所以最先取到的是最后输入的参数)
127.0.0.1:6379> LRANGE data 0 -1 # 0 -1 获取全部 0 n 获取第一个到第n个元素
1. “c”
2. “b”
3. “a”
往底部添加元素
127.0.0.1:6379> RPUSH data CC

(integer) 4
127.0.0.1:6379> LRANGE data 0 -1
1. “c”
2. “b”
3. “a”
移除（左L 右R元素）
127.0.0.1:6379> LPOP data 1
1. “c”
127.0.0.1:6379> RPOP data 1
1. “CC”
获取列表长度
127.0.0.1:6379> LRANGE data 0 -1
1. “c”
2. “b”
3. “a”
127.0.0.1:6379> LLEN data

(integer) 3
将list某个值移动到另一个list中
127.0.0.1:6379> RPOPLPUSH data datas

“a”
127.0.0.1:6379> LRANGE data 0 -1
1. “c”
2. “b”
  127.0.0.1:6379> LRANGE datas 0 -1
3. “a”
在list某个元素前插入一个元素
127.0.0.1:6379> LINSERT mylist before hello LZP

(integer) 2
127.0.0.1:6379> LRANGE mylist 0 -1
1. “LZP”
2. “hello”
在list某个元素后插入一个元素
127.0.0.1:6379> LINSERT mylist after hello xfr

(integer) 3
127.0.0.1:6379> LRANGE mylist 0 -1
1. “LZP”
2. “hello”
3. “xfr”

SET类型（集合）

set中的值不能重复，set开头都是“S”,set没有顺序

添加元素

127.0.0.1:6379> sadd myset a

(integer) 1
127.0.0.1:6379> sadd myset b
(integer) 1
查看set中的元素
127.0.0.1:6379> SMEMBERS myset
1. “c”
2. “b”
3. “a”
判断元素是否存在
127.0.0.1:6379> SMEMBERS myset
1. “c”
2. “b”
3. “a”
  127.0.0.1:6379> SISMEMBER myset c
  (integer) 1
127.0.0.1:6379> SISMEMBER myset d

(integer) 0
获取元素个数

127.0.0.1:6379> SCARD myset

(integer) 3

移除元素
127.0.0.1:6379> SMEMBERS myset
1. “c”
2. “b”
3. “a”
  127.0.0.1:6379> SREM myset c
  (integer) 1
  127.0.0.1:6379> SMEMBERS myset
4. “b”
5. “a”

随机获取元素(抽随机数)
127.0.0.1:6379> SMEMBERS myset
1. “a”
2. “d”
3. “b”
4. “c”
5. “e”
6. “f”
127.0.0.1:6379> SRANDMEMBER myset

“e”
127.0.0.1:6379> SRANDMEMBER myset
“f”
127.0.0.1:6379> SRANDMEMBER myset
“c”
删除随机元素

127.0.0.1:6379> SPOP myset
“a”
127.0.0.1:6379> SPOP myset
“c”

将指定元素移动到另一个集合中 (将myset中元素c 移动到myset2中)
127.0.0.1:6379> SMOVE myset myset2 c
(integer) 1
127.0.0.1:6379> SMEMBERS myset2
1. “c”

数据类

差集(查看myset 和myset2中不同的元素)
127.0.0.1:6379> SMEMBERS myset
1. “b”
2. “g”
3. “e”
4. “d”
5. “f”
  127.0.0.1:6379> SMEMBERS myset2
6. “b”
7. “c”
8. “a”
127.0.0.1:6379> SDIFF myset myset2
1. “e”
2. “g”
3. “f”
4. “d”
交集(查看两个集合中相同的元素)
127.0.0.1:6379> SINTER myset myset2
1. “b”
并集(查看两个集合一共有多少元素)
127.0.0.1:6379> SUNION myset myset2
1. “b”
2. “g”
3. “c”
4. “a”
5. “e”
6. “d”
7. “f”
可以对多个集合进行操作
127.0.0.1:6379> sadd myset3 ddddddddddd
(integer) 1
127.0.0.1:6379> SUNION myset myset2 myset3
1. “b”
2. “ddddddddddd”
3. “g”
4. “c”
5. “a”
6. “e”
7. “d”
8. “f”

Hash(map集合)

map集合，key-<key,value>map集合!这时候这个值就是一个map集合，命令以“H”开头

元素插入

127.0.0.1:6379> HSET test field1 test
(integer) 1

批量插入和获取
127.0.0.1:6379> HMSET mytest a 1 b 2 c 3

OK

127.0.0.1:6379> HMGET mytest a b c
1. “1”
2. “2”
3. “3”
获取全部值
127.0.0.1:6379> HGETALL mytest
1. “a”
2. “1”
3. “b”
4. “2”
5. “c”
6. “3”
删除指定key字段，对应的value也就随之删除
127.0.0.1:6379> HDEL mytest a

(integer) 1
127.0.0.1:6379> HGETALL mytest
1. “b”
2. “2”
3. “c”
4. “3”
获取长度

127.0.0.1:6379> HLEN mytest

(integer) 2
判断hash是否存在

127.0.0.1:6379> HEXISTS mytest a

(integer) 0
127.0.0.1:6379> HEXISTS mytest b
(integer) 1
只获得所有的key
127.0.0.1:6379> HKEYS mytest
1. “b”
2. “c”
只获得所有的value
127.0.0.1:6379> HVALS mytest
1. “2”
2. “3”
如果存在设置不存在不设置

127.0.0.1:6379> HSETNX mytest ww 5

(integer) 1
127.0.0.1:6379> HSETNX mytest ww 6
(integer) 0
json形式存储

127.0.0.1:6379> HSET user:1 name lzp

(integer) 1

Zset（有序集合）

set的基础上增加了一个值，语法以“Z”开头

添加一个值或多个值
127.0.0.1:6379> zadd test 1 one

(integer) 1

127.0.0.1:6379> zadd test 2 two 3 three

(integer) 2

127.0.0.1:6379> ZRANGE test 0 -1
1. “one”
2. “two”
3. “three”
排序实现(-inf inf 负无穷到正无穷)
127.0.0.1:6379> zadd salary 150 a
(integer) 1
127.0.0.1:6379> zadd salary 200 b
(integer) 1
127.0.0.1:6379> zadd salary 152 c
(integer) 1
127.0.0.1:6379> zadd salary 149 d
(integer) 1

127.0.0.1:6379> ZRANGEBYSCORE salary -inf inf #升序
1. “d”
2. “a”
3. “c”
4. “b”
127.0.0.1:6379> ZREVRANGE salary 0 -1 #降序
1. “b”
2. “c”
3. “d”
- 携带key显示
  127.0.0.1:6379> ZRANGEBYSCORE salary -inf inf withscores
  1. “d”
  2. “149”
  3. “a”
  4. “150”
  5. “c”
  6. “152”
  7. “b”
  8. “200”
移除元素
127.0.0.1:6379> ZRANGE salary 0 -1
1. “d”
2. “a”
3. “c”
4. “b”
127.0.0.1:6379> ZREM salary a

(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1
1. “d”
2. “c”
3. “b”
获取集合中的个数
127.0.0.1:6379> ZRANGE salary 0 -1
1. “d”
2. “c”
3. “b”
127.0.0.1:6379> ZCARD salary

(integer) 3

8.三大特殊类型

geospatial地理位置

朋友定位，附近的人，打车距离计算？

Redis的Geo在redis3.2版本就提出了，推算两地位置和距离。

只有6个命令

GEOADD
GEODIST
GEOHASH
GEOPOS
GEORADIUS
GEORADIUSBYNEMBER

GEOPOS

1.添加地理位置

🅰️ 规制：；两季无法直接添加，我们一般下载城市数据，直接通过java程序一次导入！

🅱️ 参数: key 纬度经度名称

GEOADD 精度维度名称

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 112.70 37.69 yuci
(integer) 1

127.0.0.1:6379> GEOADD china:city 39.90 116.40 beijing
(error) ERR invalid longitude,latitude pair 39.900000,116.400000
报错此类说明经纬度超出 限定数据，参数有误

2.获取经纬度

127.0.0.1:6379> GEOPOS china:city yuci

“112.69999891519546509”

“37.68999952533372522”

3.获取多个

127.0.0.1:6379> GEOPOS china:city yuci beijing

“112.69999891519546509”

“37.68999952533372522”

“116.39999896287918091”

“39.90000009167092543”

---------

GEODIST

1.两人之间的距离

单位如下

m 米
km 千米
mi 英里
ft 英尺

127.0.0.1:6379> GEODIST china:city yuci shanghai
“1077536.9256”

2.我附近的人的地址（地位）通过半径来查询

127.0.0.1:6379> GEORADIUS china:city 116 30 1000 km #获取100 到30 经纬度寻找方圆1000km城市

“shanghai”
“yuci”

127.0.0.1:6379> GEORADIUS china:city 116 30 1000 km withcoord #获取100 到30 经纬度寻找方圆1000km城市以及经纬

“shanghai”

“121.47000163793563843”
“31.22999903975783553”

“yuci”

“112.69999891519546509”
“37.68999952533372522”

127.0.0.1:6379> GEORADIUS china:city 116 30 1000 km withcoord count 1 #获取100 到30 经纬度寻找方圆1000km城市以及经纬截取一个数据

“shanghai”

“121.47000163793563843”
“31.22999903975783553”

3.查询距离指定地点附近n 距离的城市

0.0.1:6379> GEORADIUSBYMEMBER china:city yuci 700 km #查询榆次700km附近的城市

“yuci”
“beijing”

4.获取经纬字符（hash）将二维·经纬转换为一维字符串

127.0.0.1:6379> GEOHASH china:city yuci

“ww8nkt38hm0”

5.获取所有城市名称

127.0.0.1:6379> ZRANGE china:city 0 -1

“shanghai”
“yuci”
“beijing”

6.移除数据

127.0.0.1:6379> ZREM china:city beijing
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1

“shanghai”
“yuci”

Hyperloglog基数统计

🅰️ 什么是基数？

基数（基数不重复的元素） = 5 ，可与i接受误差

📗简介

网页的UV（访问次数，一个人访问网站多次，统计依旧以一个人的数量显示）

传统的方式，set保存用户的id，然后就可以统计set中的元素数量作为标准！

这个方式如果保存大量的用户id，就会比较麻烦！我们的目的是为了基数，而不是保存用户id。

Hyperloglog优缺点

优点：占用内存是固定，2^64不同的元素基数，只需要花费12kb内存。如果从保存角度比较的话Hyperloglog首选！

1.添加元素并统计数量(重复元素不计数)

127.0.0.1:6379> PFADD mykey a b c d e f

(integer) 1

127.0.0.1:6379> PFCOUNT mykey

(integer) 6

2.并集计算(将mykey 和 mykey2 合并为a)

127.0.0.1:6379> PFMERGE a mykey mykey2

OK

127.0.0.1:6379> PFCOUNT a

(integer) 11

Bitmap

位存储

统计用户信息，活跃，不活跃！登录和未登录。打卡，365打卡，两个状态选择就可以使用Bitmaps，二进制记录，只有0和1。言简意赅的来说，你未登录用0标识即可，登录用1标识即可

1.存取数据和读取数据

127.0.0.1:6379> SETBIT sign 0 0

(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 4 1
(integer) 0

127.0.0.1:6379> GETBIT sign 3

(integer) 0

127.0.0.1:6379> GETBIT sign 4

(integer) 1

2.统计多少天打卡

127.0.0.1:6379> BITCOUNT sign
(integer) 1

9.事务

Redis事务本质：一组命令的集合！一个事务的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！$\textcolor{red}{一次性，顺序性，排他性} $

所有的命令子在事务中，并没有直接被执行，只有发起执行命令的时候才会执行

$\textcolor{red}{Redis单条命令保存原子性，但是事务不保证原子性！} $

redis的事务

开启事务（multi）
命令入列（…）
执行·事务（exec）

正常执行事务！

入队的时候并没有执行，当所有命令入列之后使用exec执行事务，当执行完事务的时候也就意味着事务销毁，生命周期结束，再次使用需要再次开启

1.事务的执行

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

OK
OK
“v2”
OK

2.事务的取消

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> set a1 a
QUEUED
127.0.0.1:6379(TX)> set a2 b
QUEUED
127.0.0.1:6379(TX)> set a3 c
QUEUED

127.0.0.1:6379(TX)> DISCARD

OK
127.0.0.1:6379> get a3
(nil)****

3.编译型异常（代码有问题！命令错误），事物中所有命令不被执行.

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)> getset ks
(error) ERR wrong number of arguments for ‘getset’ command
127.0.0.1:6379(TX)> set k4 v
QUEUED
127.0.0.1:6379(TX)> set k5 vv
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.

4.运行时异常（1/0），如果事务队列中存在语法性，那么执行命令的时候，其他命令可以正常执行

127.0.0.1:6379> set ka “v1”
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> INCR ka #递增
QUEUED
127.0.0.1:6379(TX)> set a1 x
QUEUED
127.0.0.1:6379(TX)> set a2 c
QUEUED
127.0.0.1:6379(TX)> set ab 6
QUEUED
127.0.0.1:6379(TX)> exec

(error) ERR value is not an integer or out of range
OK
OK
OK

$\textcolor{green}{监控}$

悲观锁：（效率低下）

很悲观，什么时候都会出问题，无论做什么都会加锁

乐观锁：

很乐观，认位什么时候都不会出问题，所以不会上锁！更新数据的时候会去判断一下，再次期间判断是否有人修改。version加版本号
获取version
更新的时候比较version

事务正常测试结束，数据期间没有发生边动

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 20
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 10 #money -10
QUEUED
127.0.0.1:6379(TX)> INCRBY out 10 #out +10
QUEUED
127.0.0.1:6379(TX)> EXEC

(integer) 90
(integer) 30

10.Jedis

java

为什么是jedis是官方推荐的java连接工具！使用java操作redis中间件！如果你使用java操作Redis，那一定对jedis很熟悉。

1.导入对应的依赖

       <!--redis学习包-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!--json-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
            <scope>compile</scope>
        </dependency>

           
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.1.RELEASE</version>
        </dependency>

2.配置

#jsp文件路径，默认路径：src/main/webapp,
spring:
  #redis配置
  redis:
    host: localhost
    port: 6376
    password:
    # 连接超时时间 单位 ms（毫秒）
    timeout: 3000
    max-idle: 200
    max-active: 2000
    max-wait: 1000
#mysql配置
  datasource:
    url: jdbc:mysql://localhost:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    max-idle: 10
    max-wait: 1000
    min-idle: 5
    initial-size: 5
    dbcp2:
      validation-query: SELRCT 1
      test-on-borrow: true
mybatis:
  type-aliases-package: com.example.demo.pojo
  mapper-locations: classpath:/mapper/*.xml
logging:
  level:
    com.example.demo.dao: debug  #只更改level下的路径为自己的的mapper debug不变
http:
  encoding:
      charset: UTF-8
      enabled: true
      force: true

server:
  port: 8082
  session:
    timeout: 10
  tomcat:
    uri-encoding: UTF-8

3.基本命令（与在xshell中命令一样）

/**
 * redis是否连接
 */
@Test
public void test1(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    System.out.println(jedis.ping());
    //关闭redis
    jedis.close();
}

/**
 * 主键有哪些
 */
@Test
public void test2(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    Set<String> keys = jedis.keys("*");
    System.out.println("redis有：" + keys + "主键");
}

/**
 * 查看主键是否存在
 */
@Test
public void test3(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    Boolean name = jedis.exists("name");
    System.out.println(name);
}

/**
 * 删除主键
 */
@Test
public void test4(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    Long name = jedis.del("name");
    System.out.println(name);
    Boolean name1 = jedis.exists("name");
    System.out.println(name1);
}

/**
 * 获取元素
 */
@Test
public void test5(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    jedis.set("name", "陆离");
    String data = jedis.get("name");
    System.out.println(data);
}



/**
 * 批量插入
 */
@Test
public void test6(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    jedis.mset("name", "陆离","age","22","sex","boy");
    String data = jedis.get("age");
    System.out.println(data);
}

/**
 * 清空
 */
@Test
public void test7(){
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    jedis.flushDB();
}




        System.out.println(清空数据库：+jedis.flushDB());
        System.out.println(判断某个键是否存在：+jedis.exists(k1));
        System.out.println(新增k1,v1键值对：+jedis.set(k1,v1));
        System.out.println(新增k2,v2键值对：+jedis.get(k1));
        System.out.println(系统中所有的键如下：);
        SetString keys = jedis.keys(*);
        System.out.println(keys);
        System.out.println(删除键k2：+jedis.del(k2));
        System.out.println(判断键k2是否存在：+jedis.exists(k2));
        System.out.println(查看键 k1 所存储的数据类型：+jedis.type(k1));
        System.out.println(随机返回 key 空间的一个：+jedis.randomKey());
        System.out.println(重命名 key ：+jedis.rename(k1,newk1));
        System.out.println(取出改后的 newk1 ：+jedis.get(newk1));
        System.out.println(按索引查询：+jedis.select(0));
        System.out.println(删除当前选择数据库中的所有键：+jedis.flushDB());
        System.out.println(返回当前数据库中 key 的数量：+jedis.dbSize());
        System.out.println(删除所有数据库中的所有 key ：+jedis.flushAll());

4.事务的执行

@Test
public void test1() {
    Jedis jedis = new Jedis("127.0.0.1", 6376);
    jedis.flushDB();
    JSONObject jsonObject = new JSONObject();
    jsonObject.put("name", "陆离");
    jsonObject.put("age", "22");
    //开启事务
    Transaction multi = jedis.multi();
    String data = jsonObject.toJSONString();
    try {
        multi.set("user1", data);
        multi.set("user2", data);
        //成功的情况会查询成功数据
        /**
         * {"name":"陆离","age":"22"}
         * {"name":"陆离","age":"22"}
         */
        //如果此处有异常代码
        //int i= 10/0;
        /**
         * null
         * null
         */
        multi.exec();
    } catch (Exception e) {
        multi.discard();        //放弃事务
        e.printStackTrace();
    } finally {
        System.out.println(jedis.get("user1"));
        System.out.println(jedis.get("user2"));
        jedis.close();
    }
}

11.SpringBoot整合

1.导入redis依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>1.4.1.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.4.3</version>
</dependency>

2.配置yml

spring:
  #redis配置
  redis:
    host: 127.0.0.1
    port: 6376
    password:

3.测试连接

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    /**
     * redisTemplate操作不同数据类型
     * opsForValue 操作字符串 类似于String
     * opsForList 操作list
     * opsForHash 操作hash
     * opsForSet
     * opsForHyperLogLog
     * opsForZSet
     * opsForGeo
     */

    @Test
    public void test1() {
        //获取连接对象
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        String ping = connection.ping();
        System.out.println(ping);
    }
}

12.自定义RedisTemplate（固定模板，可以直接在项目中使用）

@Configuration
@EnableAutoConfiguration
public class RedisConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.pool")
    public JedisPoolConfig getRedisConfig() {
        return new JedisPoolConfig();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    public JedisConnectionFactory getConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setUsePool(true);
        JedisPoolConfig config = getRedisConfig();
        factory.setPoolConfig(config);
        return factory;
    }

    @Bean
    public RedisTemplate<?, ?> getRedisTemplate() {
        JedisConnectionFactory factory = getConnectionFactory();
        RedisTemplate<?, ?> template = new StringRedisTemplate(factory);
        return template;
    }


    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        serializer.setObjectMapper(objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setDefaultSerializer(stringRedisSerializer);
        template.setKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(serializer);
        template.setHashKeySerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}




然后当注入bean的时候
    //@Qualifier("redisTemplate") 可以直接只想bean
    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate<String,Object> redisTemplate;

13.封装Redis工具类***

致谢**静静别跑**，

https://www.cnblogs.com/zhzhlong/p/11434284.html

此处的工具类为学取这位前辈的代码。此处非原创

package com.migu.example.demo.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import redis.clients.jedis.Jedis;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
@SuppressWarnings("all")
public final class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================



    /**
     * 判断redis是否连接成功
     * @param host
     * @param port
     * @return
     */
    public Boolean linkStatus(String host, int port) {
        Jedis jedis = new Jedis(host, port);
        String ping = jedis.ping();
        return "PONG".equals(ping);
    }

    /**
     * 指定缓存失效时间
     *  @param key  键
     * @param time 时间(秒)
     */
    public void expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据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((Collection<String>) 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)
     */
    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)
     */
    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
     */
    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 对应多个键值
     */
    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)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    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 键
     */
    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代表所有值
     */
    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 键
     */
    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倒数第二个元素，依次类推
     */
    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 值
     */
    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  时间(秒)
     */
    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 值
     * @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;
        }

    }
}

14 .redis.conf详解

# Redis configuration file example.
#
# Note that in order to read the configuration file, Redis must be
# started with the file path as first argument:
#
# ./redis-server /path/to/redis.conf

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

################################## INCLUDES ###################################

1.配置unit单位对大小写不敏感。

可以包含多个conf

include /path/to/other.conf

################################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Note that option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf

################################## MODULES #####################################

指定ip

bind 127.0.0.1 -::1

保护模式

protected-mode yes

指定端口

port 6379

数据库数量

databases 16

快照

持久化规则，在规定时间内，执行了多少次操作，则会持久化到文件.rdb，.aof

#如果3600秒内，如果至少有一个key进行操作，我们将会持久化操作
# save 3600 1
# save 300 100
# save 60 10000

程序操作是否继续执行

stop-writes-on-bgsave-error yes

是否压缩为rdb

rdbcompression yes

保存rdb进行错误的校验

rdbchecksum yes

获取密码

127.0.0.1:6379> get requirepass
(nil)

15.Redis持久化

在指定的时间间隔内将内存中的数据集快照写入磁盘,也就是行话讲的Snapshot快照,它恢复时是将快照文件直接读到内存里。Redis会单独创建(fork )一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,再用这个临时文·件替换上次持久化好的文件。整个过程中,主进程是不进行任何0操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常敏感,那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

通过配置conf文件中配置save 即可配置

当执行FLUSHALL命令时就会生成rdb文件，如果redis数据丢失，将rdb放入redis’启动目录下就可以恢复数据。

查看存放位置

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin/redis-cof"

优点

适合大规模数据的恢复！

对数据的完整性要求不高
缺点

需要一定时间间隔进程操作，如果redis意外宕机，这个最后一次修改的数据就没有了

fork进程的时候，回占用一定的内容空间

16.持久化操作之AOF

在配置中默认是no

appendonly yes

appendfilename “appendonly.aof” #生成名称

17.发布订阅

通信队列发送者订阅者

Redis 发布订阅（pub/sub）是一种消息通信模式：发送者（pub）发送信息，订阅者（sub）接受信息

在这里插入图片描述

测试

订阅端

此处相当于一个新建一个频道 等待接收消息
SUBSCRIBE 频道名称
127.0.0.1:6379> SUBSCRIBE luli
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "luli"
3) (integer) 1
1) "message"
2) "luli"
3) "hello"
1) "message"
2) "luli"
3) "hellos"

发送端

新开一个窗口作为发布端，类似于向频道端发送消息，当发送过去后，频道端就会接收到
PUBLISH 频道名称 "消息"
127.0.0.1:6379> PUBLISH luli "hello"
(integer) 1
127.0.0.1:6379> PUBLISH luli "hellos"
(integer) 1

使用场景

实时消息系统
实时聊天（频道当做聊天室）

就类似于微信聊天，其实双方或者多方发送的消息并不是发送给对方，而是双方把信息发送到你们联通开启的这个聊天室中

概念

是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower)；数据的复制是单向的，只能由主节点到从节点。
Master以写为主，Slave 以读为主。

默认情况下，每台Redis服务器都是主节点；
且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。（）
主从复制的作用主要包括：
1、数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2、故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务
的冗余。
3、负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务
（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写
少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用（集群）基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复
制是Redis高可用的基础。

一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的（宕机），原因如下：
1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较
大；
2、从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有
内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。
电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是"多读少写"。
对于这种场景，我们可以使如下这种架构：

主从复制，读写分离！ 80% 的情况下都是在进行读操作！减缓服务器的压力！架构中经常使用！

18.Redis主从复制

临时命令配置

主从复制，读写分离！80%的情况下都是进行读操作！一主二从

解决虚拟机ip未分配问题
https://www.cnblogs.com/tyche116/p/14171721.html
命令：sudo dhclient ens33

#redis集群分配

#master主机	路径：D:\VMPojo
#此台主机为固定主机
192.168.146.139
root
lzp+19991128

#此台主机为redis测试主机
#leader主机 	路径：D:\新建文件夹
192.168.146.144
root
lzp+19991128x

#follower主机	
192.168.146.145
root
lzp+19991128s

#follower2主机	
192.168.146.146
root
lzp+19991128s2

查看主从复制的信息

[root@localhost bin]# redis-server redis-cof/redis-cof 
[root@localhost bin]#  redis-cli -p 6379
127.0.0.1:6379> info replication
# Replication
role:master			#角色
connected_slaves:0	#从机
master_failover_state:no-failover
master_replid:11d3b6c9f44cb89020e1c13335c487f601ca3cb0
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

搭建过程（单机多服务，一台主机多个服务）：

复制三份conf文件

[root@localhost redis-cof]# cp redis.conf redis79.conf
[root@localhost redis-cof]# cp redis.conf redis80.conf
[root@localhost redis-cof]# cp redis.conf redis81.conf

vim编辑

#6379服务
logfile "6379.log"
dbfilename dump6319.rdb

#6380服务
port 6380
pidfile /var/run/redis_6380.pid
logfile "6380.log"
dbfilename dump6380.rdb

#6381服务
port 6381
pidfile /var/run/redis_6381.pid
logfile "6381.log"
dbfilename dump6381.rdb

启动

[root@localhost redis-cof]# redis-server redis79.conf 
[root@localhost redis-cof]# ps -ef|grep redis
root       1425      1  0 15:30 ?        00:00:01 redis-server 127.0.0.1:6379
root       1526      1  0 15:46 ?        00:00:00 redis-server 127.0.0.1:6380
root       1532      1  0 15:46 ?        00:00:00 redis-server 127.0.0.1:6381

主从复制只需要配置从机节点即可。主机节点无需配置！认老大

79作为主机

80和81作为从机

认定主机

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379			#认定主机
OK
127.0.0.1:6380> info replication
# Replication
role:slave				#从机
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_repl_offset:0
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:2d0bbfc7426e8b4227383215f92fe4b03e44b4e1
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0

再次查看主机节点

127.0.0.1:6379>  info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6380,state=online,offset=462,lag=0			#80主机
slave1:ip=127.0.0.1,port=6381,state=online,offset=462,lag=0			#81主机
master_failover_state:no-failover
master_replid:2d0bbfc7426e8b4227383215f92fe4b03e44b4e1
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:462
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:462

配置永久主从

一般情况下我们是配置永久的信息

所以我们在conf文件中需要配置

在这里插入图片描述

replicaof 127.0.0.1 6379
masterauth 123456

细节注意

主机负责写，从机负责读取！主机中的所有信息和数据都会被从机保存。

主机79

127.0.0.1:6379> set a 1
OK

从机80

127.0.0.1:6380> get a
"1"

从机81

127.0.0.1:6381> get a
"1"

测试

如果主机断开的情况，从机依旧可以读取数据，但是没有了写操作。

哨兵模式

如何主节点宕机，从节点替代主节点

手动选举（不推荐）：如果主机断开SLAVEOF NO ONE让自己变成主机

自动选举(Sentinel哨兵模式)：通过监控后台的主机是否有故障，从而主动促发选举机制。

在这里插入图片描述

如果你有三台服务器，也就意味着你需要三个哨兵，哨兵与哨兵之间也需要进行监控

如果主机宕机，哨兵进行随机投票，从而选举出主机

在这里插入图片描述

哨兵搭建过程

1在目录下新建conf文件，核心基本配置

[root@localhost redis-cof]# vim sentinel.conf

#编辑内容	ip 端口 投票
sentinel monitor myredis 127.0.0.1 6379 1

2.启动哨兵

[root@localhost bin]# redis-sentinel redis-cof/sentinel.conf

以下信息则启动成功

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UUOJRcql-1624791715265)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210627183708229.png)]$

这个代表你监控的主机和从机

2042:X 27 Jun 2021 17:58:35.971 # +monitor master myredis 127.0.0.1 6379 quorum 1
2042:X 27 Jun 2021 17:58:35.971 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
2042:X 27 Jun 2021 17:58:35.972 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379

测试

启动之后宕机79服务主机节点

[root@localhost redis-cof]# redis-server redis.conf 
[root@localhost redis-cof]# redis-cli -p 6379
127.0.0.1:6379> set a 1
OK
127.0.0.1:6379> SHUTDOWN
not connected> EXEC

从机节点发出心跳包信息

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kiyGToX3-1624791715266)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20210627184122648.png)]$

那么我们在看一下他的信息

127.0.0.1:6380> INFO replication
# Replication
role:master				#此处信息成为了master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=28626,lag=1
slave1:ip=127.0.0.1,port=6379,state=online,offset=28626,lag=1
master_failover_state:no-failover
master_replid:809d45d915dc57b89ba45dde07b0f099c695c06a
master_replid2:10e889a9d41eaf898986adddf7b759f5ebcdae14
master_repl_offset:28626
second_repl_offset:16317
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:197
repl_backlog_histlen:28430
127.0.0.1:6380>

如果主机回来，那么哨兵从master就会回到slave

哨兵模式优缺点

优点：

哨兵集群，基于复制模式，所有的主从配置优点，他都有
主从可以切换，故障可以移除，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点：

redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦
实现哨兵模式的配置其实很麻烦里面有很多选择

哨兵的全部配置

# 端口
port 26379

# 是否后台启动
daemonize yes

# pid文件路径
pidfile /var/run/redis-sentinel.pid

# 日志文件路径
logfile "/var/log/sentinel.log"

# 定义工作目录
dir /tmp

# 定义Redis主的别名, IP, 端口，这里的2指的是需要至少2个Sentinel认为主Redis挂了才最终会采取下一步行为
sentinel monitor mymaster 127.0.0.1 6379 2

# 如果mymaster 30秒内没有响应，则认为其主观失效
sentinel down-after-milliseconds mymaster 30000

# 如果master重新选出来后，其它slave节点能同时并行从新master同步数据的台数有多少个，显然该值越大，所有slave节点完成同步切换的整体速度越快，但如果此时正好有人在访问这些slave，可能造成读取失败，影响面会更广。最保守的设置为1，同一时间，只能有一台干这件事，这样其它slave还能继续服务，但是所有slave全部完成缓存更新同步的进程将变慢。
sentinel parallel-syncs mymaster 1

# 该参数指定一个时间段，在该时间段内没有实现故障转移成功，则会再一次发起故障转移的操作，单位毫秒
sentinel failover-timeout mymaster 180000

# 不允许使用SENTINEL SET设置notification-script和client-reconfig-script。
sentinel deny-scripts-reconfig yes

19.缓存，击穿，雪崩

文献参考:https://blog.csdn.net/kongtiao5/article/details/82771694

缓存穿透

描述：

   缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

  解决方案：

接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击

缓存击穿

  描述：

  缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

  解决方案：

设置热点数据永远不过期。
加互斥锁.

缓存雪崩

  描述：

  缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，        缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

 解决方案：

缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。
如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
设置热点数据永远不过期。

以下为我的虚拟机配置，可以忽略。

redis集群分配

解决虚拟机ip未分配问题
https://www.cnblogs.com/tyche116/p/14171721.html


#redis集群分配

#master主机	
#此台主机为固定主机
192.168.146.139
root
lzp+19991128

#此台主机为redis测试主机
#leader主机 	
192.168.146.144
root
lzp+19991128x

#follower主机	
192.168.146.145
root
lzp+19991128s

#follower2主机	
192.168.146.146
root
lzp+19991128s2

127.0.0.1 6379 1


2.启动哨兵

```shell
[root@localhost bin]# redis-sentinel redis-cof/sentinel.conf

以下信息则启动成功

[外链图片转存中…(img-UUOJRcql-1624791715265)]

这个代表你监控的主机和从机

2042:X 27 Jun 2021 17:58:35.971 # +monitor master myredis 127.0.0.1 6379 quorum 1
2042:X 27 Jun 2021 17:58:35.971 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
2042:X 27 Jun 2021 17:58:35.972 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379

测试

启动之后宕机79服务主机节点

[root@localhost redis-cof]# redis-server redis.conf 
[root@localhost redis-cof]# redis-cli -p 6379
127.0.0.1:6379> set a 1
OK
127.0.0.1:6379> SHUTDOWN
not connected> EXEC

从机节点发出心跳包信息

[外链图片转存中…(img-kiyGToX3-1624791715266)]

那么我们在看一下他的信息

127.0.0.1:6380> INFO replication
# Replication
role:master				#此处信息成为了master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=28626,lag=1
slave1:ip=127.0.0.1,port=6379,state=online,offset=28626,lag=1
master_failover_state:no-failover
master_replid:809d45d915dc57b89ba45dde07b0f099c695c06a
master_replid2:10e889a9d41eaf898986adddf7b759f5ebcdae14
master_repl_offset:28626
second_repl_offset:16317
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:197
repl_backlog_histlen:28430
127.0.0.1:6380>

如果主机回来，那么哨兵从master就会回到slave

哨兵模式优缺点

优点：

哨兵集群，基于复制模式，所有的主从配置优点，他都有
主从可以切换，故障可以移除，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点：

redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦
实现哨兵模式的配置其实很麻烦里面有很多选择

哨兵的全部配置

# 端口
port 26379

# 是否后台启动
daemonize yes

# pid文件路径
pidfile /var/run/redis-sentinel.pid

# 日志文件路径
logfile "/var/log/sentinel.log"

# 定义工作目录
dir /tmp

# 定义Redis主的别名, IP, 端口，这里的2指的是需要至少2个Sentinel认为主Redis挂了才最终会采取下一步行为
sentinel monitor mymaster 127.0.0.1 6379 2

# 如果mymaster 30秒内没有响应，则认为其主观失效
sentinel down-after-milliseconds mymaster 30000

# 如果master重新选出来后，其它slave节点能同时并行从新master同步数据的台数有多少个，显然该值越大，所有slave节点完成同步切换的整体速度越快，但如果此时正好有人在访问这些slave，可能造成读取失败，影响面会更广。最保守的设置为1，同一时间，只能有一台干这件事，这样其它slave还能继续服务，但是所有slave全部完成缓存更新同步的进程将变慢。
sentinel parallel-syncs mymaster 1

# 该参数指定一个时间段，在该时间段内没有实现故障转移成功，则会再一次发起故障转移的操作，单位毫秒
sentinel failover-timeout mymaster 180000

# 不允许使用SENTINEL SET设置notification-script和client-reconfig-script。
sentinel deny-scripts-reconfig yes

19.缓存，击穿，雪崩

文献参考:https://blog.csdn.net/kongtiao5/article/details/82771694

缓存穿透

描述：

   缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

  解决方案：

接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击

缓存击穿

  描述：

  缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

  解决方案：

设置热点数据永远不过期。
加互斥锁.

缓存雪崩

  描述：

  缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，        缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

 解决方案：

以下为我的虚拟机配置，可以忽略。

redis集群分配

解决虚拟机ip未分配问题
https://www.cnblogs.com/tyche116/p/14171721.html


#redis集群分配

#master主机	
#此台主机为固定主机
192.168.146.139
root
lzp+19991128

#此台主机为redis测试主机
#leader主机 	
192.168.146.144
root
lzp+19991128x

#follower主机	
192.168.146.145
root
lzp+19991128s

#follower2主机	
192.168.146.146
root
lzp+19991128s2

陆离a

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
史上最全的Redis整合

Redis学习1. Nosql概述为什么使用Nosql现在属于大数据时代（大数据：一般的数据库无法分析处理）用于大型数据的处理和分析。什么是nosqlNosql = not only sql（不仅仅是sql）关系型数据库：表格，行，列泛指非关系性数据库，随着web2.0互联网的诞生！传统的关系型数据库，很难对付web2.0时代！尤其是超大规模的高并发的社区！暴露出很多难以克服的问题。2.redis作用Redis是一个开源(BSD许可)的内存数据结构存储，用作数据库、缓存和消息代理。Re
复制链接

扫一扫