redis笔记
1. 基础概念
1.1 NoSQL的引言
NoSQL(
Not Only SQL)，意即不仅仅是SQL, 泛指非关系型的数据库。Nosql这个技术门类,早期就有人提出,发展至2009年趋势越发高涨。
1.2 为什么是NoSQL
随着互联网网站的兴起，传统的关系数据库在应付动态网站，特别是超大规模和高并发的纯动态网站已经显得力不从心，暴露了很多难以克服的问题。如
商城网站中对商品数据频繁查询、对热搜商品的排行统计、订单超时问题、以及微信朋友圈（音频，视频）存储等相关使用传统的关系型数据库实现就显得非常复杂，虽然能实现相应功能但是在性能上却不是那么乐观。nosql这个技术门类的出现，更好的解决了这些问题，它告诉了世界不仅仅是sql。
1.3 NoSQL的四大分类
1.3.1 键值(Key-Value)存储数据库
# 1.说明:
- 这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。
# 2.特点
- Key/value模型对于IT系统来说的优势在于简单、易部署。
- 但是如果DBA只对部分值进行查询或更新的时候，Key/value就显得效率低下了。
# 3.相关产品
- Tokyo Cabinet/Tyrant,
- Redis
- SSDB
- Voldemort
- Oracle BDB
1.3.2 列存储数据库
# 1.说明
- 这部分数据库通常是用来应对分布式存储的海量数据。
# 2.特点
- 键仍然存在，但是它们的特点是指向了多个列。这些列是由列家族来安排的。
# 3.相关产品
- Cassandra、HBase、Riak.
1.3.3 文档型数据库
# 1.说明
- 文档型数据库的灵感是来自于Lotus Notes办公软件的，而且它同第一种键值存储相类似该类型的数据模型是版本化的文档，半结构化的文档以特定的格式存储，比如JSON。文档型数据库可 以看作是键值数据库的升级版，允许之间嵌套键值。而且文档型数据库比键值数据库的查询效率更高
# 2.特点
- 以文档形式存储
# 3.相关产品
- MongoDB、CouchDB、 MongoDb(4.x). 国内也有文档型数据库SequoiaDB，已经开源。
1.3.4 图形(Graph)数据库
# 1.说明
- 图形结构的数据库同其他行列以及刚性结构的SQL数据库不同，它是使用灵活的图形模型，并且能够扩展到多个服务器上。
- NoSQL数据库没有标准的查询语言(SQL)，因此进行数据库查询需要制定数据模型。许多NoSQL数据库都有REST式的数据接口或者查询API。
# 2.特点
# 3.相关产品
- Neo4J、InfoGrid、 Infinite Graph、
1.4 NoSQL应用场景
- 数据模型比较简单
- 需要灵活性更强的IT系统
- 对数据库性能要求较高
- 不需要高度的数据一致性
1.5 什么是Redis
Redis 开源 遵循BSD 基于内存数据存储 被用于作为 数据库 缓存 消息中间件
总结: redis是一个内存型的数据库
1.6 Redis特点
- Redis是一个高性能key/value内存型数据库
- Redis支持丰富的数据类型
- Redis支持持久化
- Redis单线程,单进程
2. Redis安装
# 0.准备环境
- vmware15.x+
- centos7.x+
# 1.下载redis源码包
- https://redis.io/
# 2.下载完整源码包,该笔记中使用的是4.0.10
- redis-4.0.10.tar.gz
# 3.将下载redis资料包上传到Linux中
# 4.解压缩文件
[root@localhost ~]# tar -zxvf redis-4.0.10.tar.gz
# 5.安装gcc
- yum install -y gcc
# 6.进入解压缩目录执行如下命令
- make MALLOC=libc
# 7.编译完成后执行如下命令
- make install PREFIX=/usr/redis
# 8.进入/usr/redis目录启动redis服务
- ./redis-server
# 9.Redis服务端口默认是 6379
# 10.进入bin目录执行客户端连接操作,出现下图所示，表示连接成功
- ./redis-cli –p 6379
# 11.后台启动方式需要修改redis.conf中
daemonize no #将no修改成yes
3. Redis数据库相关指令
3.1 数据库操作指令
# 1.Redis中库说明
- 使用redis的默认配置器动redis服务后,默认会存在16个库,编号从0-15
- 默认16个数据库，类似数组下表从零开始，初始默认使用零号库
- 可以使用select 库的编号 来选择一个redis的库
# 2.Redis中操作库的指令
- 清空当前的库 FLUSHDB
- 清空全部的库 FLUSHALL
# 3.redis客户端显示中文
- ./redis-cli -p 7000 --raw
# 4. dbsize查看当前数据库的key的数量,同时也可以查看key的名称,使用keys *并且支持通配符查询,例如:keys k?,查询k开头的所有key.
3.2 操作key相关指令
# 1.DEL指令
- 语法 : DEL key [key ...]
- 作用 : 删除给定的一个或多个key 。不存在的key 会被忽略。
- 可用版本： >= 1.0.0
- 返回值： 被删除key 的数量。
# 2.EXISTS指令
- 语法: EXISTS key
- 作用: 检查给定key 是否存在。
- 可用版本： >= 1.0.0
- 返回值： 若key 存在，返回1 ，否则返回0。
# 3.EXPIRE
- 语法: EXPIRE key seconds
- 作用: 为给定key 设置生存时间，当key 过期时(生存时间为0 )，它会被自动删除。
- 可用版本： >= 1.0.0
- 时间复杂度： O(1)
- 返回值：设置成功返回1 。
# 4.KEYS
- 语法 : KEYS pattern
- 作用 : 查找所有符合给定模式pattern 的key 。
- 语法:
KEYS * 匹配数据库中所有key 。
KEYS h?llo 匹配hello ，hallo 和hxllo 等。
KEYS h*llo 匹配hllo 和heeeeello 等。
KEYS h[ae]llo 匹配hello 和hallo ，但不匹配hillo 。特殊符号用 "\" 隔开
- 可用版本： >= 1.0.0
- 返回值： 符合给定模式的key 列表。
# 5.MOVE
- 语法 : MOVE key db
- 作用 : 将当前数据库的key 移动到给定的数据库db 当中。
- 可用版本： >= 1.0.0
- 返回值： 移动成功返回1 ，失败则返回0 。
# 6.PEXPIRE
- 语法 : PEXPIRE key milliseconds
- 作用 : 这个命令和EXPIRE 命令的作用类似，但是它以毫秒为单位设置key 的生存时间，而不像EXPIRE 命令那样，以秒为单位。
- 可用版本： >= 2.6.0
- 时间复杂度： O(1)
- 返回值：设置成功，返回1 key 不存在或设置失败，返回0
# 7.PEXPIREAT
- 语法 : PEXPIREAT key milliseconds-timestamp
- 作用 : 这个命令和EXPIREAT 命令类似，但它以毫秒为单位设置key 的过期unix 时间戳，而不是像EXPIREAT那样，以秒为单位。
- 可用版本： >= 2.6.0
- 返回值：如果生存时间设置成功，返回1 。当key 不存在或没办法设置生存时间时，返回0 。(查看EXPIRE 命令获取更多信息)
# 8.TTL
- 语法 : TTL key
- 作用 : 以秒为单位，返回给定key 的剩余生存时间(TTL, time to live)。
- 可用版本： >= 1.0.0
- 返回值：
当key 不存在时，返回-2 。
当key 存在但没有设置剩余生存时间时，返回-1 。
否则，以秒为单位，返回key 的剩余生存时间。
- Note : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。
# 9.PTTL
- 语法 : PTTL key
- 作用 : 这个命令类似于TTL 命令，但它以毫秒为单位返回key 的剩余生存时间，而不是像TTL 命令那样，以秒为单位。
- 可用版本： >= 2.6.0
- 返回值： 当key 不存在时，返回-2 。当key 存在但没有设置剩余生存时间时，返回-1 。
- 否则，以毫秒为单位，返回key 的剩余生存时间。
- 注意 : 在Redis 2.8 以前，当key 不存在，或者key 没有设置剩余生存时间时，命令都返回-1 。
# 10.RANDOMKEY
- 语法 : RANDOMKEY
- 作用 : 从当前数据库中随机返回(不删除) 一个key 。
- 可用版本： >= 1.0.0
- 返回值：当数据库不为空时，返回一个key 。当数据库为空时，返回nil 。
# 11.RENAME
- 语法 : RENAME key newkey
- 作用 : 将key 改名为newkey 。当key 和newkey 相同，或者key 不存在时，返回一个错误。当newkey 已经存在时，RENAME 命令将覆盖旧值。
- 可用版本： >= 1.0.0
- 返回值： 改名成功时提示OK ，失败时候返回一个错误。
# 12.TYPE
- 语法 : TYPE key
- 作用 : 返回key 所储存的值的类型。
- 可用版本： >= 1.0.0
- 返回值：
none (key 不存在)
string (字符串)
list (列表)
set (集合)
zset (有序集)
hash (哈希表)
3.3 String类型
string是redis最基本的类型，可以理解成与Memcached一模一样的类型，一个key对应一个value。
3.3 1 内存存储模型
3.3 2 常用操作命令
获得redis常见数据类型操作命令: http://redisdoc.com/
| 命令 | 说明 |
|---|---|
| set | 设置一个key/value |
| get | 根据key获得对应的value |
| del | 删除某一个指定的key |
| mset | 一次设置多个key value |
| mget | 一次获得多个key的value |
| getset | 获得原始key的值，同时设置新值 |
| strlen | 获得对应key存储value的长度 |
| append | 为对应key的value追加内容 |
| getrange 索引0开始 | 截取value的内容 |
| setex | 设置一个key存活的有效期（秒） |
| psetex | 设置一个key存活的有效期（毫秒） |
| setnx | 存在不做任何操作,不存在添加 |
| msetnx原子操作(只要有一个存在不做任何操作) | 可以同时设置多个key,只有有一个存在都不保存 |
| decr | 进行数值类型的-1操作 |
| decrby | 根据提供的数据进行减法操作 |
| Incr | 进行数值类型的+1操作 |
| incrby | 根据提供的数据进行加法操作 |
| Incrbyfloat | 根据提供的数据加入浮点数 |
3.4 List类型
- list 列表 相当于java中list 集合 特点 元素有序 且 可以重复
- Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）
- 它的底层实际是个链表
3.4.1 内存存储模型
3.4.2 常用操作指令
| 命令 | 说明 |
|---|---|
| lpush | 将某个值加入到一个key列表头部 |
| lpushx | 同lpush,但是必须要保证这个key存在 |
| rpush | 将某个值加入到一个key列表末尾 |
| rpushx | 同rpush,但是必须要保证这个key存在 |
| lpop | 返回和移除列表左边的第一个元素，lpop弹出元素后,该元素就不再集合了 |
| rpop | 返回和移除列表右边的第一个元素 |
| lrange | 获取某一个下标区间内的元素 |
| llen | 获取列表元素个数 |
| lset | 设置某一个指定索引的值(索引必须存在) |
| lindex | 获取某一个指定索引位置的元素 |
| lrem | 删除重复元素 |
| ltrim | 保留列表中特定区间内的元素 |
| linsert | 在某一个元素之前，之后插入新元素 |
总结：
- 它是一个字符串链表，left、right都可以插入添加；
- 如果键不存在，创建新的链表；
- 如果键已存在，新增内容；
- 如果值全移除，对应的键也就消失了。
- 链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了
3.5 Set类型
特点: Set类型 Set集合 元素无序 不可以重复,Redis的Set是string类型的无序集合。它是通过HashTable实现实现的
3.5.1 内存存储模型
3.5.2 常用操作指令
| 命令 | 说明 |
|---|---|
| sadd | 为集合添加元素 |
| smembers | 查看集合中是否存在某个值,存在返回1,不存在返回0, 无序 |
| scard | 返回集合中元素的个数 |
| spop | 随机返回一个元素 并将元素在集合中删除 |
| smove | 从一个集合中向另一个集合移动元素 必须是同一种类型 |
| srem | 从集合中删除一个元素 |
| sismember | 判断一个集合中是否含有这个元素 |
| srandmember | 随机返回元素 |
| sdiff | 去掉第一个集合中其它集合含有的相同元素 |
| sinter | 求交集 |
| sunion | 求和集 |
3.6 ZSet类型
- 特点: 可排序的set集合 排序 不可重复
- ZSET 官方 可排序SET sortSet
- Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。
- redis正是通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的,但分数(score)却可以重复。
3.6.1 内存模型
3.6.1常用操作指令
| 命令 | 说明 |
|---|---|
| zadd | 添加一个有序集合元素 |
| zcard | 返回集合的元素个数 |
| zrange 升序 zrevrange 降序 | 返回一个范围内的元素 |
| zrangebyscore | 按照分数查找一个范围内的元素 |
| zrank | 返回排名 |
| zrevrank | 倒序排名 |
| zscore | 显示某一个元素的分数 |
| zrem | 移除某一个元素 |
| zincrby | 给某个特定元素加分 |
3.7 hash类型
- 特点: value 是一个map结构 存在key value key 无序的
- Redis hash 是一个键值对集合。
- Redis hash是一个string类型的field和value的映射表,hash特别适合用于存储对象
3.7.1 内存模型
3.7.2 常用操作指令
| 命令 | 说明 |
|---|---|
| hset | 设置一个key/value对 |
| hget | 获得一个key对应的value |
| hgetall | 获得所有的key/value对 |
| hdel | 删除某一个key/value对 |
| hexists | 判断一个key是否存在 |
| hkeys | 获得所有的key |
| hvals | 获得所有的value |
| hmset | 设置多个key/value |
| hmget | 获得多个key的value |
| hsetnx | 设置一个不存在的key的值 |
| hincrby | 为value进行加法运算 |
| hincrbyfloat | 为value加入浮点值 |
4. redis配置文件
为什么我将redis.conf拷贝出来单独执行
- 在生产环境上修改配置文件,不能保证每次都修改正确,所以需要将配置文件复制一份,在复制的文件上做修改,启动时也启动复制修改的文件.
units单位：
配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit， 对大小写不敏感
INCLUDES包含
和我们的Struts2配置文件类似，可以通过includes包含，redis.conf可以作为总闸，包含其他
GENERAL通用的一些配置
1.daemonize介绍
A、redis.conf配置文件中daemonize守护线程，默认是NO。
B、daemonize是用来指定redis是否要用守护线程的方式启动。
daemonize 设置yes或者no区别
daemonize:yes:redis采用的是单进程多线程的模式。当redis.conf中选项daemonize设置成yes时，代表开启守护进程模式。在该模式下，redis会在后台运行，并将进程pid号写入至redis.conf选项pidfile设置的文件中，此时redis将一直运行，除非手动kill该进程。
daemonize:no: 当daemonize选项设置成no时，当前界面将进入redis的命令行界面，exit强制退出或者关闭连接工具(putty,xshell等)都会导致redis进程退出。
2. pidfile /var/run/redis_6379.pid
当Redis以守护进程方式运行时，即使该项没有配置，Redis也会默认把pid写入/var/run/redis.pid文件；而当Redis不是以守护进程凡是运行时，若该项没有配置，则redis不会创建pid文件。创建pid文件是尝试性的动作，即使创建写入失败，redis依然可以启动运行
3.port 6379
指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字
4.tcp-backlog
设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。
在高并发环境下你需要一个高backlog值来避免慢客户端连接问题。注意Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值，所以需要确认增大somaxconn和tcp_max_syn_backlog两个值来达到想要的效果
5.bind 127.0.0.1
绑定的主机地址，如果想全部访问不做限制的话，全为0.0.0.0,
6.timeout 300
当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
7.tcp-keepalive
单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60
8.loglevel notice
日志记slave-serve-stale-data yes：在master服务器挂掉或者同步失败时，从服务器是否继续提供服务。录等级，有4个可选值，debug，verbose（默认值），notice，warning
9.logfile ""
日志记录方式，配置空字符串强制让日志打到标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null
10.syslog-enabled
是否把日志输出到syslog中
11.syslog-ident
指定syslog里的日志标志
12.syslog-facility
指定syslog设备，值可以是USER或LOCAL0-LOCAL7
13.databases
设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id
SNAPSHOTTING快照
1.save <seconds> <changes>
指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
RDB是整个内存的压缩过的Snapshot，RDB的数据结构，可以配置复合的快照触发条件，默认
如果想禁用RDB持久化的策略，只要不设置任何save指令，或者给save传入一个空字符串参数也可以
Redis默认配置文件中提供了三个条件：
save 900 1
save 300 10
save 60 10000
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。
2.stop-writes-on-bgsave-error
如果以RDB的方式持久化数据时出错了，redis默认将不接收写入操作，以便让应用层感知出现问题了，配置为no禁用；
如果配置成no，表示你不在乎数据不一致或者有其他的手段发现和控制
3. rdbcompression
rdbcompression：对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用
LZF算法进行压缩。如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能
指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
4. rdbchecksum
rdbchecksum：在存储快照后，还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加大约
10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能
5. dbfilename
指定本地数据库文件名，默认值为dump.rdb
6. dir
指定本地数据库存放目录
REPLICATION复制
SECURITY安全:访问密码的查看、设置和取消
APPEND ONLY MODE追加
1. appendonly
指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
2. appendfilename
指定更新日志文件名，默认为appendonly.aof
3.appendfsync
always：同步持久化 每次发生数据变更会被立即记录到磁盘 性能较差但数据完整性比较好
everysec：出厂默认推荐，异步操作，每秒记录 如果一秒内宕机，有数据丢失
指定更新日志条件，共有3个可选值：
no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折衷，默认值）
4.no-appendfsync-on-rewrite：重写时是否可以运用Appendfsync，用默认no即可，保证数据安全性。
5.auto-aof-rewrite-min-size：设置重写的基准值
6.auto-aof-rewrite-percentage：设置重写的基准值
redis.conf配置文件中的常用配置说明：
参数说明
redis.conf 配置项说明如下：
1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程
daemonize no
2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定
pidfile /var/run/redis.pid
3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字
port 6379
4. 绑定的主机地址
bind 127.0.0.1
5.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能
timeout 300
6. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose
loglevel verbose
7. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null
logfile stdout
8. 设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id
databases 16
9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合
save <seconds> <changes>
Redis默认配置文件中提供了三个条件：
save 900 1
save 300 10
save 60 10000
分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。
10. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大
rdbcompression yes
11. 指定本地数据库文件名，默认值为dump.rdb
dbfilename dump.rdb
12. 指定本地数据库存放目录
dir ./
13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步
slaveof <masterip> <masterport>
14. 当master服务设置了密码保护时，slav服务连接master的密码
masterauth <master-password>
15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH <password>命令提供密码，默认关闭
requirepass foobared
16. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息
maxclients 128
17. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区
maxmemory <bytes>
18. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no
appendonly no
19. 指定更新日志文件名，默认为appendonly.aof
appendfilename appendonly.aof
20. 指定更新日志条件，共有3个可选值：
no：表示等操作系统进行数据缓存同步到磁盘（快）
always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全）
everysec：表示每秒同步一次（折衷，默认值）
appendfsync everysec
21. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）
vm-enabled no
22. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享
vm-swap-file /tmp/redis.swap
23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
vm-max-memory 0
24. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值
vm-page-size 32
25. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。
vm-pages 134217728
26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4
vm-max-threads 4
27. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启
glueoutputbuf yes
28. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法
hash-max-zipmap-entries 64
hash-max-zipmap-value 512
29. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）
activerehashing yes
30. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件
include /path/to/local.conf
5. 持久化机制
client redis[内存] --> 内存数据–> 数据持久化–> 磁盘
Redis官方提供了两种不同的持久化方法来将数据存储到硬盘里面分别是:
- 快照(Snapshot) 也称为RDB方式
- AOF (Append Only File) 只追加日志文件
5.1 快照(Snapshot)(RDB)
5.1.1 快照特点
- 这种方式可以将某一时刻的所有数据都写入硬盘中，当然这也是redis的默认开启持久化方式，保存的文件是以.rdb形式结尾的文件因此这种方式也称之为RDB方式。
- 在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里
- Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到
一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件- 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能，如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方
式要比AOF方式更加的高效- RDB的缺点是最后一次持久化后的数据可能丢失
5.1.2 快照生成方式
- 客户端方式: BGSAVE 和 SAVE指令
- 服务器配置自动触发
# 1.客户端方式之BGSAVE
- a.客户端可以使用BGSAVE命令来创建一个快照,当接收到客户端的BGSAVE命令时,redis会调用fork¹来创建一个子进程,然后子进程负责将快照写入磁盘中,而父进程则继续处理命令请求。
`名词解释: fork当一个进程创建子进程的时候,底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化:在刚开始的时候,父子进程共享相同内存,直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务`
# 2.客户端方式之SAVE
- b.客户端还可以使用SAVE命令来创建一个快照,接收到SAVE命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令
注意: SAVE命令并不常用,使用SAVE命令在快照创建完毕之前,redis处于阻塞状态,无法对外服务
# 3.服务器配置方式之满足配置自动触发
- 如果用户在redis.conf中设置了save配置选项,redis会在save选项条件满足之后自动触发一次BGSAVE命令,如果设置多个save配置选项,当任意一个save配置选项条件满足,redis也会触发一次BGSAVE命令
配置解读：选择其中一条配置即可
- save “ ” ：表示禁用rdb方式来保存数据
- “save 900 1”：表示如果900秒内至少1个key发生变化（新增、修改和删除），则重写rdb文件
- “save 300 10”：表示如果每300秒内至少10个key发生变化（新增、修改和删除），则重写rdb文件
- “save 60 3600”：表示如果每60秒内至少10000个key发生变化（新增、修改和删除），则重写rdb文件
# 4.服务器接收客户端shutdown指令
- 当redis通过shutdown指令接收到关闭服务器的请求时,会执行一个save命令,阻塞所有的客户端,不再执行客户端执行发送的任何命令,并且在save命令执行完毕之后关闭服务器
# 5.原理
Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。
整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等）
数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程
如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。
RDB的缺点是最后一次持久化后的数据可能丢失。
5.1.3 配置生成快照名称和位置
#1.修改生成快照名称
- dbfilename dump.rdb
# 2.修改生成位置
- dir ./
RDB优缺点：
优点:
- 适合大规模的数据恢复
- 对数据完整性和一致性要求不高
缺点:
- 在一定间隔时间做一次备份，所以如果redis意外down掉的话，就会丢失最后一次快照后的所有修改
- Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑
补充：
- 动态所有停止RDB保存规则的方法：redis-cli config set save “”
- 获取最后一次快照的时间：last save命令
5.2 AOF
5.2.1 AOF特点
- 只追加日志文件,这种方式可以将所有客户端执行的写命令记录到日志文件中,AOF持久化会将被执行的写命令写到AOF的文件末尾,以此来记录数据发生的变化,因此只要redis从头到尾执行一次AOF文件所包含的所有写命令,就可以恢复AOF文件的记录的数据集
- AOF比RDB优点在于数据的实时性高，经过设置后最多只会损失一秒钟的数据，而RDB最多可能损失上次备份到此次DOWM机间的数据
原理：
以日志的形式来记录每个写操作，将Redis执行过的所有写指令记录下来(读操作不记录)，只许追加文件但不可以改写文件，Redis启动之处会读取该文件重新构建数据，换言之，Redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
5.2.2 开启AOF持久化
在redis的默认配置中AOF持久化机制是没有开启的，需要在配置中开启
# 1.开启AOF持久化
- a.修改 appendonly yes 开启持久化
- b.修改 appendfilename "appendonly.aof" 指定生成文件名称
5.2.3 日志追加频率
# 1.always 【谨慎使用】
- 说明: 每个redis写命令都要同步写入硬盘,严重降低redis速度
- 解释: 如果用户使用了always选项,那么每个redis写命令都会被写入硬盘,从而将发生系统崩溃时出现的数据丢失减到最少;遗憾的是,因为这种同步策略需要对硬盘进行大量的写入操作,所以redis处理命令的速度会受到硬盘性能的限制;
- 注意: 转盘式硬盘在这种频率下200左右个命令/s ; 固态硬盘(SSD) 几百万个命令/s;
- 警告: 使用SSD用户请谨慎使用always选项,这种模式不断写入少量数据的做法有可能会引发严重的写入放大问题,导致将固态硬盘的寿命从原来的几年降低为几个月。
# 2.everysec 【推荐】
- 说明: 每秒执行一次同步显式的将多个写命令同步到磁盘
- 解释： 为了兼顾数据安全和写入性能,用户可以考虑使用everysec选项,让redis每秒一次的频率对AOF文件进行同步;redis每秒同步一次AOF文件时性能和不使用任何持久化特性时的性能相差无几,而通过每秒同步一次AOF文件,redis可以保证,即使系统崩溃,用户最多丢失一秒之内产生的数据。
# 3.no 【不推荐】
- 说明: 由操作系统决定何时同步
- 解释：最后使用no选项,将完全有操作系统决定什么时候同步AOF日志文件,这个选项不会对redis性能带来影响但是系统崩溃时,会丢失不定数量的数据,另外如果用户硬盘处理写入操作不够快的话,当缓冲区被等待写入硬盘数据填满时,redis会处于阻塞状态,并导致redis的处理命令请求的速度变慢。
5.2.4 修改同步频率
# 1.修改日志同步频率
- 修改appendfsync everysec|always|no 指定
5.3 AOF文件的重写
5.3.1 AOF带来的问题
AOF的方式也同时带来了另一个问题。持久化文件会变的越来越大。例如我们调用incr test命令100次，文件中必须保存全部的100条命令，其实有99条都是多余的。因为要恢复数据库的状态其实文件中保存一条set test 100就够了。为了压缩aof的持久化文件Redis提供了AOF重写(ReWriter)机制。
5.3.2 AOF重写
用来在一定程度上减小AOF文件的体积
5.3.3 触发重写方式
# 1.客户端方式触发重写
- 执行BGREWRITEAOF命令 不会阻塞redis的服务
# 2.服务器配置方式自动触发
- 配置redis.conf中的auto-aof-rewrite-percentage选项 参见下图↓↓↓
- 如果设置auto-aof-rewrite-percentage值为100和auto-aof-rewrite-min-size 64mb,并且启用的AOF持久化时,那么当AOF文件体积大于64M,并且AOF文件的体积比上一次重写之后体积大了至少一倍(100%)时,会自动触发,如果重写过于频繁,用户可以考虑将auto-aof-rewrite-percentage设置为更大
- No-appendsync-on-rewrite：重写时是否可以运用Appendfsync，用默认no即可，保证数据安全性
- Auto-aof-rewrite-min-size：设置重写的基准值
- Auto-aof-rewrite-percentage：设置重写的基准值
5.3.4 重写原理
注意：重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,替换原有的文件这点和快照有点类似。
# 重写流程
- 1. redis调用fork ，现在有父子两个进程 子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令
- 2. 父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。
- 3. 当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。
- 4. 现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。
5.4 持久化总结
- 两种持久化方案既可以同时使用(aof),又可以单独使用,在某种情况下也可以都不使用,具体使用那种持久化方案取决于用户的数据和应用决定。
- 无论使用AOF还是快照机制持久化,将数据持久化到硬盘都是有必要的,除了持久化外,用户还应该对持久化的文件进行备份(最好备份在多个不同地方)
两种方式配合使用：
性能建议：
- 因为RDB文件只用做后备用途，建议只在Slave上持久化RDB文件，而且只需要15分钟备份一次就够了，只保留save 900 1这条规则
- 如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单，只load自己的AOF文件就可以了。代价一是带来了持续的IO，而是AOF rewriter的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎不可避免的。只要硬盘许可，应该尽快减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上。默认超过原大小100%大小时，重写可以改到适当的数值
- 如果不Enable AOF，仅靠Master-Slave Replication实现高可用性也可以。能省掉一大笔IO也减少了rewrite时带来的系统波动。代价是如果Master/Slave同事倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的RDB文件，载入较新的那个
6. java操作Redis
6.1 环境准备
6.1.1 引入依赖
<!--引入jedis连接依赖-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
6.1.2 创建jedis对象
public static void main(String[] args) {
//1.创建jedis对象
Jedis jedis = new Jedis("192.168.40.4", 6379);//1.redis服务必须关闭防火墙 2.redis服务必须开启远程连接
jedis.select(0);//选择操作的库默认0号库
//2.执行相关操作
//....
//3.释放资源
jedis.close();
}
public static void main(String[] args) {
//创建jedis客户端对象
Jedis jedis = new Jedis("39.105.61.8", 6379);
//选择使用一个库，默认使用0号库
jedis.select(0);
//获取redis中所有的key
Set<String> keys = jedis.keys("*");
keys.forEach(key -> System.out.println("key="+key));
//操作库相关api
//jedis.flushAll(); //清空所有库
//jedis.flushDB(); //清空当前库
//释放资源
jedis.close();
}
6.2 操作key相关API
/**
* 操作key相关的api
*/
public class TestKey {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
jedis.select(0);
}
@After
public void after(){
jedis.close();
}
@Test
public void testKeys(){
//删除一个key
jedis.del("key1");
//删除多个key
//jedis.del("key2","key3");
//判断一个key是否存在exits
Boolean key1 = jedis.exists("key2");
System.out.println(key1);
//设置一个key超时时间 expire pexpire
Long key2 = jedis.expire("key2", 100);
System.out.println(key2);
//获取一个key超时时间 ttl
Long key2ttl = jedis.ttl("key2");
System.out.println(key2ttl);
随机获取一个key
String key = jedis.randomKey();
System.out.println(key);
//修改key名称
jedis.rename("key2","key5");
//查看可以对应值的类型
String name1 = jedis.type("key2");
System.out.println(name1);
String maps = jedis.type("ket5");
System.out.println(maps);
//查看所有的key
Set<String> keys = jedis.keys("*");
System.out.println(keys);
}
}
6.3 操作String相关API
/**
* 操作String相关的API
*/
public class TestString {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
}
@After
public void after(){
jedis.close();
}
@Test
public void testString(){
//set
jedis.set("name","chentf");
//get
String value = jedis.get("name");
System.out.println(value);
//mset
jedis.mset("address", "湖北武汉", "email", "ctflq@163.com");
//mget
List<String> mget = jedis.mget("address", "email");
mget.forEach(m -> System.out.println("m ->"+m));
//getset
String set = jedis.getSet("name", "小明");
System.out.println(set);
}
}
6.4 操作List相关API
public class TestList {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
}
@After
public void after(){
jedis.close();
}
@Test
public void testList(){
//lpush
jedis.lpush("name1","张三","李四","王五");
//rpush
jedis.rpush("name2","sunwukong");
//lrange
List<String> name1 = jedis.lrange("name1", 0, -1);
name1.forEach(name -> System.out.println("name = "+name));
//lpop rpop
String names11 = jedis.lpop("names1");
System.out.println(names11);
//llen
jedis.linsert("lists", BinaryClient.LIST_POSITION.BEFORE,"xiaohei","xiaobai");
}
}
6.5 操作Set的相关API
public class TestSet {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
}
@After
public void after(){
jedis.close();
}
@Test
public void testSet(){
//sadd
jedis.sadd("name3","宋江","李逵");
//smembers
jedis.smembers("names");
//sismember
jedis.sismember("names","xiaochen");
}
}
6.6 操作ZSet相关API
/**
* 测试zset相关API
*/
public class TestZSet {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
}
@After
public void after(){
jedis.close();
}
@Test
public void testZSet(){
//zadd
jedis.zadd("names",10,"张三");
//zrange
jedis.zrange("names",0,-1);
//zcard
jedis.zcard("names");
//zrangeByScore
jedis.zrangeByScore("names","0","100",0,5);
}
}
6.7 操作Hash相关API
public class TestHash {
private Jedis jedis;
@Before
public void before(){
this.jedis = new Jedis("39.105.61.8", 6379);
}
@After
public void after(){
jedis.close();
}
@Test
public void testHash(){
//hset
jedis.hset("maps","name","zhangsan");
//hget
jedis.hget("maps","name");
//hgetall
jedis.hgetAll("mps");
//hkeys
jedis.hkeys("maps");
//hvals
jedis.hvals("maps");
}
}
7. SpringBoot整合Redis
Spring Boot Data(数据) Redis 中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象，而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。
注意: 使用RedisTemplate默认是将对象序列化到Redis中,所以放入的对象必须实现对象序列化接口
7.1 环境准备
7.1.1 引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
7.1.2 配置application.propertie
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0
7.2 使用StringRedisTemplate和RedisTemplate
//启动springboot应用
@SpringBootTest(classes = RedisDay2Application.class)
@RunWith(SpringRunner.class)
public class TestRedisTemplate {
//注入RedisTemplate key Object Value Object ===> 对象序列化 name new User() ====> name序列化 对象序列化结果
@Autowired
private RedisTemplate redisTemplate;
//opsForxxx Value String List Set Zset hash
@Test
public void testRedisTemplate(){
/**
* redisTemplate对象中 key 和 value 的序列化都是 JdkSerializationRedisSerializer
* key: string
* value: object
* 修改默认key序列化方案 : key StringRedisSerializer
*/
//修改key序列化方案 String类型序列
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
User user = new User();
user.setId(UUID.randomUUID().toString()).setName("张三").setAge(30).setBir(new Date());
redisTemplate.opsForValue().set("user",user); //redis进行设置 对象需要经过序列化
User user1 = (User)redisTemplate.opsForValue().get("user");
System.out.println(user1);
redisTemplate.opsForList().leftPush("list",user);
redisTemplate.opsForSet().add("set",user);
redisTemplate.opsForZSet().add("zset",user,10);
redisTemplate.opsForHash().put("map","name",user);
}
}
@SpringBootTest(classes = RedisDay2Application.class)
@RunWith(SpringRunner.class)
public class TestBoundAPI {
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
//spring data 为了方便我们对redis进行更友好的操作 因此有提供了bound api 简化操作
@Test
public void testBound() {
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//redisTemplate stringRedisTemplate 将一个key多次操作进行绑定 对key绑定
// stringRedisTemplate.opsForValue().set("name", "xufengnian");
// stringRedisTemplate.opsForValue().append("name", "扶墙而出");
// String name = stringRedisTemplate.opsForValue().get("name");
// System.out.println(name);
//对字符串类型key进行绑定 后续所有操作都是基于这个key的操作
BoundValueOperations<String, String> nameValueOperations = stringRedisTemplate.boundValueOps("name");
nameValueOperations.set("xuxiao");
nameValueOperations.append("人屠啊");
String xuxiao = nameValueOperations.get();
System.out.println(xuxiao);
//对list set zset hash
BoundListOperations<String, String> listsOperations = stringRedisTemplate.boundListOps("lists");
listsOperations.leftPushAll("张三","李四","小陈");
List<String> lists = listsOperations.range(0, -1);
lists.forEach(list-> System.out.println(list));
//set
//redisTemplate.boundSetOps();
//stringRedisTemplate.boundSetOps()
//zset
//stringRedisTemplate.boundZSetOps();
//redisTemplate.boundZSetOps();
//hash
//stringRedisTemplate.boundHashOps();
//redisTemplate.boundHashOps()
/**
* 1.针对于日后处理key value 都是 String 使用 StringRedisTemplate
* 2.针对于日后处理的key value 存在对象 使用 RedisTemplate
* 3.针对于同一个key多次操作可以使用boundXXxOps() Value List Set Zset Hash的api 简化书写
*/
/**
* redis应用场景
*
* 1.利用redis 中字符串类型完成 项目中手机验证码存储的实现
* 2.利用redis 中字符串类型完成 具有失效性业务功能 12306 淘宝 订单还有:40分钟
* 3.利用redis 分布式集群系统中 Session共享 memcache 内存 数据存储上限 数据类型比较简单 redis 内存 数据上限 数据类型丰富
* 4.利用redis zset类型 可排序set类型 元素 分数 排行榜之类功能 dangdang 销量排行 sales(zset) [商品id,商品销量] ......
* 5.利用redis 分布式缓存 实现
* 6.利用redis 存储认证之后token信息 微信小程序 微信公众号 |用户 openid ---> 令牌(token) redis 超时
* 7.利用redis 解决分布式集群系统中分布式锁问题 redis 单进程 单线程 n 20 定义
* jvm 1进程开启多个线程 synchronize int n=20
* jvm 1进程开启多个线程 synchronize int n=20
* ..... LRA脚本
*
*/
}
}
@SpringBootTest(classes = RedisDay2Application.class)
@RunWith(SpringRunner.class)
public class TestStringRedisTemplate {
//注入StringRedisTemplate
@Autowired
private StringRedisTemplate stringRedisTemplate; //key value 都是字符串
//操作redis中key相关
@Test
public void testKey(){
//删除一个key
// stringRedisTemplate.delete("name");
//判断某个key是否存在
Boolean hasKey = stringRedisTemplate.hasKey("name");
System.out.println(hasKey);
//判断key所对应值的类型
DataType name = stringRedisTemplate.type("name");
System.out.println(name);
//获取redis中所有的key
Set<String> keys = stringRedisTemplate.keys("*");
keys.forEach(key -> System.out.println("key = "+key));
//获取key的超时时间 -1：永不超时 -2：key不存在>=0过去时间
Long expire = stringRedisTemplate.getExpire("key = " + keys);
System.out.println(expire);
stringRedisTemplate.randomKey();//在redis中随机获取一个key
//stringRedisTemplate.rename("age","age1");//修改key名字 要求key必须存在 不存在 报错
//stringRedisTemplate.renameIfAbsent("name","name1");//修改key名字 判断key是否存在
stringRedisTemplate.move("name1",1);//移动key到指定库
}
//操作redis中字符串 opsForValue 实际操作就是redis中String类型
@Test
public void testString(){
stringRedisTemplate.opsForValue().set("name","小陈"); //set 用来设置一个key value
String value= stringRedisTemplate.opsForValue().get("name"); //用来获取一个key对应value
System.out.println("value = " + value);
stringRedisTemplate.opsForValue().set("code","2357",120, TimeUnit.SECONDS);//设置一个key 超时时间
stringRedisTemplate.opsForValue().append("name","他是是一个好人,单纯少年!");//追加
}
//操作redis中list类型 opsForList 实际操作就是redis中list类型
@Test
public void testList(){
//stringRedisTemplate.opsForList().leftPush("names","小陈");//创建一个列表 并放入一个元素
//stringRedisTemplate.opsForList().leftPushAll("names","小陈","小张","小王");//创建一个列表 放入多个元素
List<String> names = new ArrayList<>();
names.add("xiaoming");
names.add("xiaosan");
//stringRedisTemplate.opsForList().leftPushAll("names",names);//创建一个列表 放入多个元素
List<String> stringList = stringRedisTemplate.opsForList().range("names", 0, -1); //遍历list
stringList.forEach(value-> System.out.println("value = " + value));
stringRedisTemplate.opsForList().trim("names",1,3); //截取指定区间的list
}
//操作redis中set类型 opsForSet 实际操作就是redis中set类型
@Test
public void testSet(){
stringRedisTemplate.opsForSet().add("sets","张三","张三","小陈","xiaoming");//创建set 并放入多个元素
Set<String> sets = stringRedisTemplate.opsForSet().members("sets");//查看set中成员
sets.forEach(value-> System.out.println("value = " + value));
Long size = stringRedisTemplate.opsForSet().size("sets");//获取set集合元素个数
System.out.println("size = " + size);
}
//操作redis中Zset类型 opsForZSet 实际操作就是redis中Zset类型
@Test
public void testZset(){
stringRedisTemplate.opsForZSet().add("zsets","小黑",20);//创建并放入元素
Set<String> zsets = stringRedisTemplate.opsForZSet().range("zsets", 0, -1);//指定范围查询
zsets.forEach(value-> System.out.println(value));
System.out.println("=====================================");
Set<ZSetOperations.TypedTuple<String>> zsets1 = stringRedisTemplate.opsForZSet().rangeByScoreWithScores("zsets", 0, 1000);//获取指定元素以及分数
zsets1.forEach(typedTuple ->{
System.out.println(typedTuple.getValue());
System.out.println(typedTuple.getScore());
});
}
//操作redis中Hash类型 opsForHash 实际操作就是redis中Hash类型
@Test
public void testHash(){
stringRedisTemplate.opsForHash().put("maps","name","张三");//创建一个hash类型 并放入key value
Map<String,String> map = new HashMap<String,String>();
map.put("age","12");
map.put("bir","2012-12-12");
stringRedisTemplate.opsForHash().putAll("maps",map); //放入多个key value
List<Object> values = stringRedisTemplate.opsForHash().multiGet("maps", Arrays.asList("name", "age"));//获取多个key的value
values.forEach(value-> System.out.println(value));
String value = (String) stringRedisTemplate.opsForHash().get("maps", "name");//获取hash中某个key的值
List<Object> vals = stringRedisTemplate.opsForHash().values("maps");//获取所有values
Set<Object> keys = stringRedisTemplate.opsForHash().keys("maps");//获取所有keys
}
}
@Autowired
private StringRedisTemplate stringRedisTemplate; //对字符串支持比较友好,不能存储对象
@Autowired
private RedisTemplate redisTemplate; //存储对象
@Test
public void testRedisTemplate(){
System.out.println(redisTemplate);
//设置redistemplate值使用对象序列化策略
redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());//指定值使用对象序列化
//redisTemplate.opsForValue().set("user",new User("21","小黑",23,new Date()));
User user = (User) redisTemplate.opsForValue().get("user");
System.out.println(user);
// Set keys = redisTemplate.keys("*");
// keys.forEach(key -> System.out.println(key));
/*Object name = redisTemplate.opsForValue().get("name");
System.out.println(name);*/
//Object xiaohei = redisTemplate.opsForValue().get("xiaohei");
//System.out.println(xiaohei);
/*redisTemplate.opsForValue().set("name","xxxx");
Object name = redisTemplate.opsForValue().get("name");
System.out.println(name);*/
/*redisTemplate.opsForList().leftPushAll("lists","xxxx","1111");
List lists = redisTemplate.opsForList().range("lists", 0, -1);
lists.forEach(list-> System.out.println(list));*/
}
//key的绑定操作 如果日后对某一个key的操作及其频繁,可以将这个key绑定到对应redistemplate中,日后基于绑定操作都是操作这个key
//boundValueOps 用来对String值绑定key
//boundListOps 用来对List值绑定key
//boundSetOps 用来对Set值绑定key
//boundZsetOps 用来对Zset值绑定key
//boundHashOps 用来对Hash值绑定key
@Test
public void testBoundKey(){
BoundValueOperations<String, String> nameValueOperations = stringRedisTemplate.boundValueOps("name");
nameValueOperations.set("1");
//yuew
nameValueOperations.set("2");
String s = nameValueOperations.get();
System.out.println(s);
}
//hash相关操作 opsForHash
@Test
public void testHash(){
stringRedisTemplate.opsForHash().put("maps","name","小黑");
Object o = stringRedisTemplate.opsForHash().get("maps", "name");
System.out.println(o);
}
//zset相关操作 opsForZSet
@Test
public void testZSet(){
stringRedisTemplate.opsForZSet().add("zsets","小黑",10);
Set<String> zsets = stringRedisTemplate.opsForZSet().range("zsets", 0, -1);
zsets.forEach(value-> System.out.println(value));
}
//set相关操作 opsForSet
@Test
public void testSet(){
stringRedisTemplate.opsForSet().add("sets","xiaosan","xiaosi","xiaowu");
Set<String> sets = stringRedisTemplate.opsForSet().members("sets");
sets.forEach(value-> System.out.println(value));
}
//list相关的操作opsForList
@Test
public void testList(){
// stringRedisTemplate.opsForList().leftPushAll("lists","张三","李四","王五");
List<String> lists = stringRedisTemplate.opsForList().range("lists", 0, -1);
lists.forEach(key -> System.out.println(key));
}
//String相关的操作 opsForValue
@Test
public void testString(){
//stringRedisTemplate.opsForValue().set("166","好同学");
String s = stringRedisTemplate.opsForValue().get("166");
System.out.println(s);
Long size = stringRedisTemplate.opsForValue().size("166");
System.out.println(size);
}
//key相关的操作
@Test
public void test(){
Set<String> keys = stringRedisTemplate.keys("*");//查看所有key
Boolean name = stringRedisTemplate.hasKey("name");//判断某个key是否存在
stringRedisTemplate.delete("age");//根据指定key删除
stringRedisTemplate.rename("","");//修改key的名称
stringRedisTemplate.expire("key",10, TimeUnit.HOURS);
//设置key超时时间 参数1:设置key名 参数2:时间 参数3:时间的单位
stringRedisTemplate.move("",1);//移动key
}
8 Redis 主从复制
8.1 主从复制
主从复制架构仅仅用来解决数据的冗余备份,从节点仅仅用来同步数据
无法解决: 1.master节点出现故障的自动故障转移
8.2 主从复制架构图
8.3 搭建主从复制
# 1.准备3台机器并修改配置
- master
port 6379
bind 0.0.0.0
- slave1
port 6380
bind 0.0.0.0
slaveof masterip masterport
- slave2
port 6381
bind 0.0.0.0
slaveof masterip masterport
# 2.启动3台机器进行测试
- cd /usr/redis/bin
- ./redis-server /root/master/redis.conf
- ./redis-server /root/slave1/redis.conf
- ./redis-server /root/slave2/redis.conf
9 Redis哨兵机制
9.1 哨兵Sentinel机制
Sentinel（哨兵）是Redis 的高可用性解决方案：由一个或多个Sentinel 实例 组成的Sentinel 系统可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器。简单的说哨兵就是带有自动故障转移功能的主从架构。
无法解决: 1.单节点并发压力问题 2.单节点内存和磁盘物理上限
9.2 哨兵架构原理
9.3 搭建哨兵架构
# 1.在主节点上创建哨兵配置
- 在Master对应redis.conf同目录下新建sentinel.conf文件，名字绝对不能错；
# 2.配置哨兵，在sentinel.conf文件中填入内容：
- sentinel monitor 被监控数据库名字（自己起名字） ip port 1
说明：最后的2的含义与主节点的故障判定有关：至少需要2个哨兵节点同意，才能判定主节点故障并进行故障转移。
说明：这个后面的数字2,是指当有两个及以上的sentinel服务检测到master宕机，才会去执行主从切换的功能。
# 3.启动哨兵模式进行测试
- redis-sentinel /root/sentinel/sentinel.conf
9.4 通过springboot操作哨兵
# redis sentinel 配置
# master书写是使用哨兵监听的那个名称
spring.redis.sentinel.master=mymaster
# 连接的不再是一个具体redis主机,书写的是多个哨兵节点
spring.redis.sentinel.nodes=192.168.202.206:26379
注意:如果连接过程中出现如下错误:RedisConnectionException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface. If you want to connect from external computers to Redis you may adopt one of the following solutions: 1) Just disable protected mode sending the command ‘CONFIG SET protected-mode no’ from the loopback interface by connecting to Redis from the same host the server is running, however MAKE SURE Redis is not publicly accessible from internet if you do so. Use CONFIG REWRITE to make this change permanent. 2)
解决方案:在哨兵的配置文件中加入bind 0.0.0.0 开启远程连接权限
10 Redis集群
10.1 集群
Redis在3.0后开始支持Cluster(模式)模式,目前redis的集群支持节点的自动发现,支持slave-master选举和容错,支持在线分片(sharding shard )等特性。reshard
10.2 集群架构图
10.3 集群细节
- 所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.
- 节点的fail是通过集群中超过半数的节点检测失效时才生效.
- 客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可
- redis-cluster把所有的物理节点映射到[0-16383]slot上,cluster 负责维护node<->slot<->value
10.4 集群搭建
判断一个是集群中的节点是否可用,是集群中的所用主节点选举过程,如果半数以上的节点认为当前节点挂掉,那么当前节点就是挂掉了,所以搭建redis集群时建议节点数最好为奇数，搭建集群至少需要三个主节点,三个从节点,至少需要6个节点。
# 1.准备环境安装ruby以及redis集群依赖
- yum install -y ruby rubygems
- gem install redis-xxx.gem
# 2.在一台机器创建7个目录
# 3.每个目录复制一份配置文件
[root@localhost ~]# cp redis-4.0.10/redis.conf 7000/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7001/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7002/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7003/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7004/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7005/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7006/
# 4.修改不同目录配置文件
- port 6379 ..... //修改端口
- bind 0.0.0.0 //开启远程连接
- cluster-enabled yes //开启集群模式
- cluster-config-file nodes-port.conf //集群节点配置文件
- cluster-node-timeout 5000 //集群节点超时时间
- appendonly yes //开启AOF持久化
# 5.指定不同目录配置文件启动七个节点
- [root@localhost bin]# ./redis-server /root/7000/redis.conf
- [root@localhost bin]# ./redis-server /root/7001/redis.conf
- [root@localhost bin]# ./redis-server /root/7002/redis.conf
- [root@localhost bin]# ./redis-server /root/7003/redis.conf
- [root@localhost bin]# ./redis-server /root/7004/redis.conf
- [root@localhost bin]# ./redis-server /root/7005/redis.conf
- [root@localhost bin]# ./redis-server /root/7006/redis.conf
# 6.查看进程
- [root@localhost bin]# ps aux|grep redis
10.4.1 创建集群
# 1.复制集群操作脚本到bin目录中
- [root@localhost bin]# cp /root/redis-4.0.10/src/redis-trib.rb .
# 2.创建集群
- ./redis-trib.rb create --replicas 1 192.168.202.205:7000 192.168.202.205:7001 192.168.202.205:7002 192.168.202.205:7003 192.168.202.205:7004 192.168.202.205:7005
# 3.集群创建成功出现如下提示
10.4.2 查看集群状态
# 1.查看集群状态 check [原始集群中任意节点] [无]
- ./redis-trib.rb check 192.168.202.205:7000
# 2.集群节点状态说明
- 主节点
主节点存在hash slots,且主节点的hash slots 没有交叉
主节点不能删除
一个主节点可以有多个从节点
主节点宕机时多个副本之间自动选举主节点
- 从节点
从节点没有hash slots
从节点可以删除
从节点不负责数据的写,只负责数据的同步
10.4.3 添加主节点
# 1.添加主节点 add-node [新加入节点] [原始集群中任意节点]
- ./redis-trib.rb add-node 192.168.1.158:7006 192.168.1.158:7005
- 注意:
1.该节点必须以集群模式启动
2.默认情况下该节点就是以master节点形式添加
10.4.4 添加从节点
# 1.添加从节点 add-node --slave [新加入节点] [集群中任意节点]
- ./redis-trib.rb add-node --slave 192.168.1.158:7006 192.168.1.158:7000
- 注意:
当添加副本节点时没有指定主节点,redis会随机给副本节点较少的主节点添加当前副本节点
# 2.为确定的master节点添加主节点 add-node --slave --master-id master节点id [新加入节点] [集群任意节点]
- ./redis-trib.rb add-node --slave --master-id 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 127.0.0.1:7006 127.0.0.1:7000
10.4.5 删除副本节点
# 1.删除节点 del-node [集群中任意节点] [删除节点id]
- ./redis-trib.rb del-node 127.0.0.1:7002 0ca3f102ecf0c888fc7a7ce43a13e9be9f6d3dd1
- 注意:
1.被删除的节点必须是从节点或没有被分配hash slots的节点
10.4.6 集群在线分片
# 1.在线分片 reshard [集群中任意节点] [无]
- ./redis-trib.rb reshard 192.168.1.158:7000
11 Redis实现分布式Session管理
11.1 管理机制
redis的session管理是利用spring提供的session管理解决方案,将一个应用session交给Redis存储,整个应用中所有session的请求都会去redis中获取对应的session数据。
11.2 开发Session管理
11.2.1 引入依赖
<dependency>
<groupId>org.springframework.session</groupId>
<artifactId>spring-session-data-redis</artifactId>
</dependency>
11.2.2 开发Session管理配置类
@Configuration
@EnableRedisHttpSession
public class RedisSessionManager {
}
扫一扫
621
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
