Redis学习总结

Redis

• 视频学习地址：https://space.bilibili.com/95256449/?spm_id_from=333.999.0.0
• 学习代码总结：https://gitee.com/liang-weihao/study-redis-in-april-2023

Nosql

为什么要用nosql

• redis-cli -p 6379

1、

• 单机mysql年代
• 大数据时代
• 大数据一般的数据库无法进行分析处理！
• 数据的索引（b+ tree）超过300w数据就要加索引
• 访问量过大，一个服务器承受不了

2、

• memcached（缓存）+mysql+垂直拆分（读写分离）
• 网站多数都是在读，可以通过缓存减轻压力

发展过程：优化数据结构和索引–》文件缓存（io）–》memcached

3、

• 分库分表+水平拆分+mysql集群

本质：数据库（读，写 ）

4、如今最近的年代

• mysql等关系型数据库不够用，数据量很大，变化很快

5、目前互联网项目

为什么要用nosql！

• 用户的个人信息，社交网络，地理位置。用户产生数据，用户日志日渐增长
• 这个时候我们用nosql就可以很好处理这个问题

什么是nosql

• nosql = not only sql（不仅仅是sql）
• 泛指非关系关系型数据库

特点：

• 解耦

• 方便扩展，k-v键值对（数据之间没有关系，很好扩展）

• 大数据量高性能（redis：读：一秒11w， 写一秒8w）

• 数据多类型（不需要写设计数据库）

• 传统rdbms和nosql

传统的rdbms

• 结构化组织
• sql
• 数据和关系都存在单独表中
• 操作，数据定义语言
• 严格的一致性
• 基础的事务操作

nosql

• 不仅仅是数据
• 没有固定的查询语言
• 键值对存储，列存储，文档存储，图形数据库
• 最终一致性
• cap定理和base（异地多活，保持不宕机）
• 高性能，高可用，高可扩

真正公司实践：nosql+rdbms一起使用

• 阿里巴巴历程
  

Nosql的四大分类

• kv键值对
• 文档型数据库
  • MongoDB（一般必须要掌握）
    • MongoDB是一个居于分布式文件存储的数据库，c++编写，处理大量文档
    • MongoDB是一个介于关系型数据库和非关系型数据库的中间产品，最像关系型数据库
• 列存储数据库
  • HBASE
  • 分布式文件系统
• 图关系数据库
  

Redis概述

• 非关系型数据库

redis是什么？

redis能干嘛？

1. 内存存储、持久化，内存是断电即失，持久化很重要（rdb、aof）
2. 效率高
3. 发布订阅系统
4. 地图信息分析
5. 计时器，浏览量

redis特性

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

redis推荐在Linux搭建

windows安装

• 双击redis-server.exe启动即可
  
• 启动redis后，双击redis-cli.exe启动客户端，测试是否启动成功
  

Linux安装

• 下载上传

• 解压：tar -zxvf

• source /etc/profile：刷新文件
rpm -ivh jdk-8u361-linux-x64.rpm：下载安装jdk

• 进入redis
  

• 基本的环境安装 yum install gcc-c++
  

• 然后执行make命令

• redis默认安装路径：usr/java/opt
  

• vim redis.conf
  

• ctrl+c :wq保存退出编辑文件

• 启动redis服务

• 启动成功
  

• 使用redis-cli客户端进行连接测试
  

• 查看redis进程是否开启 ps -ef|grep redis
  

• • 关闭redis服务器 shutdown

• 停掉redis服务后，这边redis-cli 和redis-server已经没了
  

测试性能

测试：100个并发连接 十万请求

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

基础的知识

• redis默认有16个数据库
• 可以select 3 切换数据库
• dbsise查看db大小

• 查看当前数据库所有的key：key*
• 清空当前所有数据库：flushall
• 清空当前数据库：flushdb

redis是单线程!

redis很快，基于内存操作，瓶颈是机器内存和网络带宽

redis为什么单线程还这么快？（c语言写的）

1. 误区1：高性能服务器一定是多线程？
2. 误区2：多线程一定比单线程效率高

先CPU》内存》硬盘速度

核心：redis将所有数据全部放在内存中，所以说使用单线程操作效率高，多线程（CPU上下文切换：耗时），对于内存系统没有上下文切换就是效率最高的，多次读写都是在CPU上的，这才是最佳的方案

五大基本类型

概述：

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

127.0.0.1:6379> set name lwh 5
(error) ERR syntax error
127.0.0.1:6379> expire name 5 设置过期时间5s
(integer) 1
127.0.0.1:6379> ttl name  查看当前key是否过期 -2 已过期
(integer) -2
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> move name 移除当前key
127.0.0.1:6379> type name 查看当前value的类型
string

• string
• list
• set
• hash
• zset

string（字符串）

127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> get key
(nil)
127.0.0.1:6379> get key1
"v1"
127.0.0.1:6379> append key1 hello  追加字符串，如果不存在就等于添加多一个key
(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 lwh
(integer) 10
127.0.0.1:6379> strlen key1 值长度
(integer) 10
127.0.0.1:6379> get key1
"v1hellolwh"
***************************************************************
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views
(integer) 1
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> 
127.0.0.1:6379> incr views
(integer) 3
127.0.0.1:6379> incr views  加一
(integer) 4
127.0.0.1:6379> incr views
(integer) 5
127.0.0.1:6379> get views
"5"
127.0.0.1:6379> decr views 减一
(integer) 4
127.0.0.1:6379> decr views
(integer) 3
127.0.0.1:6379> inceby views 10
(error) ERR unknown command 'inceby', with args beginning with: 'views' '10' 
127.0.0.1:6379> incrby views 10 增
(integer) 13
127.0.0.1:6379> incrby views 10
(integer) 23
127.0.0.1:6379> decrby views 10  减
(integer) 13
**********************************************************
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set key1 hello lwh
(error) ERR syntax error
127.0.0.1:6379> get key1
(nil)
127.0.0.1:6379> set key1 hellolwh
OK
127.0.0.1:6379> get key1
"hellolwh"
127.0.0.1:6379> getrange key1 0 3 获取字符串
"hell"
127.0.0.1:6379> getrange key1 0 -1 获取全部字符串
"hellolwh"
127.0.0.1:6379> 
**********************************************************
127.0.0.1:6379> set key2 abc
OK
127.0.0.1:6379> get key2
"abc"
127.0.0.1:6379> setrange key2 1 xx 替换指定位置字符串
(integer) 3
127.0.0.1:6379> get key2
"axx"
127.0.0.1:6379> 

**********************************************************
setex       设置过期时间
setnx       不存在就设置
127.0.0.1:6379> setex key2 30 "hello"
OK  设置30秒过期
127.0.0.1:6379> ttl key2
(integer) 24
127.0.0.1:6379> get key2
"hello"
127.0.0.1:6379> setnx mykey "redis"
(integer) 1
127.0.0.1:6379> keys *
1) "mykey"
2) "key1"
127.0.0.1:6379> setnx mykey "mysql"
(integer) 0
127.0.0.1:6379> get mykey
"redis"
127.0.0.1:6379> 

**********************************************************
mset
mget
127.0.0.1:6379> mset k1 a k2 b k3 c 同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
127.0.0.1:6379> mget k1 k2 k3 同时获取多个值
1) "a"
2) "b"
3) "c"
127.0.0.1:6379> msetnx k1 a k4 d  不存在就set，原子性，要么都成功要么都失败
(integer) 0
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"

# 对象
127.0.0.1:6379> mset user:1:name lwh user:1:age 2
OK	
127.0.0.1:6379> mget user:1:name user:1:age
1) "lwh"
2) "2"

**********************************************************
127.0.0.1:6379> getset db redis
(nil)
127.0.0.1:6379> get db 如果存在值则获取原来的值并设置新的值
"redis"
127.0.0.1:6379> getset db mysql
"redis"
127.0.0.1:6379> get db
"mysql"



**********************************************************

List

• 可以用作栈（先进后出）或者队列（先进先出）
• 所有的list命令都是l开头，redis不区分大小写

127.0.0.1:6379> lpush list two
(integer) 1
127.0.0.1:6379> lpush list one
(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) "one"
3) "two" 现进后出

**********************************************************
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"
3) "two"
4) "reig"
127.0.0.1:6379> lpop list 移除元素（l左r右）
"three"
127.0.0.1:6379> rpop list
"reig"
127.0.0.1:6379> 

**********************************************************
127.0.0.1:6379> lindex list 0 通过下标获取list值
"one"
127.0.0.1:6379> 

**********************************************************
127.0.0.1:6379> lpush list 1  查看当前list长度
(integer) 1
127.0.0.1:6379> lpush list 2
(integer) 2
127.0.0.1:6379> lpush list 3
(integer) 3
127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> llen list
(integer) 3
127.0.0.1:6379> 

**********************************************************
移除指定的值
127.0.0.1:6379> llen list
(integer) 3
127.0.0.1:6379> lrem list 1 1 移除指定个数的值 中间1代表相同的值移除去几个
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "3"
2) "2"
127.0.0.1:6379> 

**********************************************************
trim 修剪。截断
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> lrange list 0 -1
(empty array)
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "hello1"
3) "hello2"
4) "hello3"
127.0.0.1:6379> ltrim mylist 1 2 通过下标截取指定的长度，截取后只剩下被截取的数据
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello1"
2) "hello2"

**********************************************************
rpoplpush 移除列表的最后一个元素，移动到新的列表

127.0.0.1:6379> rpush mylist heelo
(integer) 1
127.0.0.1:6379> rpush mylist heelo1
(integer) 2
127.0.0.1:6379> rpush mylist heelo2
(integer) 3
127.0.0.1:6379> rpoplpush mylist myotherlist
"heelo2"
127.0.0.1:6379> lrange mylist 0 -1
1) "heelo"
2) "heelo1"
127.0.0.1:6379> lrange myotherlist 0 -1
1) "heelo2"

**********************************************************
127.0.0.1:6379> lset list 0 item  将列表指定下标的值替换为另外的值，先判断是否存在，如果不存在列表去更新就会报错，存在就会被update
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "value1"
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> 


**********************************************************
linsert 将某一个具体的值插到列表的某个元素前面或者后面位置
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 lwh
(integer) 3
127.0.0.1:6379> lrange mylist
(error) ERR wrong number of arguments for 'lrange' command
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "lwh"
3) "world"
127.0.0.1:6379> linsert mylist after  lwh  test
(integer) 4
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "lwh"
3) "test"
4) "world"

set（集合）

set的值不能重复

127.0.0.1:6379> sadd myset hello
(integer) 1
127.0.0.1:6379> sadd myset lwh
(integer) 1
127.0.0.1:6379> smembers myset 查看元素
1) "hello"
2) "lwh"
127.0.0.1:6379> sismember myset lwh 判断值是否在set中
(integer) 1
127.0.0.1:6379> sismember myset lwhs
(integer) 0
127.0.0.1:6379> 

**********************************************************
127.0.0.1:6379> scard myset
(integer) 2
127.0.0.1:6379> scard myset lwh 不可重复
(error) ERR wrong number of arguments for 'scard' command
127.0.0.1:6379> scard myset 获取元素个数
(integer) 2
127.0.0.1:6379> 

**********************************************************
127.0.0.1:6379> srem myset hello 移除元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 1

**********************************************************
set 无序不重复集合
127.0.0.1:6379> smembers myset 
1) "lwh123"
2) "lwh1"
3) "lwh12"
4) "lwh"
5) "lwh1233"
127.0.0.1:6379> srandmember myset  随机抽出一个元素
"lwh12"
127.0.0.1:6379> srandmember myset
"lwh12"
127.0.0.1:6379> srandmember myset
"lwh"
127.0.0.1:6379> srandmember myset
"lwh1"
127.0.0.1:6379> srandmember myset
"lwh"
127.0.0.1:6379> srandmember myset
"lwh12"
127.0.0.1:6379> 

**********************************************************
删除指定的可以，随机删除key
127.0.0.1:6379> smembers myset
1) "lwh123"
2) "lwh1233"
3) "lwh12"
4) "lwh1"
5) "lwh"
127.0.0.1:6379> spop myset  随机删除一个元素
"lwh123"
127.0.0.1:6379> smembers myset
1) "lwh1233"
2) "lwh12"
3) "lwh1"
4) "lwh"
127.0.0.1:63

**********************************************************
将一个指定的值，移动到另外一个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 lwh
(integer) 1
127.0.0.1:6379> sadd myset2 set2
(integer) 1
127.0.0.1:6379> smembers myset
1) "hello"
2) "lwh"
3) "world"
127.0.0.1:6379> smove myset myset2 lwh
(integer) 1
127.0.0.1:6379> smembers myset
1) "hello"
2) "world"
127.0.0.1:6379> smembers myset2
1) "set2"
2) "lwh"

**********************************************************
微博，b站，共同关注（并集）
数字集合类：
- 差集
- 交集
- 并集
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 b
(integer) 1
127.0.0.1:6379> sadd key2 a
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> sdiff key1 key2
(empty array)
127.0.0.1:6379> sdiff key1 key2
(empty array)
127.0.0.1:6379> smembers key1
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> smembers key2
1) "a"
2) "c"
3) "e"
4) "b"
127.0.0.1:6379> sdiff key2 key1 差集
1) "e"
127.0.0.1:6379> sinter key1 key2 交集
1) "c"
2) "a"
3) "b"
127.0.0.1:6379> sunion key1 key2 并集
1) "a"
2) "c"
3) "e"
4) "b"

**********************************************************

**********************************************************

Hash（哈希）

• map集合，key-map，是一个map集合，本质和string类型没有太大区别
• hash更适合对象的存储，string更适合字符串存储

127.0.0.1:6379> hset myhash filed1 lwh set值
(integer) 1
127.0.0.1:6379> hget myhash filed1
"lwh"
127.0.0.1:6379> hmset myhash filed1 heelo filed2 world set多个key-value
OK
127.0.0.1:6379> hmget myhash filed1 filed2  获取多个字段值
1) "heelo"
2) "world"
127.0.0.1:6379> hgetall myhash  获取全部的数据
1) "filed1"
2) "heelo"
3) "filed2"
4) "world"


**********************************************************
127.0.0.1:6379> hdel myhash filed1  删除对应key，对应的value也没了
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "filed2"
2) "world"

**********************************************************
hlen
127.0.0.1:6379> hlen myhash 获取hash值的数量
(integer) 2
127.0.0.1:6379> 


**********************************************************
127.0.0.1:6379> hexists myhash filed1 判断是hash中指定的字段是否存在
(integer) 1
127.0.0.1:6379> hexists myhash filed3
(integer) 0
127.0.0.1:6379> 

**********************************************************
127.0.0.1:6379> hkeys myhash 获取所有的filed
1) "filed2"
2) "filed1"
127.0.0.1:6379> hvals myhash 获取所有的value
1) "world"
2) "heelo"


**********************************************************
incr 
127.0.0.1:6379> hset myhash filed3 5
(integer) 1
127.0.0.1:6379> hincrby myhash filed3 1 指定增量
(integer) 6
127.0.0.1:6379> hincrby myhash filed3 -1
(integer) 5
127.0.0.1:6379> hsetnx myhash filed4 hello  如果不存在则可以设置存在则不能设置
(integer) 1
127.0.0.1:6379> hsetnx myhash filed4 hel
(integer) 0

Zset（有序集合）

在set的基础上，增加一个值，set k1 v1 zset k1 score v1

127.0.0.1:6379[1]> zadd myset 1 one
(integer) 1
127.0.0.1:6379[1]> zadd myset 2 two 3 three
(integer) 1
127.0.0.1:6379[1]> zrange myset  0 -1
1) "one"
2) "two"
3) "three"

**********************************************************
移除元素rem
127.0.0.1:6379[1]> zrange sa 0 -1
1) "lwh"
2) "lw1h"
3) "lw1h2"
127.0.0.1:6379[1]> zrem sa lwh
(integer) 1
127.0.0.1:6379[1]> zrange sa 0 -1
1) "lw1h"
2) "lw1h2"

127.0.0.1:6379[1]> zcard sa 获取有序集合中的个数
(integer) 2

**********************************************************
获取指定区间的数量
127.0.0.1:6379[1]> zadd myset 2 world 3 lwh 1 hello
(integer) 3
127.0.0.1:6379[1]> zcount myset 1 3
(integer) 3



**********************************************************

127.0.0.1:6379[1]> zadd sa 2000 lwh
(integer) 1
127.0.0.1:6379[1]> zadd sa 3000 lw1h
(integer) 1
127.0.0.1:6379[1]> zadd sa 5000 lw1h2
(integer) 1
127.0.0.1:6379[1]> zrangebyscore sa -inf +inf 正无穷负无穷，根据工资排序
1) "lwh"
2) "lw1h"
3) "lw1h2"
127.0.0.1:6379[1]> 

127.0.0.1:6379[1]> zrangebyscore sa -inf +inf withscores
1) "lwh"
2) "2000"
3) "lw1h"
4) "3000"
5) "lw1h2"
6) "5000"
127.0.0.1:6379[1]> zrangebyscore sa -inf 3000 withscores 显示附带成绩
1) "lwh"
2) "2000"
3) "lw1h"
4) "3000"

127.0.0.1:6379[1]> zrevrange sa 0 -1 从大到小排序（降序）
1) "lw1h2"
2) "lw1h"

三种特殊数据类型

geospatial 地理位置

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

城市经度纬度查询：http://www.jsons.cn/lngcode/

只有六个命令

getadd

添加地理位置
两极无法添加
127.0.0.1:6379[1]> geoadd china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379[1]> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379[1]> geoadd china:city 114.05 22.52 shenzhen
(integer) 1

获取指定城市的经度纬
127.0.0.1:6379[1]> geopos china:city beijing 度
 1) "116.39999896287918091"
   2) "39.90000009167092543"


两城市的距离
127.0.0.1:6379[1]> geodist china:city beijing shanghai
"1067378.7564"


获得所有的附近的人地址，定位，通过半径查询（必须存在key中）
127.0.0.1:6379[1]> georadius china:city 110 30 1000 km
1) "shenzhen"


127.0.0.1:6379[1]> georadius china:city 110 30 1000 km withdist withcoord count 1 筛选出指定的结果
1) 1) "shenzhen"
   2) "924.6408"
   3) 1) "114.04999762773513794"
      2) "22.5200000879503861"

Hyperloglog

什么是基数？

• 不重复的元素

Bitmap

位存储

事务

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

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

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

redis事务没有隔离级别的概念

所有的命令在事务中，并没有被直接执行！发起执行命令才会执行！exec

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

redis的事务：

• 开始事务（multi）
• 命令入队（）
• 执行事务（exec）

正常执行事务

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set a 1
QUEUED
127.0.0.1:6379(TX)> set b 2
QUEUED
127.0.0.1:6379(TX)> set c 3
QUEUED
127.0.0.1:6379(TX)> get a
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
4) "1"
127.0.0.1:6379> 

放弃事务

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 v1
QUEUED
127.0.0.1:6379(TX)> set key2 v2
QUEUED
127.0.0.1:6379(TX)> set key4 v4
QUEUED
127.0.0.1:6379(TX)> discard 取消事务
OK
127.0.0.1:6379> get key4  事务中的命令都不会被执行
(nil)

编译型异常（代码有问题，命令有错），事务中所有的命令都不会被执行

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key4 v4
QUEUED
127.0.0.1:6379(TX)> set key3 v3
QUEUED
127.0.0.1:6379(TX)> set key2 v2
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 4
QUEUED
127.0.0.1:6379(TX)> set k5 v5
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5 所有的命令都不会被执行
(nil)

运行时异常（1/0）,如果事务队列中存在语法错误，其他命令会正常执行，错误命令可以抛出异常

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> multi
(error) ERR MULTI calls can not be nested
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> set k2 2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 1
2) OK
3) (error) ERR value is not an integer or out of range  虽然第一条命令报错了，但是不影响其他命令执行
4) OK
5) "2"

监控！watch

悲观锁：

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

乐观锁：

• 很乐观，认为什么时候都不会出现问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过数据，version！
• 获取version
• 更新的时候比较version

Redis的监视测试

正常执行成功

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 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) 20

Jedis

我们使用java来操作redis

jedis是redis官方推荐的java连接开发公开！使用java操作redis的中间件

1. 导入依赖

    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.2.0</version>
    </dependency>
<!--    fastjson-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.62</version>
    </dependency>

2. 编码测试
   1. 连接数据库
   2. 操作命令
   3. 断开连接

   public static void main(String[] args) {
        //new jedis对象
        Jedis jedis = new Jedis("127.0.0.1",6379);
        System.out.println(jedis.ping());
    }

输出

PONG

Process finished with exit code 0

常用api

string

package com.liang;

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class TestString {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1","value1"));
        System.out.println(jedis.set("key2","value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:"+jedis.del("key2"));
        System.out.println("获取键key2:"+jedis.get("key2"));
        System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
        System.out.println("key3的值："+jedis.get("key3"));
        System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
        System.out.println("删除多个键值对："+jedis.del("key01","key02"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));

        jedis.flushDB();
        System.out.println("===========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

        System.out.println("===========新增键值对并设置有效时间=============");
        System.out.println(jedis.setex("key3", 2, "value3"));
        System.out.println(jedis.get("key3"));
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(jedis.get("key3"));

        System.out.println("===========获取原值，更新为新值==========");
        System.out.println(jedis.getSet("key2", "key2GetSet"));
        System.out.println(jedis.get("key2"));

        System.out.println("获得key2的值的字串："+jedis.getrange("key2", 2, 4));
    }
}

list

 public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("===========添加一个list===========");
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("collections", "HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素,end为-1表示查询全部
        System.out.println("collections区间0-3的元素："+jedis.lrange("collections",0,3));
        System.out.println("===============================");
        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("删除下表0-3区间之外的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "LinkedArrayList"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("===============================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("获取collections下标为2的元素："+jedis.lindex("collections", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
    }

hash

public class TestHash {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        Map<String,String> map = new HashMap<String,String>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        //添加名称为hash（key）的hash元素
        jedis.hmset("hash",map);
        //向名称为hash的hash中添加key为key5，value为value5元素
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2："+jedis.hexists("hash","key2"));
        System.out.println("判断hash中是否存在key3："+jedis.hexists("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3","key4"));
    }
}

zset

set

public class TestSet {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("============向集合中添加元素（不重复）============");
        System.out.println(jedis.sadd("eleSet", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0："+jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("eleSet", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("eleSet"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet2", "e1","e2","e4","e3","e0","e8"));
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e1"));//移到集合元素
        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e2"));
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet3中的元素："+jedis.smembers("eleSet3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet2中的元素："+jedis.smembers("eleSet2"));
        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("eleSet1","eleSet2"));//eleSet1中有，eleSet2中没有
        jedis.sinterstore("eleSet4","eleSet1","eleSet2");//求交集并将交集保存到dstkey的集合
        System.out.println("eleSet4中的元素："+jedis.smembers("eleSet4"));
    }
}

事务

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.flushDB();
        //开启事务
        Transaction multi = jedis.multi();
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "liangwh");
        String jsonString = jsonObject.toJSONString();
        try {
            multi.set("user1", jsonString);
            multi.set("user2", jsonString);
//                int i = 1/0; //模拟代码有问题，事务失败
//      jedis.watch(jsonString);监听
            multi.exec();//正常情况，执行事务
        }catch (Exception e){
            multi.discard();//有异常，放弃事务
            e.printStackTrace();
        }finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            jedis.close();//关闭连接
        }
    }
}

springboot集成redis

整合测试

3、导入依赖

     <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、测试

    @Autowired
    private RedisTemplate redisTemplate;


    @Test
    void contextLoads() {

       // redisTemplate
       // 操作宁符串类似opsForValue
        // opsForList埃fList 光似List
        //opsForSet
        //opsForHash
        //opsForGeo
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();//获取redis连接对象
        connection.flushAll();
        connection.flushDb();

        redisTemplate.opsForValue().set("mykey", "lwh");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

redisconfig

package com.liang.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

}

redis.config详解

启动的时候，通过配置文件启动

• 单位
  
  1、配置文件unit单位对大小写不敏感
  

网络

bind 127.0.0.1   绑定地址ip

protected-mode yes 保护模式

port 6379  端口

daemonize yes  守护进程方式运行，默认是no，我们要手动开启

pidfile /var/run/redis_6379.pid  后台的方式运行，需要指定pid文件

#日志 
#Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)生产环境
# warning (only very important / critical messages are logged)
loglevel notice

logfile ""  日志文件位置名称

databases 16 数据库的数量，默认16个

always-show-logo no  是否显示logo

快照
持久化，规定时间内，执行多少次操作，生产文件，rdb，aof

svve 900 1  900秒内至少有一个key进行修改我们就进行持久化操作
save 300 10
save 60 10000


stop-writes-on-bgsave-error yes 持久化出错，是否继续工作

rdbcompression yes  是否压缩rdb文件，需要消耗CPU资源

rdbchecksum yes 保存rdb文件的时候，进行错误的检查

dir ./  rdb保存的目录

REPLICATION 主从复制

SECURITY 安全

• 默认是没有密码

CLIENTS 限制

maxclients 10000 连接客户端最大的数量

maxmemory <bytes> 最大的内存容量

maxmemory-policy noeviction 内存满了处理策略（移除过期的key）


1、volatile-lru: 只对设置了过期时间的key进行LRU(默认值)2、a11keys-lru : 删除1ru算法的key
3、volatile-random: 随机删除即将过期key
4、a11keys-random: 随机删除
5、volatile-ttl : 删除即将过期的
6、noeviction : 永不过期，返回错误

APPEND ONLY MODE 模式 aof配置

appendonly no 默认不开启，默认使用rdb方式持久化

appendfilename "appendonly.aof"  持久化文件的名字


# appendfsync always 每次修改都会sync，速度慢，消耗性能
appendfsync everysec  命秒执行一次sync，可能会丢失这一秒的数据
# appendfsync no  不执行sync(同步)，操作系统自己同步数据速度是最快的

Redis持久化

Redis 是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所
以 Redis 提供了持久化功能!

RDB（redis database）

什么是rdb

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

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

• 我们默认的就是RDB，一般情况下不需要修改这个配置 !

• /编辑文件/＋就是搜索

• 60秒内修改五次文件触发rdb文件保存

触发机制，rdb规则

1. save情况满足
2. 执行flushall命名
3. 退出redis

如何恢复rdb文件

1. 只需要将rdb文件放在redis的启动目录，redis启动会自动检查dump.rdb文件恢复数据

优点:
1、适合大规模的数据恢复!
2、对数据的完整性要不高 !
缺点:
1、需要一定的时间间隔进程操作!如果redis意外宕机了，这个最后一次修改数据就没有的了!
2、fork进程的时候，会占用一定的内容空间 ! !

• vim

AOF

• 将我们所有的命令记录下来，history，恢复的时候把这个文件执行一次

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

Aof保存的是 appendonly.aof 文件

• 默认不开启，no，改为yes即可为开启
  

- 删除文件
[root@VM-20-4-centos bin]# ls
dump.rdb  lconfig
[root@VM-20-4-centos bin]# rm -rf dump.rdb
[root@VM-20-4-centos bin]# ls
lconfig
[root@VM-20-4-centos bin]# 

• 重启redis

127.0.0.1:6379> shutdown 关机
not connected> exit 退出
[root@VM-20-4-centos bin]# redis-server lconfig/redis.conf 重启
[root@VM-20-4-centos bin]# redis-cli -p 6379 连接客户端
127.0.0.1:6379> ping 测试
PONG
127.0.0.1:6379> 

• 如果aof配置文件有错误，redis启动不起来，需要修复aof文件，redis提供了一个工具redis-cheak-aof --fix
  
• 文件正常，重启就直接恢复了
  
  
• aof默认无限文件追加，文件会越来越大

Redis发布订阅

测试

127.0.0.1:6379> subscribe liangwh
Reading messages... (press Ctrl-C to quit) 订阅
1) "subscribe"
2) "liangwh"
3) (integer) 1
1) "message"
2) "liangwh"
3) "6666666666"
1) "message"
2) "liangwh"
3) "nihao"
1) "message"
2) "liangwh"
3) "ni"
1) "message"
2) "liangwh"
3) "888"


127.0.0.1:6379> publish liangwh 6666666666 发布者
(integer) 1
127.0.0.1:6379> publish liangwh nihao
(integer) 1
127.0.0.1:6379> publish liangwh ni
(integer) 1
127.0.0.1:6379> publish liangwh 888
(integer) 1
127.0.0.1:6379> 

Redis主从复制

概念
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower); 数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave 以读为主。
默认情况下，每台Redis服务器都是主节点，且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点.
主从复制的作用主要包括:
1、数据冗余: 主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式
2、故障恢复:当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复，实际上是一种服务的几余。
3、负载均衡:在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务( 即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点)，分担服务器负载，尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4、高可用基石: 除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的，原因如下
1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大，一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存从容量上，单个Redis服务器内存容量有限

• 主从复制，读写分离 ! 80% 的情况下都是在进行读操作!减缓服务器的压力! 架构中经常使用 ! 一主二从!
• 只要在公司中，主从复制就是必须要使用的，因为在真实的项目中不可能单机使用Redis !

环境配置

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

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

复制3个配置文件，然后修改对应的信息
1、端口
2、pid 名字
3、log文件名字
4、dump.rdb 名字

• redis集群
• 修改完毕之后，启通过进程查看
  

一主二从

默认情况下，每一台redis服务器都是主节点。,一般情况只用配置从机

认老大，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:8
master_sync_in_progress:0
slave_read_repl_offset:28
slave_repl_offset:28
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:ee6f03d38c7774fd24cb075f5ab54e344f454056
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:28
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:15
repl_backlog_histlen:14
127.0.0.1:6380> 


主机信息 6379
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=140,lag=1
master_failover_state:no-failover
master_replid:ee6f03d38c7774fd24cb075f5ab54e344f454056
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:140
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:140

• 两个从机 6380和6381，主机是6379
  
  真实的主从配置应该在文件中配置，永久的，我们现在是命令，暂时的

细节

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

• 从机不能写,只能读

127.0.0.1:6380> set b a
(error) READONLY You can't write against a read only replica.

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

如果是使用命令行，来配置的主从，这个时候如果重启了就会变回主机!只要变为从机，立马就会从主机中获取值!
复制原理

• slave 启动成功连接到 master 后会发送一个sync命令

• Master 接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步

• 全量复制: 而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

• 增量复制: Master 继续将新的所有收集到的修改命令依次传给slave，完成同步但是只要是重新连接master，一次完全同步( 全量复制)将被自动执行，我们数据可以在从机看到
  
  如果主机断开连接使用slaveof no one让自己成为老大

127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_read_repl_offset:2005
slave_repl_offset:2005
master_link_down_since_seconds:24
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:f872c3c3f12ea91c0a5773721bb8afcb5c31e4c8
master_replid2:ee6f03d38c7774fd24cb075f5ab54e344f454056
master_repl_offset:2005
second_repl_offset:928
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:15
repl_backlog_histlen:1991
127.0.0.1:6380> slaveof no one
OK
127.0.0.1:6380> info replication
# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:dae6b1090d667967de8e05af95f45c7fdebdcb37
master_replid2:f872c3c3f12ea91c0a5773721bb8afcb5c31e4c8
master_repl_offset:2005
second_repl_offset:2006
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:15
repl_backlog_histlen:1991
127.0.0.1:6380> 

• 如果主机修复了，也只能重复连接从机

哨兵模式

概述

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

• Redis从2.8开始正式提供了Sentinel(哨兵)架构来解决这个问题。
  谋朝算位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

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

• 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。

• 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

• 然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。

• 各个哨兵之间还会进行监控，这样就形成了多哨兵模式。
  

测试

目前是一主二从

1、哨兵配置文件 sentinel.conf

sentinel monitor myredis 127.0.0.1 6379 1

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

2、启动哨兵

• 如果Master 节点断开了，这个时候就会从从机中随机选择一个服务器 ! ( 这里面有一个投票算法!)
• 哨兵日志

哨兵模式

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

优点
1、哨兵集群，基于主从复制模式，所有的主从配置优点，它全有

2、主从可以切换，故障可以转移，系统的可用性就会更好3、哨兵模式就是主从模式的升级，手动到自动，更加健壮!

缺点:
1、Redis 不好在线扩容的，集群容量一旦到达上限，在线扩容就十分麻烦!
2、实现哨兵模式的配置其实是很麻烦的，里面有很多选择!

Redis缓存穿透和缓存雪崩、缓存击穿

服务高可用的问题

在这里我们不会详细的区分析解决方案的底层。

• Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。

• 另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。
  

缓存穿透（查不到）

概念：缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中(秒杀!)，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

布隆过滤器

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

缓存击穿（量太大）

概述

• 这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
• 当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大

解决方案

• 设置热点数据不过期
• 加锁

缓存雪崩

概念

缓存雪崩，是指在某一个时间段，缓存集中过期失效。**Redis 宕机!**产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。

其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。

解决方案

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

限流降级
这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
数据预热
数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

禁止flushall等敏感操作