Redis入门-狂神说Redis笔记

以你之姓@ 2024-03-17 21:08 74阅读 0赞

## Redis ##

## 1、nosql概述 ##

nosql:泛指非关系型数据库

## 2、Nosql的特点 ##

1、方便扩展（数据库之间没有了关系，很好扩展）

2大数据量高性能（nosql的缓存记录级，是一种细粒度的缓存，性能会比较高！）

3、数据类型是多样性的！（不需要事先设计数据库！随取随用！如果是数据量十分大的表，很多人就无法设计了！）

4、传统RDMS和NoSQL

传统的RDBMS
        结构化组织
        SQL
        数据和关系都存在单独的表中 row  col 
        数据操作，数据定义语言
        严格的一致性
        基础的事务
        。。。。。

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

了解：3v+3高

大数据时代的3V和：主要描述问题的

*  海量 Velume
 *  多样 Variety
 *  实时 Velocity

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

*  高并发
 *  高可扩
 *  高性能

## 3、NoSQL的四大分类 ##

###### KV键值对： ######

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

###### 文档型数据库（bson格式和json一样） ######

*  MongoDB(一般必须要掌握)
    
     *  MongoDB是一个分布式文件存储的数据库，主要用来处理大量的文档。
     *  MongoDB是一个介于关系型的数据库和非关系数据库中中间件的产品！MongoDB是非关系型数据库中功能最丰富，最像关系型数据库的！
 *  ContyDB
    
    **列存储数据库**
    
     *  HBase
     *  分布式文件系统
    
    **图关系数据库**
    
     *  他不是存图形，放的是关系比如说：朋友圈的社交网络、
     *  Neo4j,InfoGrid;

## 4、Redis能干什么 ##

Redis是一个开源的，能做数据库 、缓存、和消息中间件。

Redis能干嘛？

1.  内存存储、持久化、内存中是断电即失、所以说持久化很重要（rdb、aof)
2.  效率高、可以用于高速缓存
3.  发布订阅系统
4.  地图信息分析
5.  计时器、计数器（ 浏览量）
6.  …

> 特性

1.  多样的数据类型
2.  持久化
3.  集群
4.  事务
5.  …

###### 基础知识： ######

Redis是C语言写的，官方提供的数据为100000+的QPS,完全不必使用key\_value 的Memecache差！

**Redis为什么单线程还这么快？**

1.  误区1：高性能的服务器一定是多线程的？
2.  误区2：多线程（CPU上下文）一定比单线程效率高！

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

命令要记住，springboot和jedis,所有的方法就是这些命令！
    单点登录

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

###### Redis-Key ######

[root@iZ2zefrn59xpiawd7jgzxhZ ~]# ps -ef|grep redis #链接Redis
    redis     4486     1  0 09:54 ?        00:00:08 /www/server/redi/src/redis-server 127.0.0.1:6379
    root     17010 16956  0 11:44 pts/0    00:00:00 grep --color=auto redis
    [root@iZ2zefrn59xpiawd7jgzxhZ ~]# redis-cli -p 6379
    127.0.0.1:6379> ping  #测试
    PONG
    127.0.0.1:6379> keys *  #查看所有的
    1) "key:__rand_int__"
    127.0.0.1:6379> set name liuxukun  # set key 
    OK
    127.0.0.1:6379> set age 1
    OK
    127.0.0.1:6379> keys *
    1) "key:__rand_int__"
    2) "age"
    3) "name"
    127.0.0.1:6379> EXISTS name
    (integer) 1
    127.0.0.1:6379> EXISTS name1
    (integer) 0
    127.0.0.1:6379> move name 1
    (integer) 1
    127.0.0.1:6379> keys *
    1) "key:__rand_int__"
    2) "age"
    127.0.0.1:6379> set name liu
    OK
    127.0.0.1:6379> EXPIRE name 10 #设置过期时间·
    (integer) 1
    127.0.0.1:6379> ttl name 
    (integer) 6
    127.0.0.1:6379> ttl name 
    (integer) 5
    127.0.0.1:6379> 
    127.0.0.1:6379> set name lxk 
    OK
    127.0.0.1:6379> type name  #查看类型
    string
    127.0.0.1:6379> 
    [root@iZ2zefrn59xpiawd7jgzxhZ ~]#

###### String（字符串） ######

127.0.0.1:6379> set key1 v1          #设置值
    OK
    127.0.0.1:6379> get key1			 #获得值
    "v1"
    127.0.0.1:6379> keys *				#获得所有值
    1) "key1"
    2) "key:__rand_int__"
    3) "name"
    127.0.0.1:6379> EXISTS key1  	#判断某一个key是否存在
    (integer) 1
    127.0.0.1:6379>  APPEND key "hello"  
    		#追加字符串，如果当前的key不存在，就相当于setkey
    (integer) 5
    127.0.0.1:6379> get key1           
    "v1"
    127.0.0.1:6379> APPEND key1 "hello"
    (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 ",lxk"
    (integer) 11
    127.0.0.1:6379> get key1
    "v1hello,lxk"
    ######################################################
    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  #自增一
    (integer) 1
    127.0.0.1:6379> incr views
    (integer) 2
    127.0.0.1:6379> decr views  #自减1 
    (integer) 1
    127.0.0.1:6379> decr views
    (integer) 0
    127.0.0.1:6379> incrby views 10  # 可以设置步长，指定增量
    (integer) 10
    127.0.0.1:6379> decr views 5
    (error) ERR wrong number of arguments for 'decr' command
    127.0.0.1:6379> decrby views 5
    (integer) 5
    ######################################################
    字符串范围 range
    127.0.0.1:6379> keys *  #设置key1 的值
    1) "key1"
    2) "name"
    3) "key:__rand_int__"
    4) "key"
    5) "views"
    127.0.0.1:6379> get key1
    "v1hello,lxk"
    127.0.0.1:6379> GETRANGE key1 0 3  #截取字符串【0,3】
    "v1he"
    127.0.0.1:6379> GETRANGE key1 0 -2
    "v1hello,lx"
    127.0.0.1:6379> GETRANGE key1 0 -0
    (error) ERR value is not an integer or out of range
    127.0.0.1:6379> GETRANGE key1 0 -1 #获取全部的字符串和getkey是一样的
    "v1hello,lxk"
    
    #替换
    127.0.0.1:6379> set key2 abcdefg
    OK
    127.0.0.1:6379> SETRANGE key2 1 xx  #替换指定位置开始的字符串
    (integer) 7
    127.0.0.1:6379> get key2
    "axxdefg"
    ######################################################
    setex(set with expire) #设置过期时间
    setnx(set with expire)# 不存在设置
    127.0.0.1:6379> setex key3 30 "hello"  #设置key3的值为hello，30秒后过期
    OK
    127.0.0.1:6379> ttl key3
    (integer) 21
    127.0.0.1:6379> get key3
    "hello"
    127.0.0.1:6379> setnx mykey "redis" #如果mekey不存在，创建mykey
    (integer) 1
    127.0.0.1:6379> keys *
    1) "key1"
    2) "name"
    3) "key2"
    4) "mykey"
    5) "key:__rand_int__"
    6) "key"
    7) "views"
    127.0.0.1:6379> setnx mykey "MonogoDB"#如果mykey存在，创建失败
    (integer) 0
    127.0.0.1:6379> get mykey
    "redis"
    ######################################################
    #mset
    #mget
    127.0.0.1:6379> keys *
    (empty array)
    127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3  #同时设置多个值
    OK
    127.0.0.1:6379> keys *
    1) "k1"
    2) "k3"
    3) "k2"
    127.0.0.1:6379> mget k1 k2 k3 #同时获取多个值
    1) "v1"
    2) "v2"
    3) "v3"
    127.0.0.1:6379> msetnx k1 v1 k4 v4  #msetnx是一个原子性的操作，要么一起成功，要么一起失败
    (integer) 0
    127.0.0.1:6379> get k4
    (nil)
    
    #对象
    set user:1 {
        name:zhangsan,age:3}#设置一个user:1对象值为json字符来保存一个对象！
    
    #这里的key是一个巧妙的设计：user:{id}:{filed},如此设计在Redis中是完全OK的
    
    127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
    OK
    127.0.0.1:6379> mget user:1:name user:1:age
    1) "zhangsan"
    2) "2"
    
    ######################################################
    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"

数据结构是相同的，jedis

string的使用场景：

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

###### List ######

最基本的数据类型，列表吧

在Redis里面，我们可以把list弄成，栈、队列、阻塞队列

所有的list的命令中l和r可以控制元素进出的方向

*  增加一个命令

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> RPUSH list right #将一个或者多个值插入到列表的尾部（有）
    (integer) 4
    127.0.0.1:6379> LRANGE list 0 -1
    1) "three"
    2) "two"
    3) "one"
    4) "right"

*  移除一个命令

127.0.0.1:6379> lpop list #移除list的第一个元素
    "three"
    127.0.0.1:6379> rpop list#移除list的最后一个元素
    "right"
    127.0.0.1:6379>

*  获取一个元素（lindex）通过下标

127.0.0.1:6379> lindex list 1  #通过下标获取一个值
    "one"
    127.0.0.1:6379> lindex list 0
    "two"
    127.0.0.1:6379>

*  llen获取列表的长度

127.0.0.1:6379> llen list
    (integer) 2

*  移除指定的值（lrem)

127.0.0.1:6379> lrange list 0 -1
    1) "two"
    2) "two"
    3) "two"
    127.0.0.1:6379> lrem list 2 two #移除list结合中指定个数的value，精确匹配
    (integer) 2
    127.0.0.1:6379> lrange list 0 -1
    1) "two"

*  trim修剪：list截断

127.0.0.1:6379> rPUSH mylist "hello"
    (integer) 1
    127.0.0.1:6379> rPUSH mylist "hello1"
    (integer) 2
    127.0.0.1:6379> rPUSH mylist "hello2"
    (integer) 3
    127.0.0.1:6379> rPUSH mylist "hello3"
    (integer) 4
    127.0.0.1:6379> ltrim 1 2
    (error) ERR wrong number of arguments for 'ltrim' command
    127.0.0.1:6379> ltrim mylist 1 2  #通过下标截取指定的长度这个list已经改变了，截断了只剩下截取的元素
    OK
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "hello1"
    2) "hello2"

*  rpoplpush \# 移出列表的最后一个元素，将他移动到新的列表中

127.0.0.1:6379> rpush mylist "hello"
    (integer) 1
    127.0.0.1:6379> rpush mylist "hello1"
    (integer) 2
    127.0.0.1:6379> rpush mylist "hello2"
    (integer) 3
    127.0.0.1:6379> rpush mylist "hello2"
    (integer) 4
    127.0.0.1:6379> rpoplpush mylist myotherlist
    "hello2"
    127.0.0.1:6379> lrange mylist 0 -1
    1) "hello"
    2) "hello1"
    3) "hello2"
    127.0.0.1:6379> lrange myotherlist 0 -1
    1) "hello2"

*  lset命令将指定下标中的值替换成另外一个值，更新操作
    
     *  如果不存在列表我们去更新就会报错

127.0.0.1:6379> EXISTS list
    (integer) 0
    127.0.0.1:6379> Lpush list value
    (integer) 1
    127.0.0.1:6379> LRANGE list 0 0
    1) "value"
    127.0.0.1:6379> lset list 0 item #如果存在就会更新
    OK
    127.0.0.1:6379> LRANGE list 0 0
    1) "item"
    127.0.0.1:6379> LRANGE list 0 1
    1) "item"
    127.0.0.1:6379> LRANGE list 0 -1
    1) "item"
    127.0.0.1:6379> LRANGE list 0 2
    1) "item"
    127.0.0.1:6379> lset list 1 other #如果不存在就会报错
    (error) ERR index out of range
    127.0.0.1:6379>

*  linsert :蒋某一个具体的value插入到列把你中某个元素的前面或者后面

127.0.0.1:6379> Rpush mylist "hello"
    (integer) 1
    127.0.0.1:6379> Rpush mylist "world"
    (integer) 2
    127.0.0.1:6379> LINSERT mylist before "world" "other"
    (integer) 3
    127.0.0.1:6379> LRANGE mylist 0 -1
    1) "hello"
    2) "other"
    3) "world"
    127.0.0.1:6379> LINSERT mylist after "world" "new"
    (integer) 4
    127.0.0.1:6379> LRANGE mylist 0 -11) "hello"
    2) "other"
    3) "world"
    4) "new"

小结：

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

消息排队、消息队列

###### SET（集合） ######

set中的值是不能重复的！

127.0.0.1:6379> sadd mysetv "hello"\  #set集合中添加元素
    Invalid argument(s)
    127.0.0.1:6379> sadd mysetv "hello"
    (integer) 1
    127.0.0.1:6379> sadd mysetv "liu"
    (integer) 1
    127.0.0.1:6379> sadd mysetv "liuxukun"
    (integer) 1
    127.0.0.1:6379> smembers mysetv  #查看指定的set的所有值
    1) "liu"
    2) "liuxukun"
    3) "hello"
    127.0.0.1:6379> sismember mysetv hello #判断一个只是不是在set集合中！
    (integer) 1
    127.0.0.1:6379> sismember mysetv world
    (integer) 0
    127.0.0.1:6379>

*  获取元素的个数

127.0.0.1:6379> scard mysetv
    (integer) 3

*  移除某一个元素

127.0.0.1:6379> srem mysetv hello #移除集合中的某一个元素
    (integer) 1
    127.0.0.1:6379> smembers mysetv
    1) "liu"
    2) "liuxukun"

*  set无序不重复集合。抽随机！

127.0.0.1:6379> SRANDMEMBER mysetv
    "liuxukun"
    127.0.0.1:6379> SRANDMEMBER mysetv
    "liu"
    127.0.0.1:6379> SRANDMEMBER mysetv 2
    1) "liu"
    2) "liuxukun"
    127.0.0.1:6379> SRANDMEMBER mysetv 2
    1) "liu"
    2) "liuxukun"
    127.0.0.1:6379>

*  删除指定的key，随机删除key

127.0.0.1:6379> SMEMBERS mysetv
    1) "liu"
    2) "liuxukun"
    127.0.0.1:6379> spop mysetv  #随机删除set集合中的元素
    "liuxukun"
    127.0.0.1:6379> spop mysetv
    "liu"
    127.0.0.1:6379> SMEMBERS mysetv
    (empty array)
    127.0.0.1:6379>

*  将一个指定的值，移动到另一个set集合！

127.0.0.1:6379> sadd myset "hello"
    (integer) 1
    127.0.0.1:6379> sadd myset "world"
    (integer) 1
    127.0.0.1:6379> sadd myset "liu"
    (integer) 1
    127.0.0.1:6379> sadd myset2 "set2"
    (integer) 1
    127.0.0.1:6379> smove myset myset2 "liu"
    (integer) 1
    127.0.0.1:6379> smembers myset
    1) "world"
    2) "hello"

*  微博，b站，共同关注！（交集）
 *  数字集合类
    
     *  差集 sdiff
     *  交集 sinter
     *  并集sunion

127.0.0.1:6379> sadd key1 a
    (integer) 1
    127.0.0.1:6379> sadd key1 b
    (integer) 1
    127.0.0.1:6379> sadd key1 c
    (integer) 1
    127.0.0.1:6379> sadd key2 c
    (integer) 1
    127.0.0.1:6379> sadd key2 d
    (integer) 1
    127.0.0.1:6379> sadd key2 e
    (integer) 1
    127.0.0.1:6379>  sdiff key1 key2  #求差集
    1) "a"
    2) "b"
    127.0.0.1:6379> sinter key1 key2  #求交集
    1) "c"
    127.0.0.1:6379> sunion key1 key2  #求并集
    1) "c"
    2) "a"
    3) "b"
    4) "d"
    5) "e"

微博，A用户将所有关注的人放在一个set集合中！将他的粉丝页放在一个集合之中。

共同关注，共同爱好，二度好友

###### hash（哈希） ######

Map集合，key-map!时候这个值是一个map集合！本质和String类型没有太大的区别，还是一个简单地key-vlaue！

*  存值和查询

127.0.0.1:6379> hset myhash field1 liu  #set一个具体的key-vlaue
    (integer) 1
    127.0.0.1:6379> hget myhash field1  #获取一个字段值
    "liu"
    127.0.0.1:6379> hmset myhash field1 hello field2 world  #set多个的key-vlaue
    OK
    127.0.0.1:6379> hmget myhash field1 feild2  #获取多个字段值
    1) "hello"
    2) (nil)
    127.0.0.1:6379> hmset myhash field1 hello field2 world
    OK
    127.0.0.1:6379> hmget myhash field1 feild2
    1) "hello"
    2) (nil)
    127.0.0.1:6379> hgetall myhash  #获取全部的数据
    1) "field1"
    2) "hello"
    3) "field2"
    4) "world"

*  删除某一个值

127.0.0.1:6379> hdel myhash field2 #删除指定的值
    (integer) 1
    127.0.0.1:6379> hgetall myhash 
    1) "field1"
    2) "hello"

*  查看hash的字段数量

127.0.0.1:6379> hset myhash field1 hello field2 world f3 liu
    (integer) 2
    127.0.0.1:6379> hgetall myhash
    1) "field1"
    2) "hello"
    3) "field2"
    4) "world"
    5) "f3"
    6) "liu"
    127.0.0.1:6379> hlen myhash
    (integer) 3

*  判断hash中的key是否存在

127.0.0.1:6379> hexists myhash field1
    (integer) 1
    127.0.0.1:6379> hexists myhash field3
    (integer) 0

*  只获取说有的key
 *  只获取所有的vlaue

127.0.0.1:6379> hkeys myhash
    1) "field1"
    2) "field2"
    3) "f3"
    127.0.0.1:6379> hvals myhash
    1) "hello"
    2) "world"
    3) "liu"

*  incr decr

127.0.0.1:6379> hset myhash field3 5  #指定增量
    (integer) 1
    127.0.0.1:6379> hincrby myhash field3 1
    (integer) 6
    127.0.0.1:6379> hincrby myhash field3 -1
    (integer) 5
    127.0.0.1:6379> hsetnx myhash field4 hello  #如果不存在则可以设置
    (integer) 1
    127.0.0.1:6379> hsetnx myhash field4 world  #如果存在则不能设置
    (integer) 0

hash中也可以同时赋予多个值user:1:参考上面的String类型

hash变更的数据user，name，age，尤其是用户信息之类的，经常变动的信息

hash更适合对象的存储 ，String适合字符串的存储

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

在set的基础上，增加了一个值，set k1 v1 zset k1 score1(排序) v1

*  添加一个值

127.0.0.1:6379> zadd myset 1 one #添加一个值
    (integer) 1
    127.0.0.1:6379> zadd myset 2 two 3 three #添加多个值
    (integer) 2
    127.0.0.1:6379> zrange myset 0 -1
    1) "one"
    2) "two"
    3) "three"

*  排序如何实现

127.0.0.1:6379> zadd salary 2500 xiaohong  #添加用户
    (integer) 1
    127.0.0.1:6379> zadd salary 50000 zhangsan
    (integer) 1
    127.0.0.1:6379> zadd salary 500  liu 
    (integer) 1
    127.0.0.1:6379> zrangebyscore myset 0  1000000
    1) "one"
    2) "two"
    3) "three"
    127.0.0.1:6379> zrangebyscore salary 0  1000000  #显示全部用户从小到大排序
    1) "liu"
    2) "xiaohong"
    3) "zhangsan"
    127.0.0.1:6379> zrangebyscore salary -inf +inf 
    1) "liu"
    2) "xiaohong"
    3) "zhangsan"
    
    127.0.0.1:6379> zrevrange salary 0 -1  #从大到小排序
    1) "zhangsan"
    2) "liu"
    127.0.0.1:6379> zrangebyscore salary 0 2000 withscores  #显示所有用户并附带成绩，显示工资小于2000的
    1) "liu"
    2) "500"

*  移除rem中的元素

127.0.0.1:6379> zrange salary 0 -1
    1) "liu"
    2) "xiaohong"
    3) "zhangsan"
    127.0.0.1:6379> zrem salary xiaohong  #移除有序集合中的指定的元素
    (integer) 1
    127.0.0.1:6379> zrange salary 0 -1
    1) "liu"
    2) "zhangsan"
    127.0.0.1:6379> zcard salary  #获取有序集合中元素的个数
    (integer) 2

*  获取指定区间的成员数量

127.0.0.1:6379> zadd myset 1 hello 2 world 3 liu
    (integer) 3
    127.0.0.1:6379> zcount myset 1 3  #获取指区间的成员数量
    (integer) 3
    127.0.0.1:6379> zcount myset 1 2
    (integer) 2

其他的一些api,可以去官方文档进行查询

案例思路：set排序 存储班级成绩表，工资表排序

普通消息1，重要消息2，带权重进行判断

排行榜应用实现，取top

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

###### geospatial 地理位置 ######

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

redis的Geo

*  添加地理位置：两极无法直接添加，我们一般会下载城市数据，直接通过Java导入
 *  参数key 值（纬度、经度、名称）

127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
    (integer) 1
    127.0.0.1:6379> geoadd chian:city 121.47 31.23 shanghai
    (integer) 1
    127.0.0.1:6379> geoadd chian:city 106.50  29.53 chongqing
    (integer) 1
    127.0.0.1:6379> geoadd  chian:city 114.05 22.52 shenzhen
    (integer) 1
    127.0.0.1:6379> geoadd chian:city 120.16 30.24 hangzhou 108.96 34.26 xian
    (integer) 2

*  getpos (获取查询)
 *  获取当前的定位：一定是一个坐标值

127.0.0.1:6379> geopos chian:city chongqing shanghai
    1) 1) "106.49999767541885376"
       2) "29.52999957900659211"
    2) 1) "121.47000163793563843"
       2) "31.22999903975783553"
    127.0.0.1:6379> geopos china:city beijing
    1) 1) "116.39999896287918091"
       2) "39.90000009167092543"

*  查询经纬度范围内的城市

127.0.0.1:6379> georadius china:city 110 30 1000 km
    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 withcoord
    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"

*  geohash命令-返回一个或多个位置元素的geohash表示
 *  该命令将返回11字符的geohash的字符串
 *  将二维的经纬度转换为一维的字符串

127.0.0.1:6379> geohash china:city beijing chongqing
    1) "wx4fbxxfke0"
    2) "wm5xzrybty0"
    127.0.0.1:6379> geohash china:city shanghai
    1) "wtw3sj5zbj0"

geo的底层实现原理其实就是Zset

###### Hyperloglog ######

优点：占用的内存是固定的，2^64不同元素的技术，12kb的内存

什么是基数？

A\{1,3,5,7,9,7\} B\{1,3,5,7\} 基数（不重复的元素）=4，可以接受误差

网页的（uv)访问量（一个人的访问一个望着那多次，安一个人计算）

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

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

127.0.0.1:6379> PFadd mykey a b c d e f g h i j
    (integer) 1
    127.0.0.1:6379> pfcount mykey
    (integer) 10
    127.0.0.1:6379> pfadd mykey2 i j k l m n o p q
    (integer) 1
    127.0.0.1:6379> pfcount mykey2
    (integer) 9
    127.0.0.1:6379> pfmerge mykey3 mykey mykey2  #将mykey和mykey2合并得到mykey3
    OK
    127.0.0.1:6379> pfcount mykey3
    (integer) 17

如果允许容错，那么一定使用hyperloglog

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

###### Bitmaps ######

*  位存储

统计用户信息，活跃，不活跃，登录，未登录，打卡，365打卡！Java打卡=userid status day

两个状态的都可以使用Bitmaps

使用bitmap来记录周一到周日的打卡，

最后可以查看有多少1来得出打卡多少天

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 4
    (integer) 1
    127.0.0.1:6379> getbit sign 6
    (integer) 0

统计打卡记录(后面的数字是字节而不是比特)

127.0.0.1:6379> bitcount sign  0 4
    (integer) 3
    127.0.0.1:6379> bitcount sign  0 3
    (integer) 3
    127.0.0.1:6379> bitcount sign  0 1
    (integer) 3
    127.0.0.1:6379> bitcount sign  1 2
    (integer) 0

## 事务 ##

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

redis事务的本质：一组命令的集合！一个事务中的所有的命令都会被序列化，在序列化中，会按照顺序执行。

*  一次性、顺序性、排他性！执行一些列的命令

----队列 set set set 执行------

redis事务没有隔离的概念。所有的命令在事务中并没有直接执行！轧制油发起命令的时候才会执行 Exec

redis的事务：

*  开启事务（multi）
 *  命令入队（）
 *  执行事务（exec）

锁：redis可以实现乐观锁，watch（监视）

*  正常的事务执行

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 k3 v3
    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)> getset 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)> exec
    (error) EXECABORT Transaction discarded because of previous errors.
    127.0.0.1:6379> get k4
    (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"

*  监控：watch
    
     *  悲观锁：认为什么时候都会出现问题，无论什么都会加上锁
     *  乐观锁：认为什么时候都不会出现问题，所以不会上锁，更新数据的时候判断一下，在此期间是否有人修改过这个数据
        
         *  获取version
         *  更新的时候比较version
    
        127.0.0.1:6379> set money 100
        OK
        127.0.0.1:6379> set out 0
        OK
        127.0.0.1:6379> watch money #监视money
        OK
        127.0.0.1:6379> multi #事务正常结束	，数据期间没有发生变动，这个时候就正常执行成功
        OK
        127.0.0.1:6379(TX)> decrby monry 20
        QUEUED
        127.0.0.1:6379(TX)> incrby out 20
        QUEUED
        127.0.0.1:6379(TX)> exec
        1) (integer) -20
        2) (integer) 20
        127.0.0.1:6379> multi
        OK
        127.0.0.1:6379(TX)> decrby money 20
        QUEUED
        127.0.0.1:6379(TX)> incrby out 20
        QUEUED
        127.0.0.1:6379(TX)> exec
        1) (integer) 80
        2) (integer) 40
 *  测试多线程修改值，使用watch可以当做redis的乐观锁操作

127.0.0.1:6379> watch money  #监视money
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379(TX)> decrby money 10
    QUEUED
    127.0.0.1:6379(TX)> incrby out 10
    QUEUED
    127.0.0.1:6379(TX)> exec #执行之前另外一个线程修改了我们的值，这个时候就会导致事务执行失败
    (nil)

127.0.0.1:6379> get money
    "80"
    127.0.0.1:6379> set money 1000
    OK

*  如果修改失败获取最新值就好

![image2022031214081401516470652968751.png][]

## Jedis ##

1、导入对应的依赖

<dependencies>
            
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>4.1.1</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.60</version>
            </dependency>
        </dependencies>

2、编码测试

*  链接数据库
 *  操作命令
 *  断开连接

## springboot整合 ##

springboot操作数据：springdata jpa jdbc mongodb redis

springdata也是和springboot齐名的项目！

说明：在springboot2.X之后，原来使用的jedis被替换成lettuce

jedis:采用的是直连，多个线程操作的话，是不安全的，使用jedis pool连接池。更像BIO模式

lettuce：采用netty,实例可以在多个线程中进行共享，不存在线程不安全的的情况！减少线程数量，更像Nio模式

源码分析：

默认的redisTemplate没有过多的设置，redis对象都是需要序列化的

dubbo所有实体都是序列化

两个泛型都是Object, Object的类型，我们使用需要强制转换<String,Object>

我们可以自己定义一个redisTemplate来替换这个默认的

@Bean
        @ConditionalOnMissingBean(
            name = {
        "redisTemplate"}
        )
        @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        
            RedisTemplate<Object, Object> template = new RedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        @Bean
        @ConditionalOnMissingBean
        @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        
            return new StringRedisTemplate(redisConnectionFactory);
        }

###### 整合测试 ######

1、导入依赖

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

2、配置连接

spring.redis.host=127.0.0.1
    spring.redis.port=6379

3、测试！

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

## Redis.conf详解 ##

> 网络：

*  bind 127.0.0.1 \#绑定的ip
 *  protected-mode yes \#保护设置
 *  port 6379 \#端口设置

> 通用设置：

*  daemonize yes \#以守护进程的方式运行，默认是no,我们需要自己开启为yes
 *  pidfile /var/run/redis\_6379.pid \#如果以后后台的方式运行，我们就需要一个指定pid文件
 *  日志（debug、verbose（差不多和debug一样）、notice（生产环境）、warning（警告））
 *  logfile"" \#日志文件位置名
 *  database 16 \#数据库数量，默认是16个
 *  always-show-logo yes\#是否总是显示logo

> 快照：

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

redis是内存数据库，如果没有持久化，那么数据就会断电即失

*  save 900 1 如果900秒内，至少有一个key进行了操作，我们就进行持久化操作
 *  save 300 10 如果300秒内，至少有10个key进行了操作，我们就进行持久化操作
 *  save 60 10000 如果60秒内，至少有10000个key进行了操作，我们就进行持久化操作
 *  之后可以自定义
 *  stop-writes-on-bgsave-error yes \#持久化如果出错，是否还需要继续工作
 *  rdbcompression yes \#是否压缩rdb文件，需要消耗一些CPU的资源
 *  redbchecksum yes\#保存rdb文件的时候，进行错误校验的
 *  dir ./ \#rdb文件保存的目录

> REPLICATION复制，后面讲解主从复制的时候在进行讲解

> SECURITY安全

*  可以设置redis的密码，默认是没有密码的

> 限制CLIENTS

*  maxclients 10000 \#设置能连接上redis的在最大客户数量
 *  maxmemory \#redis配置最大的内存容量
 *  maxmemory-policy noeviction \#内存内存到达上限的处理策略。移除一些过期的key、报错、。。。。。

1、volatile-lru：只对设置了过期时间的key进行LRU（默认值）

2、allkeys-lru ： 删除lru算法的key

3、volatile-random：随机删除即将过期key

4、allkeys-random：随机删除

5、volatile-ttl ： 删除即将过期的

6、noeviction ： 永不过期，返回错误

> APPEND ONLY模式 aof模式

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

## Redis持久化 ##

###### RDB：Redis Databases ######

在主从复制中，rdb就是备用的，在从机上面

![image2022031315294500016471565870042.png][]

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

Redis会单独的创建（fork)一个子进程来持久化，会先将数据写入到一个临时文件中，带持久化过程都结束了，在用这个临时文件替换上次持久化好的文件，整个过程中，主进程不进行任何的I/O操作。这就确保了极高的性能。如果需要进行大规模的数据恢复，且对于数据恢复的完整性不是非常敏感，那rdb方式要比aof方式更加的高效，rdb的缺点是最后一次持久化后的数据可能丢失

> 触发机制

1.  save的规则满足的情况下，会自动触发rdb原则
2.  执行flushall命令，也会触发我们的rdb原则
3.  退出redis，也会自动产生rdb文件

> 如何恢复rdb文件

1.  只需将rdb文件放在redis启动目录就可以了，redis启动的时候会自动检查dump.rdb恢复其中的数据
2.  查看需要存在的位置
    
        127.0.0.1:6379> config get dir
        1) "dir"
        2) "/www/server/redis"  #如果在这个目录下存在dump.rdb文件，启动时就会自动恢复其中的数据

优点：

1.  适合大规模的数据恢复！ dump.rdb
2.  对数据的完整性要求不高

缺点:

1.  需要一定的时间间隔进程操作，如果redis意外宕机， 这个修改最后一次数据就没有了
2.  fork进程的时候，会占用一定的内容空间

###### AOF(Append Only file) ######

aof默认的就是文件的无限追加，文件就会越来越大

将我们的所有命令都记录下来，恢复的时候就把这文件全部执行一遍

默认是不开启，需要手动配置，将appendonly改为yes就会开启aof

重启，redis就可以生效了

如果这个aof文件有错误，这个时候redis时启动不起来的，需要修复这个文件。redis提供了一个工具`redis-check-aof --fix`\+要修复的文件名

如果aof文件大于64m,fork一个新的进程来将我们的文件进行重写

> 优点和缺点

优点：

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

缺点：

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

##### 扩展 #####

1.  RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储  
    ![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZsODU0NQ==,size\_16,color\_FFFFFF,t\_70pic\_center.png][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZsODU0NQ_size_16_color_FFFFFF_t_70pic_center.png]

###  ###

RDB 和 AOF 对比

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>RDB</th> 
   <th>AOF</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 恢复的速度要快。

## redis发布订阅 ##

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

redis客户端可以订阅任意数量的频道

订阅/发布消息图：

第一个：消息发送者 第二个：频道 第三个：消息订阅者

![image2022031315442720716471574685313.png][]

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

![20200513215523258.png][]

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

![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw==,size\_16,color\_FFFFFF,t\_70.png][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_70.png]

命令

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PSUBSCRIBE pattern [pattern…]</td> 
   <td>订阅一个或多个符合给定模式的频道。</td> 
  </tr> 
  <tr> 
   <td>PUNSUBSCRIBE pattern [pattern…]</td> 
   <td>退订一个或多个符合给定模式的频道。</td> 
  </tr> 
  <tr> 
   <td>PUBSUB subcommand [argument[argument]]</td> 
   <td>查看订阅与发布系统状态。</td> 
  </tr> 
  <tr> 
   <td>PUBLISH channel message</td> 
   <td>向指定频道发布消息</td> 
  </tr> 
  <tr> 
   <td>SUBSCRIBE channel [channel…]</td> 
   <td>订阅给定的一个或多个频道。</td> 
  </tr> 
  <tr> 
   <td>SUBSCRIBE channel [channel…]</td> 
   <td>退订一个或多个频道</td> 
  </tr> 
 </tbody> 
</table>

> 测试

订阅端：

127.0.0.1:6379> SUBSCRIBE liu  #订阅一个频道
    Reading messages... (press Ctrl-C to quit)
    1) "subscribe"
    2) "liu"
    3) (integer) 1
    #等待读取推送的信息
    1) "message"
    2) "liu"
    3) "hello,liu"
    
    1) "message"
    2) "liu"
    3) "hello,ya"

发送端：

127.0.0.1:6379> PUBLISH liu "hello,liu"  #发布者发布消息到频道
    (integer) 1
    127.0.0.1:6379> PUBLISH liu "hello,ya"
    (integer) 1

> 原理

redis是通过publish、subscribe、和psubscribe等命令实现发布和订阅功能通过subscribe命令订阅某频道后，redis-server里维护了一个 字典，字典的键就是一个个的channel（通道、频道），而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。subscribe命令的关键，就是讲客户端添加到给定channel的订阅链表中。  
通过publish命令想订阅者发送消息，redis-server会使用给定的频道作为键，在他所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表，便利这个链表，将消息发布给所有订阅者。  
pub/sub在字面上理解就是发布（publish）与订阅（subscribe），在redis中，你可以设定对某个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会受到相应的消息，这一功能最明显的用法就是用作实时消息系统，例如群聊等

使用场景：

1.  实时消息系统
2.  实时聊天！（频道当做聊天室，将信息回显给所有人即可）
3.  订阅，关注系统都是可以的

稍微复杂的场景会使用消息中间件MQ()

###### Redis主从复制 ######

> 概念

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

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

> 作用

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

> 为什么使用集群

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

![image202203131611209821647159082257716471594050398.png][]

主从复制，读写分离！减缓服务器压力，一组二从

###### 环境配置 ######

只配置从库，不用配置主库

127.0.0.1:6379> info replication  #查看当前库的信息
    # Replication
    role:master        #角色
    connected_slaves:0  #没有从机
    master_failover_state:no-failover
    master_replid:cf22b3f99c56b05e1ce17964de89544cc0d03177
    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

复制三个配置文件，然后修改对应的信息

1.  端口
2.  pid名字
3.  log文件名字
4.  dump.rdb名字

##### 一主二从 #####

==默认情况下，每台redis服务器都是主节点；==我们一般情况下只用配置从机就好了

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379  # SLAVEOF host 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:7
    master_sync_in_progress:0
    slave_repl_offset:70
    slave_priority:100
    slave_read_only:1
    replica_announced:1
    connected_slaves:0
    master_failover_state:no-failover
    master_replid:4a6cbf67a48f12717d9fa5f0231bc7b50bbe6325
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:70
    second_repl_offset:-1
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:1
    repl_backlog_histlen:70

127.0.0.1:6379> info replication   
    # Replication
    role:master
    connected_slaves:1  #多了从机的配置
    slave0:ip=127.0.0.1,port=6380,state=online,offset=42,lag=0
    master_failover_state:no-failover
    master_replid:4a6cbf67a48f12717d9fa5f0231bc7b50bbe6325
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:42
    second_repl_offset:-1
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:1
    repl_backlog_histlen:42

如果两个都配置完了，就会有两个从机

![image2022031320475362716471756748311.png][]

真实的主从配置应该配置文件配置，这样的话是永久的

> 细节

主机可以写，从机不能写只能读。主机中的所有数据都会被从机保存。

测试：主机断开连接，从机依旧连接到主机的，但是没有写操作，这个时候，主机如果回来了，从机依旧可以直接获取主机写的信息！

如果使用命令行来配置的主从，这个时候如果重启了，就会变成主机。只要变为从机，就会立马从主机那里获取值，可以进行读操作

> 复制原理

当slave启动成功连接到master后会发送一个sync同步命令，

master接到命令后，启动后台的存盘进程，同事手机所有接收到的用于修改数据集命令，在后台进程执行完毕后，master将传送整个数据文件到slaver，并完成一次完全同步，这就是全量复制。之后master又有更新，会同步给其他从机，这就是增量复制。  
全量复制：slave服务在接收到数据库文件数据后，将其存盘并加载到内存中  
增量复制：master继续将新的所有收集到的修改命令依次传给slave，完成同步  
只要重新连接了主机，就一定会有一次全量复制

![image2022031321240745816471778490462.png][]

对应到slaveof中就是6379为主机，6380Slaveof6379,6381Slaveof6380，这种配置中这个6380即是主机又是从机，那么如果这个时候6379宕机了6380会怎么样，使用命令info replication查看后发现，这个6380依然是从机。因此上面两种配置在我们工作的时候多不会用。手动配置主机

> 手动配置主机

在没有哨兵模式之前，我们主机宕机之后，需要手动指定主机，使用命令`Slaveof no one`，表示没有任何一个从机，我就是主机。然后在给其他从机重新Slaveof 到新的主机。如果这个时候原来的主机又上线了，那么他依然是个主机。

## 哨兵模式 ##

> 概述

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

谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

哨兵模式是一种特殊的模式，首先redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程会独立运行，其原理是哨兵通过发送命令，等待redis服务器响应，从而监控运行多个redis实例

单机单个哨兵

![image2022031408210512816472172672331.png][]

哨兵的作用：

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

多哨兵模式

哨兵之间也可以互相监控

![image2022031408264681316472176080602.png][]

> 测试

1、配置哨兵配置文件sentinel79.conf

#sentienl monitor 被监控的名称 host port 1
    sentienl monitor myredis 127.0.0.1 6379 1

sentinel monitor <master-group-name> <ip> <port> <quorum>

sentienl monitor是告诉哨兵监控一个叫做mymaster的实例，它的地址与端口分别是127.0.0.1和6379，然后quorum是什么意思呢？

c它是一个权重，如果为2，也就是说最少有2个哨兵认为此主服务down了，授权给它发起援救程序。

c事实上quorum只是用于检测故障，而实行救援，将选举出某个哨兵，并被授权负责救援工作才能实行，而只有在多数哨兵在岗的情况下才能实行选举并实行这项任务。

例如有5个在岗哨兵，主服务的quorum被设置为2，那将发生什么情况：

c如果有两个哨兵认为主服务down了，那它们两中的一个负责与救援工作。

c这里最少有三个哨兵在岗，并想到能交互，救援工作才能被授权，真实的救援工作才能开始。

事实上，如果多数(这里多数少数的概念应该是对半分，超过50%为多数)的哨兵不在岗，不能相互交互，那救援工作是不可能实行的。

2、启动哨兵

![image2022031409301907916472214204533.png][]

如果Master节点断开了，这个时候就会从从机中随机选取一个服务器！(这个里面有一个投票算法)

![image2022031409500117016472226024595.png][]

![image2022031409493532116472225764294.png][]

如果主机此时回来了，只能归并到新的主机下，当做从机，这个就是哨兵模式

> 哨兵模式

优点：

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

缺点：

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

> 哨兵模式的全部配置

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

> 解决方案

布隆过滤器

![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw==,size\_16,color\_FFFFFF,t\_70.jpeg][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_70.jpeg]

对所有可能查询的参数以Hash的形式存储，以便快速确定是否存在这个值，在控制层先进行拦截校验，校验不通过直接打回，减轻了存储系统的压力。

缓存空对象

一次请求若在缓存和数据库中都没找到，就在缓存中方一个空对象用于处理后续这个请求。

![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw==,size\_16,color\_FFFFFF,t\_7016472254663257.jpeg][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_7016472254663257.jpeg]

这样做有一个缺陷：存储空对象也需要空间，大量的空对象会耗费一定的空间，存储效率并不高。解决这个缺陷的方式就是`设置较短过期时间`

即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

**缓存击穿（量太大，缓存过期）**

> 概念

相较于缓存穿透，缓存击穿的目的性更强，一个存在的key，在缓存过期的一刻，同时有大量的请求，这些请求都会击穿到DB，造成瞬时DB请求量大、压力骤增。这就是缓存被击穿，只是针对其中某个key的缓存不可用而导致击穿，但是其他的key依然可以使用缓存响应。

比如热搜排行上，一个热点新闻被同时大量访问就可能导致缓存击穿。

> 解决方案

1.  设置热点数据永不过期

这样就不会出现热点数据过期的情况，但是当Redis内存空间满的时候也会清理部分数据，而且此种方案会占用空间，一旦热点数据多了起来，就会占用部分空间

2.加互斥锁(分布式锁)

在访问key之前，采用SETNX（set if not exists）来设置另一个短期key来锁住当前key的访问，访问结束再删除该短期key。保证同时刻只有一个线程访问。这样对锁的要求就十分高。

![image20220314104441006.png][]

**缓存雪崩**

> 概念

大量的key设置了相同的过期时间，导致在缓存在同一时刻全部失效，造成瞬时DB请求量大、压力骤增，引起雪崩。

![watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw==,size\_16,color\_FFFFFF,t\_7016472256121519.jpeg][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_7016472256121519.jpeg]

> 解决方案

*  redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群

*  限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

*  数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

[image2022031214081401516470652968751.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b2473250ef2343e6bd957590710fc4a8.png
[image2022031315294500016471565870042.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/86c003eaa9be4b38aabefebdc1024815.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZsODU0NQ_size_16_color_FFFFFF_t_70pic_center.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a301504b85e94dc0a1928451c1c13d0a.png
[image2022031315442720716471574685313.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f3f336eac9bb4c8796d6e697559a71bf.png
[20200513215523258.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a0efcb56cd4c4ca9951a4071fa2efedd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/04aa0e32921f49828a2c2317f7836147.png
[image202203131611209821647159082257716471594050398.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/fffa498d2f57493ba3e0485592f1ae07.png
[image2022031320475362716471756748311.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/22068c54f6ef441ca560883988b0fcd5.png
[image2022031321240745816471778490462.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4f830cea750d43d29bb37a9683476e1b.png
[image2022031408210512816472172672331.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6308571263444fd2a973f7bfb768246b.png
[image2022031408264681316472176080602.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/154dbcbe5e2c4f4392df38bf6fb56303.png
[image2022031409301907916472214204533.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/0665699a079e4d55a595680162480805.png
[image2022031409500117016472226024595.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/fbd743a348c8479184b538ace59ce65e.png
[image2022031409493532116472225764294.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/05f3c5972b084bbf8e46baafdb3e2aae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_70.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d363b795ef8947aca2a6e023c6447c2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_7016472254663257.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/15170373741845e79e36ee31ff9e7071.png
[image20220314104441006.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9081da097d104e01b5b4b3bfd6938da2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg3MzIyNw_size_16_color_FFFFFF_t_7016472256121519.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8d02ee03426442729c9b6e519971b1c7.png