Redis

本文是在学习狂神的redis学习笔记

NoSQL

NoSQL特点

解耦！

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

2、大数据量高性能（Redis一秒写8万次。读取11万，是一种细粒度的缓存，性能较好）

3、数据类型是多样性的！（不需要事先设计数据库！随取随用）

4、传统RDBMS和NoSQL

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

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

NoSQL的四大分类

KV键值对

文档数据库

列存储数据库

图形关系数据库

Redis入门

概述

Redis是什么

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

Redis能干啥？

1、内存存储，持久化，内存中是断电即失，持久化很重要（rdb，aof）

2、效率高，可用于高速缓存

3、发布订阅系统

4、地图信息分析

5、计时器，计数器（浏览量！）

6 ……

特性

1、多样的数据类型

2、持久化

3、集群

4、事务

………

测试性能

redis-benchmark 是一个压力测试工具

redis-benchmark 命令参数

#测试：100并发连接 100000连接请求
redis-benchmark -h redisServer -p 6379 -c 100 -n 100000

基础知识

redis默认有16个数据库

可以使用select进行切换

redisServer:6379> select 3 #切换
OK
redisServer:6379[3]> DBSIZE #数据库里的东西数量
(integer) 0

查看所有key **keys ***

redisServer:6379> keys * #查看所有key
1) "mylist"
2) "counter:__rand_int__"
3) "myhash"
4) "name"
5) "key:__rand_int__"

清空当前数据库flushdb

redisServer:6379> flushdb #清空当前数据库内容
OK
redisServer:6379> DBSIZE
(integer) 0

清空全部数据库 FLUSHALL

redisServer:6379[4]> FLUSHALL #清空全部数据库
OK
redisServer:6379[4]> select 0
OK

Redis是单线程的！

Redis是基于内存操作的，CPU不是Redis的性能瓶颈，其瓶颈是机器内存和网络带宽，能用单线程就用单线程了

五大数据类型

Redis-Key

redisServer:6379> keys * #查看所有key
(empty array)
redisServer:6379> set name dying#设置key value
OK
redisServer:6379> exists name #查看是否存在
(integer) 1
redisServer:6379> EXPIRE name 10 #设置过期时间
(integer) 1
redisServer:6379> ttl name#查看剩余时间
(integer) 6
redisServer:6379> move name 1#移除
(integer) 0
redisServer:6379> type name#查看key类型
string

String

APPEND （尾加） STRLEN（长度）

redisServer:6379> set name dying
OK
redisServer:6379> keys *
1) "name"
redisServer:6379> APPEND name "hello"#追加
(integer) 10
redisServer:6379> keys *
1) "name"
redisServer:6379> get name
"dyinghello"
redisServer:6379> STRLEN name#查看value长度
(integer) 10
redisServer:6379>

redisServer:6379> keys *
1) "name"
redisServer:6379> APPEND dying hello#不存在新建key value
(integer) 5
redisServer:6379> keys *
1) "dying"
2) "name"

INCR/DECR INCRBY/DECRBY（自增）

redisServer:6379> clear
redisServer:6379> INCR views#自增 1 
(integer) 1
redisServer:6379> get views
"1"
redisServer:6379> keys *
1) "views"
redisServer:6379> DECR views#自减 1 
(integer) 0
redisServer:6379> INCRBY views 10 #自增10
(integer) 10
redisServer:6379> get views
"10"
redisServer:6379> DECRby views 9#自减 9
(integer) 1
redisServer:6379> get views
"1"

GETRANGE（截取字符串）

redisServer:6379> set name "hello,dying"
OK
redisServer:6379> get name
"hello,dying"
redisServer:6379> GETRANGE name 0 5【闭区间】
"hello,"
redisServer:6379> GETRANGE name 0 -1
"hello,dying"

SETRANGE（在指定位置替换）

redisServer:6379> get name
"hello,dying"
redisServer:6379> SETRANGE name 0 "hi"
(integer) 11
redisServer:6379> get name
"hillo,dying"

setex(设置过期时间)setnx(不存在再设置)

redisServer:6379> setex key3 30 hello #设置30秒过期
OK
redisServer:6379> ttl key3
(integer) 27
redisServer:6379> setnx name llo
(integer) 0 #说明存在
redisServer:6379> setnx mykey1 redis
(integer) 1 #说明不存在

mset（设置多个值）mget（获取多个值）

redisServer:6379> keys *
(empty array)
redisServer:6379> mset k1 v1 k2 v2 k3 v3
OK
redisServer:6379> keys *
1) "k3"
2) "k2"
3) "k1"
redisServer:6379> get k2
"v2"
redisServer:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"

redisServer:6379> mget k1 k2 k3
1) "v1"
2) "v2"
3) "v3"
redisServer:6379> msetnx k1 v2 k4 v4 #设置多个值（不存在创建）原子性，要么一起成功要么一起失败
(integer) 0
redisServer:6379> keys *
1) "k3"
2) "k2"
3) "k1"

#对象存储方式
redisServer:6379> mset user:1:name zhangsan user:1:age 2
OK
redisServer:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"

getset（先获取在设置）

#可以用来做更新，获取（不存在nil）然后设置
redisServer:6379> getset db mongodb
"redis"
redisServer:6379> getset kk kk
(nil)
redisServer:6379> get kk
"kk"

string类似的使用场景：value除了是字符串还可以是数字！

计数器
统计多单位数量
粉丝数
对象缓存存储

List

基本数据类型，列表（可以当栈、队列、阻塞队列）

所有list命令都是l开头

Lpush(将【多个】元素放到头部) Rpush（放到尾部）

redisServer:6379> LPUSH list one
(integer) 1
redisServer:6379> LPUSH list two
(integer) 2
redisServer:6379> LPUSH list three
(integer) 3
redisServer:6379> LRANGE list 0 -1 #获取值区间
1) "three"
2) "two"
3) "one"
redisServer:6379> LRANGE list 0 1
1) "three"
2) "two"
redisServer:6379> Rpush list four
(integer) 4
redisServer:6379> Lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
redisServer:6379> RPUSH list five six
(integer) 6
redisServer:6379> Lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
5) "five"
6) "six"

Lpop（移除列表头部元素）Rpop（尾部）

redisServer:6379> Lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"
5) "five"
6) "six"
redisServer:6379> LPOP list 2
1) "three"
2) "two"
redisServer:6379> Lrange list 0 -1
1) "one"
2) "four"
3) "five"
4) "six"
redisServer:6379> RPOP list 2
1) "six"
2) "five"
redisServer:6379> Lrange list 0 -1
1) "one"
2) "four"

Lindex（获取对应索引值）

redisServer:6379> Lrange list 0 -1
1) "one"
2) "four"
redisServer:6379> LINDEX list 1
"four"
redisServer:6379> LINDEX list 2
(nil)
redisServer:6379> LINDEX list 0
"one"

Llen(查看list长度)

redisServer:6379> Llen list
(integer) 2

Lrem(移除list中指定的值）

redisServer:6379> LRANGE list 0 -1
1) "one"
2) "one"
3) "four"
redisServer:6379> Lrem list 1 noe
(integer) 0
redisServer:6379> LRANGE list 0 -1
1) "one"
2) "four"

redisServer:6379> LPUSH list one
(integer) 3
redisServer:6379> LRANGE list 0 -1
1) "one"
2) "one"
3) "four"
redisServer:6379> Lrem list 2 one
(integer) 2

Ltrim（截取元素）

redisServer:6379> LPUSH mylist hello hello1 hello2 hello3
(integer) 4
redisServer:6379> lRange mylist 0 -1
1) "hello3"
2) "hello2"
3) "hello1"
4) "hello"
redisServer:6379> ltrim mylist 1 2 #只保留1到2
OK
redisServer:6379> lRange mylist 0 -1
1) "hello2"
2) "hello1"

rpopLpush (移动列表最后一个元素到新列表)

redisServer:6379> rpush mylist hello hello1 hello2
(integer) 3
redisServer:6379> rpoplpush mylist newlist
"hello2"
redisServer:6379> keys *
1) "newlist"
2) "mylist"
redisServer:6379> LRANGE newlist 0 -1
1) "hello2"
redisServer:6379> LRANGE mylist 0 -1
1) "hello"
2) "hello1"

Lset（更新值（不存在报错））

redisServer:6379> lset list 0 item
(error) ERR no such key
redisServer:6379> lpush list hello
(integer) 1
redisServer:6379> lrange list 0 -1
1) "hello"
redisServer:6379> lset list 0 item
OK
redisServer:6379> lrange list 0 -1
1) "item"

Linsert( 插入元素【前/后】)

redisServer:6379> LPUSH list hello world
(integer) 2
redisServer:6379> LINSERT list before world other
(integer) 3
redisServer:6379> LRANGE list 0 -1
1) "other"
2) "world"
3) "hello"
redisServer:6379> LINSERT list after hello dying
(integer) 4
redisServer:6379> LRANGE list 0 -1
1) "other"
2) "world"
3) "hello"
4) "dying"

小结

实际上是一个链表，before Node after ，left ，right都可以插入值
如果key不存在，创建新列表
如果key存在，新增内容
如果移除所有值，空链表，不存在
在俩边插入或者改动值，效率高。中间元素效率低

Set

set的值不能重复，无序

Sadd(添加元素) Smember(查看所有值) Sismember(判断是否存在)

redisServer:6379> Sadd set hello
(integer) 1
redisServer:6379> Sadd set dying wc
(integer) 2
redisServer:6379> Smembers set
1) "wc"
2) "dying"
3) "hello"
redisServer:6379> Sismember set hello
(integer) 1
redisServer:6379> Sismember set hell
(integer) 0

Sacrd（获取大小）

redisServer:6379> Scard set
(integer) 3
redisServer:6379> Sadd set k
(integer) 1
redisServer:6379> Scard set
(integer) 4

Srem（移除）

redisServer:6379> Scard set
(integer) 4
redisServer:6379> Smembers set
1) "wc"
2) "k"
3) "dying"
4) "hello"
redisServer:6379> Srem set k
(integer) 1
redisServer:6379> Smembers set
1) "wc"
2) "dying"
3) "hello"

SRANDMEMBER(随机获取一个/多个值)

redisServer:6379> Smembers set
1) "wc"
2) "dying"
3) "hello"
redisServer:6379> SRANDMEMBER set
"dying"
redisServer:6379> SRANDMEMBER set
"hello"
redisServer:6379> SRANDMEMBER set
"dying"
redisServer:6379> SRANDMEMBER set 2
1) "wc"
2) "hello"

Spop（随机弹出）

redisServer:6379> SMEMBERS set
1) "wc"
2) "dying"
3) "hello"
redisServer:6379> Spop set
"hello"
redisServer:6379> Spop set
"wc"

Smove（移动一个值到另一个set中）

redisServer:6379> Sadd set hello wc dying
(integer) 3
redisServer:6379> Sadd set2 set2
(integer) 1
redisServer:6379> Smove set set2 dying
(integer) 1
redisServer:6379> SMEMBERS set2
1) "dying"
2) "set2"
redisServer:6379> SMEMBERS set
1) "wc"
2) "hello"

Sdiff(差) Sinter(交) Sunion(并)

redisServer:6379> Sadd key1 a b c
(integer) 3
redisServer:6379> Sadd key2 c  d e
(integer) 3
redisServer:6379> Sdiff key1 key2
1) "b"
2) "a"
redisServer:6379> Sdiff key2 key1
1) "d"
2) "e"
redisServer:6379> SINTER key1 key2
1) "c"
redisServer:6379> Sunion key1 key2
1) "e"
2) "a"
3) "c"
4) "d"
5) "b"

用途：共同关注，共同爱好，二度好友

Hash

Map集合， key-map<key , value>

和string区别不大

Hset Hget Hmset Hmget Hgetall

redisServer:6379> Hset hash name dying
(integer) 1
redisServer:6379> Hget hash name#获取一个值
"dying"
redisServer:6379> Hmset hash h1 v1 h2 v2 #设置多个值
OK
redisServer:6379> Hmget hash name h1 h2#获取多个值
1) "dying"
2) "v1"
3) "v2"
redisServer:6379> Hgetall hash#获取所有值
1) "name"
2) "dying"
3) "h1"
4) "v1"
5) "h2"
6) "v2"

Hdel 删指定字段

redisServer:6379> Hdel hash h1
(integer) 1
redisServer:6379> Hgetall hash
1) "name"
2) "dying"
3) "h2"
4) "v2"

Hlen 获取size

redisServer:6379> Hgetall hash
1) "name"
2) "dying"
3) "h2"
4) "v2"
redisServer:6379> Hlen hash
(integer) 2
redisServer:6379> Hmset hash k l
OK
redisServer:6379> Hlen hash
(integer) 3

Hexists 判断是否存在

redisServer:6379> Hexists hash name
(integer) 1
redisServer:6379> Hexists hash p
(integer) 0

Hkeys (只获取key) Hvals(只获取值)

redisServer:6379> Hkeys hash
1) "name"
2) "h2"
3) "k"
redisServer:6379> Hvalues hash
(error) ERR unknown command 'Hvalues', with args beginning with: 'hash'
redisServer:6379> Hvals hash
1) "dying"
2) "v2"
3) "l"

HINCRBY （增加值）

redisServer:6379> hset hash age 10
(integer) 1
redisServer:6379> HINCRBY hash age 1
(integer) 11

Hsetnx

redisServer:6379> Hsetnx hash name dying
(integer) 0

Hash变更的数据。用户信息，经常变动信息，hash更适合对象，string适合字符串存储

Zset（有序集合）

再set基础上，增加了一个值，set k1 v1 | zset k1 score v1

Zadd(添加值（多个）)

redisServer:6379> Zadd zset 1 one
(integer) 1
redisServer:6379> Zadd zset 2 two 3 three
(integer) 2
redisServer:6379> ZRange zset 0 -1
1) "one"
2) "two"
3) "three"

ZRANGEBYSCORE（按照区间取值）

redisServer:6379> Zadd salary 2500 dying 5000 wc
(integer) 2
redisServer:6379> ZRANGEBYSCORE salary -inf +inf#显示用户，小——>大
1) "dying"
2) "wc"
redisServer:6379> ZRANGEBYSCORE salary 0 2500 withscores
1) "dying"
2) "2500"
redisServer:6379> ZRANGEBYSCORE salary 0 2500 withscores #显示所有用户并附带成绩

Zrange（查看） Zrem（移除）

redisServer:6379> Zrange salary 0 -1
1) "dying"
2) "wc"
redisServer:6379> Zrem salary wc
(integer) 1
redisServer:6379> Zrange salary 0 -1
1) "dying"

Zrevrange 反转排序

redisServer:6379> ZREVRANGE salary 0 -1 withscores #从大到小
1) "wc"
2) "5000"
3) "dying"
4) "2500"

Zcard获取有序集合个数

redisServer:6379> ZCARD salary
(integer) 1

Zcount（获取区间的数量）

redisServer:6379> Zcount salary 0 2500
(integer) 1
redisServer:6379> Zcount salary 0 5000
(integer) 2
redisServer:6379> ZRANGEBYSCORE salary -inf +inf withscores
1) "dying"
2) "2500"
3) "wc"
4) "5000"

用途：

set排序，成绩表

分级排序

排行榜

三种特殊类型

geospatial地理位置

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

RedisGeo再Redis3.2版本就推出了！可推算地理位置信息，两地距离，方圆几里人

geoadd添加地理位置

#getadd 添加地理位置
#规则：两级无法添加，一般下载城市数据导入
#参数 key 值（ 经度 纬度 名称）

redisServer:6379> Geoadd china:city 114.05 22.52 shenzhen 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 3

geopos显示地理位置

redisServer:6379> Geopos china:city chongqing beijin #获取指定城市经度纬度
1) 1) "106.49999767541885376"
   2) "29.52999957900659211"
2) 1) "116.39999896287918091"
   2) "39.90000009167092543"

geodist查看俩点直线距离

redisServer:6379> geodist china:city beijin shanghai
"1067378.7564"
redisServer:6379> geodist china:city beijin shanghai km #显示km
"1067.3788"

GEORADIUS 以给定经度纬度为中心，找出半径内元素

redisServer:6379> GEORADIUS china:city 110 30 1000 km
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
#withdist 距离 withcoord 显示经纬度 count 数量
redisServer:6379> GEORADIUS china:city 110 30 1000 km withdist withcoord count 1
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

GEORADIUSBYMEMBER根据位置获取半径内元素

redisServer:6379> GEORADIUSBYMEMBER china:city beijin 1000 km withcoord
1) 1) "beijin"
   2) 1) "116.39999896287918091"
      2) "39.90000009167092543"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"

Geo底层是Zset,可用zset操作

redisServer:6379> type china:city
zset

Hyperloglog

什么是基数

基数是俩个集合中不重复元素的个数，可以接收误差！

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

缺点：0.81%错误率

网页UV（一个人访问网站多次，只算一次）

传统方式，set保存用户id。可以统计set中元素作为标准判断！

这个方式保存大量uid，比较麻烦

PFadd (增加) PFcount（计数） PFmerge（合并）

redisServer:6379> PFadd key a b c d e f g h i j
(integer) 1
redisServer:6379> PFCOUNT key
(integer) 10
redisServer:6379> PFadd key2 ag h s o i k h iu k
(integer) 1
redisServer:6379> PFCOUNT key2
(integer) 7
redisServer:6379> PFMERGE key3 key key2
OK
redisServer:6379> PFcount key3
(integer) 15

如果允许容错，统计优先考虑this

Bitmap

位存储

统计用户信息，活跃，不活跃，登录，打卡

Bitmaps位图，数据结构，操作二进制数

setbit(设置key 的对应位是0|1) getbit

redisServer:6379> setbit sign 0 1
(integer) 0
redisServer:6379> setbit sign 1 0
(integer) 0
redisServer:6379> setbit sign 2 0
(integer) 0
redisServer:6379> setbit sign 3 1
(integer) 0
redisServer:6379> getbit sign 0
(integer) 1
redisServer:6379> getbit sign 1
(integer) 0
redisServer:6379> getbit sign 3
(integer) 1

bitcount 统计1个数

redisServer:6379> bitcount sign
(integer) 2

事务

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

一致性、顺序性、排他性【执行一系列命令】

Redis：事务没有隔离级别概念

Redis：所有命令在事务中，并没有直接执行，发起命令才会执行

Redis：单条命令保正原子性，事务不保证原

redis事务流程：

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

执行事务 exec

redisServer:6379> multi #开启事务
OK
redisServer:6379(TX)> set k1 v1
QUEUED
redisServer:6379(TX)> set k2 v2
QUEUED
redisServer:6379(TX)> get k2
QUEUED
redisServer:6379(TX)> set k3 v3
QUEUED
redisServer:6379(TX)> exec #执行
1) OK
2) OK
3) "v2"
4) OK

放弃事务 DISCARD

redisServer:6379> multi
OK
redisServer:6379(TX)> set k1 v1
QUEUED
redisServer:6379(TX)> get k1
QUEUED
redisServer:6379(TX)> DISCARD#都不会执行
OK

编译型异常【代码有问题，命令有错】，事务中所有命令都不会执行

redisServer:6379> multi
OK
redisServer:6379(TX)> set k1 v1
QUEUED
redisServer:6379(TX)> set k2 v2
QUEUED
redisServer:6379(TX)> set k3 v3
QUEUED
redisServer:6379(TX)> getset k3 v4
QUEUED
redisServer:6379(TX)> getset k3 #错误命令
(error) ERR wrong number of arguments for 'getset' command
redisServer:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.#所有命令都不会执行
redisServer:6379> keys *
(empty array)

允许时异常（1/0）如果事务队列中语法没问题但是非法操作，其他命令正常执行，错误命令抛出异常

redisServer:6379> set k1 hello
OK
redisServer:6379> multi
OK
redisServer:6379(TX)> INCR k1 #错误
QUEUED
redisServer:6379(TX)> set k2 v2
QUEUED
redisServer:6379(TX)> exec
1) (error) ERR value is not an integer or out of range#不影响其他的
2) OK
redisServer:6379> get k2
"v2"

监控 watch

悲观锁

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

乐观锁

乐观，认为什么时候都不会出现问题，不会上锁，更新数据时候去判断一下是否有人修改过这个数据，version！
获取version
更新时候比较version

Redis监视测试

正常执行成功！

redisServer:6379> clear
redisServer:6379> set money 100
OK
redisServer:6379> set out 0
OK
redisServer:6379> watch money
OK
redisServer:6379> multi
OK
redisServer:6379(TX)> DECRBY money 20
QUEUED
redisServer:6379(TX)> INCRBY out 20
QUEUED
redisServer:6379(TX)> exec
1) (integer) 80
2) (integer) 20

执行失败

#线程一开启事务
redisServer:6379> watch money
OK
redisServer:6379> multi
OK
redisServer:6379(TX)> DECRBY money 10
QUEUED
redisServer:6379(TX)> INCRBY out 10
QUEUED
redisServer:6379(TX)> exec
(nil) #线程2修改过执行失败

#线程2在此期间修改
redisServer:6379> get money
"80"
redisServer:6379> set money 1000
OK

事务失败后需要unwatch然后在watch重复执行

Jedis

使用

配置文件

 <!-- import jredis-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
    </dependencies>

测试连接

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

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

常用API

String

同上面redis命令

List

同上

Set

同上

Hash

同上

Zset

同上

事务

public class Testping {
    public static void main(String[] args) {
        // new Jedis
        Jedis jredis = new Jedis("127.0.0.1" , 6379);
        Transaction trans = jredis.multi();
        Response<String> res = null;
        try {
            trans.set("name", "dying");
            trans.set("name2" , "hello");
            //int i = 1  / 0;
            res = trans.get("name");

            trans.exec();
            System.out.println(res.get());
        }catch(Exception e){
            trans.discard();
            e.printStackTrace();
        }finally {
            jredis.close();
        }
    }
}

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.

可以包含其他配置文件

# include .\path\to\local.conf
# include c:\path\to\other.conf

网络

bind 192.168.1.100 10.0.0.1
bind 127.0.0.1 #绑定的ip（谁可访问本机 *代表任意）
port 6379 # 默认端口

通用GENERAL

dameonize yes #以守护进程方式运行【后台】，默认是no
pidfile /var/run/redis_6379.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 "" #日志生成文件名，空->stdout
databases 16 #数据库数量

快照

持久化，在规定时间内，执行了多少次操作，也会持久化到文件 .rdb , .aof，如果没有持久化，数据断电即失

save 900 1 #如果900秒内，有1个key修改，进行持久化操作
save 300 10 #如果300秒内，有10个key修改，进行持久化操作
save 60 10000#如果60秒内，有10000个key修改，进行持久化操作

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

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

rdbchecksum yes#保存rdb文件时进行错误校验

dir ./ #rdb文件保存目录

REPLICATION主从复制

SECURITY安全

可以在这里设置redis密码，默认没有密码

127.0.0.1:6379> config set requirepass "123456" #设置密码
OK
127.0.0.1:6379> config get requirepass #获取密码
(error) NOAUTH Authentication required.#没有认证
127.0.0.1:6379> ping
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456 #认证/登录
OK
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> config get requirepass #获取密码
1) "requirepass"
2) "123456"

限制 CLIENTS

# maxclients 10000 设置最大同时连接客户端数量

# maxmemory <bytes>配置最大内存容量

# maxmemory-policy noeviction 内存达到上限策略
#移除一些过期的key
#报错
#...

APPEND ONLY 模式aof

appendonly no  #默认不开启，使用rdb方式持久化，大部分使用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，一半不需要修改

有时候在生产环境会备份

RDB保存的文件是，dump.rdb都是在配置文件中的快照中进行配置

dbfilename dump.rdb

测试

触发机制

save的规则满足情况下，会自动触发rdb规则
执行flushall 也会触发
退出redis，也会触发

备份就自动生成一个dump.rdb

如何恢复rdb文件！

只需要将rdb文件放在启动目录就行，redis启动时候自动检查dump.rdb
查看需要存的位置

127.0.0.1:6379> config get dir
1) "dir"
2) "D:\\DevApp\\Redis" #如果在目录下存在dump.rdb,启动自动恢复

优缺点

优点

适合大规模的数据恢复
对数据的完整性要求不高

缺点

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

AOF(Append Only File)

是什么

搜去吧，不想写了。

优缺点

优点

每一次修改都同步，文件的完整性更加好
每秒同步一次，可能会丢失一秒
（不开启）从不同步，效率高

缺点

相对于数据文件来说，aof远远大于aof，恢复时间也比edb慢
aof运行效率也要比rdb慢，所以默认rdb

Redis发布订阅

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

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

订阅/发布消息图：

消息发送者频道消息订阅者

测试

订阅端：

127.0.0.1:6379> SUBSCRIBE dying
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "dying"
3) (integer) 1 #等待推送者信息
1) "message"
2) "dying"
3) "hello dying"
1) "message"
2) "dying"
3) "hi

发送端：

127.0.0.1:6379> PUBLISH dying "hello dying" #发送消息
(integer) 1
127.0.0.1:6379> PUBLISH dying hi
(integer) 1

Redis主从复制

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

默认情况下，每台redis的服务器都是主节点；且一个主节点可以有多个从节点（或者没有从节点），但一个从节点只能有一个主节点。

主从复制的作用包括：

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

一般来说，要将redis运用于项目工程中，只使用一台redis是万万不能的（宕机、一主二从），原因如下：

从结构上，单个redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载马，压力较大。
从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。

环境配置

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

127.0.0.1:6379> info replication
# Replication
role:master #角色
connected_slaves:0 #没有从机
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

一主二从

默认情况下，每台Redis服务器都是主机，一搬只需要配置从机

认老大SLAVEOF

127.0.0.1:6378> SLAVEOF 127.0.0.1 6379#认6379为主机
# Replication
role:slave
master_host:127.0.0.1#主机地址
master_port:6379#主机ip
master_link_status:up
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:225
slave_priority:100
slave_read_only:1
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

#主机中查看
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2#从机数量
slave0:ip=127.0.0.1,port=6377,state=online,offset=295,lag=0#从机信息
slave1:ip=127.0.0.1,port=6378,state=online,offset=295,lag=0#从机信息
master_repl_offset:295
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:294

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

从机只能读

主机断开重连还和之前一样

复制原理

如果主机断开连接，我没可以使用 SLAVEOF no one 使自己变成老大

哨兵模式（自动选举主节点）

概述

主从切换技术的方法是：当主服务器宕机，需要手动把一台从服务器切换为主服务器，这需要人工干预，费时费力，还会造成一段时间内服务不可用，这不推荐。更多时候我没优先考虑哨兵模式，Redis从2.8开始正式提供了Sentinel（哨兵）架构解决这个问题

会监控后台主机是否有故障，如果故障了根据投票数自动将从库切换为主库

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

哨兵作用：

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

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我没可以使用多个哨兵进行监控，各个哨兵之间还会进行监控，形成了多哨兵模式

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行faliover过程，仅仅是哨兵1 主观认为主服务器不可用，这个现象称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时那么哨兵之间就会进行一次投票，投票结果由一个哨兵发起，进行failover【故障转移】操作。切换成功后，通过发布订阅模式，让各个哨兵把自己监控的服务器实现切换主机，这个过程称为客观下线

测试

目前一主二从

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

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

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

2、启动哨兵

如果master结点断开，这个时候就会从从机中随机选择一个服务器（投票算法）

哨兵日志

如果主机重新回来，只能归并到新主机下当作从机，这就是哨兵模式规则

优缺点

优点

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

缺点

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

哨兵模式配置

# 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 2
 
# 当在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