Redis

1 .架构演变

1. 单机Mysql
   1. 
2. 缓存+垂直拆分
   1. 
3. 主从复制，读写分离
   1. 
4. 分库分表，水平拆分，数据库集群
   1. 
5. 当今状态
   1. 

2.NoSQL简介

1. Not Only SQL ，不仅仅是SQL，泛指非关系型数据库
2. NoSQL不依赖业务逻辑存储，而依赖key--value存储，扩展性强
3. 不遵循SQL标准，不支持ACID，性能高于SQL

3.NoSQL适用场景

1. 对数据高并发的读写
2. 海量数据的读写
3. 数据高可扩展性

4.NoSQL不适用的场景

1. 需要事务支持
2. 基于sql的结构化查询存储，处理复杂的关系，需要条件查询

5.常用的NoSQL数据库

1. Memcached
   1. 数据存储在内存中，一般不持久化
   2. 支持简单的key-value模式，只支持字符串
   3. 一般是作为 缓存数据库辅助持久化的数据库
   4. 使用多线程+锁的技术
2. Redis
   1. 几乎覆盖了Memcached的绝大部分功能
   2. 数据都在内存中，支持持久化，主要用作备份恢复
   3. 吃了支持简单的key-value模式，还支持多种数据结构
   4. 一般作为 缓存数据库辅助持久化的数据库
   5. 使用单线程+多路IO复用技术
3. MongoDB（最接近关系型数据库的非关系型数据库）
   1. 文档型数据库
   2. 数据在内存中，数据存储在环形队列中，如果内存不足，数据先进先出。
   3. 虽然是key-value模式，但是对value(尤其是json)提供把不常用的数据保存到硬盘，并提供丰富的查询功能
   4. 支持二进制数据和大型对象
   5. 可以取代RDBMS(关系型数据库)，也可以辅助RDBMS
4. HBase:Hadoop项目中的数据库
5. Cassandra
6. Neo4j
   1. 图关系数据库
   2. 主要描述社会关系，交通图，地图。

6.Redis介绍

1. 支持String(字符串)，list(链表)，set(集合)，zset(有序集合)和hash(哈希类型)，这些类型都支持push/pop, add/remove, 交集，并集，差集等操作，而且这些操作都是原子性的
2. Redis支持各种不同的排序方式
3. Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并在此基础上是西安了master-slave(主从)同步
4. 由于其拥有持久化能力和多样的数据结构，可以实现以下操作
   1. 

7.Redis文件介绍

1. Redis-benchmark:性能测试工具，可以在自己本子运行，测试本子性能(服务起来后再用)
2. Redis-check-aof:修复有问题的aof文件
3. Redis-check-dump:修复有问题的dump.rdp文件
4. Redis-sentinel:Redis集群使用
5. redis-server:启动Redis服务端
6. redis-cli:客户端

8.Redis配置    

1. 修改redis-server后台启动
   1. redis配置文件修改：
   2. deamonize:yes

9.Redis基本命令

1. redis-server:启动redis服务器
2. redis-cli -h 127.0.0.1 -p 6379 : 客户端连接服务器
3. shutdown：关闭服务器
4. exit：退出客户端 
5. select index :切换数据库；默认16个数据库，下标从0开始，select 1就会切换进1号库
6. Redis数据库没有用户名，只有一个通用密码。
7. keys * : 查询当前数据库所有的key
8. exists key: 查看当前数据库是否含有key。1表示true，0表示false. map,contsains(key)
9. type key: 查看当前key的类型
10. del key:删除key
11. expire key seconds :为键设置过期时间，单位为秒
12. ttl key：查看还有多少秒过期，-1表示永不过期，-2表示已经过期
13. dbsize ：查看当前数据库key的数量
14. flushdb: 清空当前库
15. flushall：清空所有库

10.Redis是单线程+IO 多路 复用技术(重点)

1. IO多路复用技术是指使用一个线程来检查多个文件描述符(Socket)的就绪状态，比如调用selec和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回。如果没有，则阻塞直至超时。返回后真正的操作可以在同一个线程内执行，也可以启动线程执行(比如线程池)
2. 阻塞IO, 给女神发一条短信, 说我来找你了, 然后就默默的一直等着女神下楼, 这个期间除了等待你不会做其他事情, 属于备胎做法
3. 非阻塞IO, 给女神发短信, 如果不回, 接着再发, 一直发到女神下楼, 这个期间你除了发短信等待不会做其他事情, 属于专一做法.
4. IO多路复用, 是找一个宿管大妈来帮你监视下楼的女生, 这个期间你可以些其他的事情. 例如可以顺便看看其他妹子,玩玩王者荣耀, 上个厕所等等. IO复用又包括 select, poll, epoll 模式. 那么它们的区别是什么?
   1. select大妈 每一个女生下楼, select大妈都不知道这个是不是你的女神, 她需要一个一个询问, 并且select大妈能力还有限, 最多一次帮你监视1024个妹子
   2. poll大妈不限制盯着女生的数量, 只要是经过宿舍楼门口的女生, 都会帮你去问是不是你女神
   3. epoll大妈不限制盯着女生的数量, 并且也不需要一个一个去问. 那么如何做呢? epoll大妈会为每个进宿舍楼的女生脸上贴上一个大字条,上面写上女生自己的名字, 只要女生下楼了, epoll大妈就知道这个是不是你女神了, 然后大妈再通知你.

11.Redis数据类型

1. String
   1. String是二进制安全的。意味着String可以包含任何数据。比如jpg图片或者序列化对象
   2. 一个Redis中字符串value最多可以是512M
   3. Redis的每一个单命令都具有原子性，这是因为Redis是单线程
   4. set <key> <value> :添加键值对
   5. get <key> :取出key对应的值
   6. append <key> <value> :给key对应的v追加value
   7. strlen <key> :获得key对应值的长度
   8. setnx <key> <value> :只有在key不存在时，设置key的值为value
   9. incr <key>:将key中存储的数字值增1，只能对数字值操作，如果为空，新增值为1
   10. decr <key>:将key中存储的数字值减1，只能对数字值操作，如果为空，新增值为-1
   11. incrby / decrby <key> <步长>：将key中存储的数字值按照步长，增加或减小。
   12. mset <key1> <value1> <key2> <value2> ......;同时设置多个key--value对（more set）
   13. mget <key1> <key2> ...... 同时获取多个key对应的value
   14. msetnx <key1> <value1> <key2> <value2> :只有在所有的key1，key2都不存在时，设置key的值为value
   15. getrange <key> <startIndex> <endIndex>;相当于subString(stIndex,endIndex+1) 即[startIndex,endIndex]
   16. setrange <key> <startIndex> <value>:用value覆写[startIndex,;;]的值
       1. 
   17. setex <key><过期时间> <value>设置键值的同时，设置过期时间，单位秒（set expire）
   18. getset <key> <value>:先获取旧值，在设置新值
2. List
   1. Redis 列表是简单的字符串列表，按照插入顺序排序，可以头插法也可以尾插法
   2. List的数据结构是双向列表，对两端操作性能很高，通过索引操作中间节点的性能较差
   3. lpush/rpush <key> <value1> <value2>:从左(头)边或右(尾)边把值添加进list
   4. lpop/rpop <key> :从左边或右边吐出一个值。值在键在。值光键亡
   5. rpoplpush <key1> <key2>:从key1对应的list右边吐出一个值，然后从左边插入key2对应的list中
   6. lrange <key> <startIndex> <endIndex>（这里的l表示list）：获取元素【startIndex,endIndex】；
      1. 0表示表头，-1表示表位
      2. 
   7. lindex <key> <index> 获取key对应的list中索引为index的元素
   8. llen <key>  获取列表长度
   9. linsert <key> before|after <value> <newValue> 在value之前或之后插入一个新值,
   10. lrem <key> <n> <value> 删除n个value
       1. n>0:从左向右删除n个value
       2. n<0:从右向左删除n个value
       3. n=0:表示删除所有value
3. Set
   1. 去重无序，可以判断元素是否存在
   2. 底层是一个value值为null的hash表（map.put("key",null)）。所以添加，删除，查找的复杂度都为O(1)
   3. sadd <key> <value1> <value2> ... 将多个元素加入到集合
   4. smembers <key> 取出集合的所有值
   5. sismember <key> <value> 判断集合是否含有value ，没有返回0，有返回1
   6. scard <key> 返回集合元素个数
   7. srem <key> <value1> <value2> 删除集合元素
   8. spop <key> 从集合随机吐出一个元素
   9. srandmember <key> <n>从集合随机选出n个值，不删除元素 
   10. sinter <key1> <key2>求交集
   11. sunion <key1> <key2>求并集
   12. sdiff <key1> <key2> 求差集 。key1对应的表有，key2对应的表没有。
4. Hash
   1. 类似于Map<String, String>
   2. hset <key> <entry.key> <entry.value>:给key对应的hash表，存入一个entry
   3. hget <key> < entry.key >:取出entry.key对应的entry.value
   4. hmset <key> <entry.key1> <entry.value1> <entry.key2> <entry.value3>批量设置值
   5. hexists <key>  <entry.key1>:<entry.key1>是否存在
   6. hkeys <key> 列出key对应的hash表中所有的entry.key
   7. hvals <key> 列出key对应的hash表中所有的entry.value
   8. hgetall <key> 列出key对应的hash表中所有的entry
   9. hincrby <key> < entry.key > <increment> 即entry.value=entry.value+increment
   10. hsetnx  <key> <entry.key> <entry.value> 如果entry.key不存在，就增加entry
5. zset
   1. zset为每个成员都关联了一个评分(score)。这个评分被用来按照从低到高的方式排序集合中的成员，集合成员唯一，但是评分可以重复
   2. 因为元素有序，所以可以根据评分(score)或者位置(position)来获取一个范围的元素。访问有序集合的中间元素也是非常快的、
   3. zadd  <key> <entry.score1> <entry.value1>  <entry.score1> <entry.value1>:添加zset
      1. 分数不同元素相同，会替换掉zset中原元素的分数，并冲重新排序
      2. 分数相同元素不同，可以添加进去，并排序
   4. zrange <key> <startIndex> <endIndex> [WITHSCORES] :返下标[startIndex,endIndex]元素。如果WITHSCORE将连SCORE一起返回
   5. zrangebyscore <key> <min> <max> [withscore] [limit offset count] 返回scorez在【min,max】之间的元素(从 小到大排列)，limit表示从返回值的第offset个开始,取出count个，
   6. zrevrangebyscore <key> < max > < min > [withscore] [limit offset count]返回scorez在【min,max】之间的元素(从 大到小排列)，limit表示从返回值的第offset个开始,取出count个，
   7. zincrby <key> <increment> <value> 给value元素对应的score加increment
   8. zrem <key> <value> 删除元素value
   9. zcount <key> <min> <max> 统计分数值在【min,max】间的元素的个数
   10. zrank <key> <value> 返回value在集合中的排名(索引)

12.Redis配置文件

1. include
   1. 用于将公共配置提取出来，引入公共配置，编写自己的配置
2. IP地址绑定
   1. 默认只接受本机请求，需要设置以下参数
   2. #bind=127.0.0.1 
   3. protected-mode no
3. tcp-backlog
   1. 可以理解是一个请求到达后至到接受进程处理前的队列
   2. backlog队列综合=未完成三次握手队列 + 已经完成三次握手队列
   3. 高并发环境tcp-backlog的设置值由超时时限内的Redis吞吐量决定
4. timeout
   1. 一个空闲的客户端维持多少秒会关闭，0表示永不关闭
5. TCP keepalive
   1. 对访问客户端的一种心跳检测。每个n秒检测一次，官方推荐60秒
6. daemonize
   1. 是否后台开启
7. pidfile
   1. 每个实例会产生一个不同的pid文件。这里是存放pid文件的位置
8. log level
   1. 日志级别
9. logfile
   1. 日志文件名称
10. database
    1. 设定库的数量，默认16个
11. maxclient
    1. 最大客户端连接数
12. maxmemory
    1. 最大可用内存

13.java操作Redis

1. 导包
   1.       < dependency >

               < groupId >redis.clients </ groupId >

               < artifactId >jedis </ artifactId >

               < version >3.3.0 </ version >

            </ dependency >
2. 使用
   1.         Jedis client = new Jedis( "127.0.0.1",6379);

              client.select(1);

              System. out.println( client.ping());

              client.flushAll();

              client.set( "usr", "yahang");

              System. out.println( client.get( "usr"));

              client.close();

14.Redis事务

1. Redis事务是一个单独的隔离操作；事务中所有的命令都会按顺序的执行，不会被其他请求所打断
2. Redis事务的主要作用就是串联多个命令防止别的命令插队。就是说把事务中包含的所有命令，打包发给服务器，Redis服务器批量执行完指令，返回结果
3. muti,exec,discard
   1. 从输入Mutimuti开始，输入的命令都会依次进入命令队列中，但不会被执行，输入exec后，按顺序执行指令
   2. 可以通过discard来取消事务
   3. 
   4. 错误处理
      1. 报告错误: 在muti之后，exec之前，输入的命令有错误，则整个事务取消
      2. 运行时错误:exec之后，执行命令出错，其他命令照常执行，并不会回滚。
4. 关系型数据库一般是悲观锁，而Redis采用的是乐观锁
5. watch<key1> <key2> <key3> 在muti之前，可以使用watch监视某些键值，如果我在开启事务后，发现监视的键值对，被改动过。则取消事务
6. unwatch 取消监视，如果在unwatch执行之前，exec或discard命令被执行，则自动取消watch
7. 代码
   1.         Jedis client = new Jedis( "127.0.0.1",6379);

              Transaction tra = client.multi();

              tra.set( "a", "b");

              Response<String> result = tra.get( "a");

              tra.exec();

15.Redis持久化

1. Redis提供了两个不同的持久化方式
   1. RDB (Redis DataBase)：保存数据，节省磁盘空间，恢复快
   2. AOF (Append Of File)：保存执行的指令
2. 触发Redis持久化的方式
   1. 满足保存策略
   2. shutdown关闭server
   3. 手动输入命令save
3. RDB
   1. 在指定时间间隔内将内存中的数据集快照写入磁盘，恢复时直接将快照文件读到内存里。
   2. Redis会单独创建(fork 分叉) 一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好了的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能，如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加高效，RDB的缺点是最后一次持久化后的数据可能丢失(意思是如果redis非正常关闭，如kill pid。那么redis 不会持久化，导致之前的修改不会保存)
   3. RDB文件保存目录，在配置文件内
      1. dbfilename dump.rdb
      2. dir ./
   4. RDB保存策略，在配置文件内
      1. save <seconds> <changes> ;在多少秒内完成对数据库的多少次更改就会进行持久化
   5. 手动保存
      1. save:只管保存，其他对redis的请求一律阻塞。
   6. 其他配置
      1. stop-writes-on-bgsave-error yes ：当Redis无法写入磁盘时，直接关掉Redis的写操作
      2. rdbcompression yes :进行rdb保存时。将文件压缩
      3. rdbchecksum yes ：在存储快照时，使用CRC64算法进行数据校验，消耗性能。
   7. rdb的备份
      1. 先通过config get dir 查询rdb文件的目录
      2. 然后将*.rdb文件拷贝到别的地方
   8. rdb的恢复
      1. 关闭Redis
      2. 先把备份的文件拷贝到工作目录下
      3. 启动Redis, 备份数据会直接加载。
4. AOF
   1. 以日志的形式记录每个写操作，将Redis执行过的所有的写操作记录下来(读操作不记录)，只许追加文件但不可以改写文件，Redis启动之初会读取该文件重新构建数据。也就是说把指令从头到尾执行一遍。
   2. 默认不开启AOF，更改配置文件开启AOF
      1. appendonly yes
      2. appendfilename "appendonly.aof"
      3. dir ./
   3. AOF同步频率
      1. 始终同步：每次Redis的写入都会立刻记入日志
      2. 每秒同步: 每秒记入日志一次，如果down机，本秒的数据丢失
      3. 不主动同步，把同步时机交给操作系统
      4. 配置文件：appendfsync everysec
   4. Rewrite
      1. bgrewriteaof:重写aof中的指令集
      2. 如果一直写命令，aof会文件会过大，当超过阈值时，会重写aof。根据内存中的内容，自动重写命令。
      3. 重写aof文件，并没有读写旧的aof文件，而是根据内存中的内容，自动生成命令
   5. 何时重写
      1. 
5. 如果RDB和AOF同时开启，Redis应该按照加载那个数据文件呢
   1. 一切以AOF为准

16 .主从复制，读写分离

1. 什么时主从复制，读写分离
   1. 
   2. 主机数据更新后根据策略和配置，自动同步到备机。Master以写为主，Slaver以读为主
2. 配从服务器，不配主服务器
   • 拷贝多个redis.conf文件include
   • 开启daemonize yes
   • Pid文件名称pidfile
   • 指定端口port
   • Log文件名字
   • Dump.rdb名字dbfilename
   • appendonly关掉或者换名字
3. 示例
   1. 配置不同的conf文件
      1. include .\redis.windows.dafault.conf
      2. dbfilename 6379.rdb
      3. port 6379
   2. 开启三个redis-sever
      1. redis-server redis.windows.6379.conf;redis-server redis.windows.6380.conf;redis-server redis.windows.6381.conf
   3. info replication:查看当前服务器的主从关系角色
      1. 
   4. slaveof <ip> <port>:让本服务器成为某个服务器的备服务器
      1. 
      2. 通过命令配置的从服务器。一旦重启机器，这种主从关系就不存在了，因此需要在配置文件中保存主从关系。
         1. slaveof <masterip> <masterport> 部分版本为 replicaof <masterip> <masterport>
   5. 复制原理
      1. 
      2. 每次从机联通后，都会给主机发送sync同步信号
      3. 主机立刻进行存盘操作，发送RDB文件给从机
      4. 从机收到RDB文件后，进行全盘加载
      5. 之后之主机的每次写操作，都会立刻发送给从机，从机执行相同的操作
   6. 薪火相传
      1. 
      2. 上一个的slave可以成为下一个服务器的master，向链条一样
      3. 如果master宕机了，可以对下一个从服务器执行命令。 slaveof no one.下一个从服务器就会变成主服务器
      4. 风险：一旦中间的slave宕机了，后面的全凉了。
   7. 哨兵模式
      1. 
      2. 哨兵自动监听主机状态，一旦主机挂掉了，可以自动将从机提升为主机
      3. 配置哨兵
         1. 调整为一主二仆
         2. 新建sentinel.conf文件
         3. 在配置文件中填写内容
            1. sentinel moniter <randomName> <127.0.0.1> <6379> 1
            2. 其中randomName是为监控对象起的服务器的名字(随便写)，1表示:至少有多少个哨兵认为master宕机了，才算宕机。
         4. 启动哨兵
            1. redis-sentinel <*.conf>
      4. 故障恢复
         1. 
4. 问题
   1. 切入点问题，假设master已经存了部分数据，slaver才开始运行，slaver会复制master的内容吗
      1. 主从内容一定是一模一样的，所以会复制
   2. slaver是否可以写
      1. 从机只能读不能写，主机可以读可以写
   3. 主机down以后，slaver会上位还是原地待命
      1. slaver原地待命，info replication中主机状态显示down
   4. 主机down之后，又开机，新增了部分内容，请问slaver还会和主机一样吗
      1. 主从内容一定是一模一样的
   5. 从机down了以后，又开机，请问slaver还会和主机一样吗
      1. 主从内容一定是一模一样的

17.Redis集群

1. 什么是集群
   1. Redis集群实现了对Redis的水平扩容。即启动N个redis节点，对整个数据库分布存储在这N个节点中，每个节点存储数据的1/N
   2. Redis集群通过分区(Partition)来提供一定程度的可用性(availability):即集群中有一部分节点失效或者无法进行通信，集群也可以继续处理命令请求
2. 配置集群
   1. 安装ruby环境
   2. 配置redis cluster的配置文件
      1. 拷贝多个redis.conf文件include
      2. 开启daemonize yes
      3. Pid文件名称pidfile
      4. 指定端口port
      5. Log文件名字
      6. Dump.rdb名字dbfilename
      7. appendonly关掉或者换名字
      8. cluster-enabled yes 打开集群模式
      9. cluster-config-file nodes-6379.conf 设定节点配置文件名（运行redis-server，自动生成的文件的姓名）
      10. cluster-node-timeout 15000 设定节点失联时间，超过该时间(毫秒)，集群自动进行主从切换
   3. 按照上述配置制作6个redis-server实例
   4. 将6个节点合成一个集群
      1. 组合之前，请确保所有redis实例启动后，node-xxx.conf文件都生成正常
      2. ./redis-trib.rb create --replicas 1 192.168.44.130:6379 192.168.44.130:6379 ......
         1. 注意不要用127.0.0.1，使用真实ip地址
         2. --replicas 1表示每个master有一个slave
   5. 以集群的方式开启客户端
      1. redis-cli -c -p 6379  随便选个端口号进去就可以，集群自动进行重定向，选择对应的redis服务器
   6. cluster nodes 命令查看集群信息
   7. redis cluster如何组织这些服务器实例，组成一个集群呢
      1. 一个集群至少3个master
      2. --replicas 1 表示一个master跟随一个slave
      3. 分配原则尽量保证每个主数据库运行在不同的ip地址，每个从库和主库不在一个ip地址上
   8. 故障恢复
      1. 如果主节点下线，从节点能否自动升为主节点：可以
      2. 主节点恢复后，主从关系如何：原主节点变成从节点
      3. 如果某一段slot的主从节点全down掉，redis集群还能用吗
         1. redis.conf中的参数 cluster-require-full-converage yes 表示只有所有slot全部正常，集群才可以提供服务
   9. JedisCluster操作集群
      1.         //随便从集群的任意一个服务器进去，都可以操作集群

                 HostAndPort hap = new HostAndPort( "192.168.1.1", 6379); //

                 JedisCluster cluster = new JedisCluster( hap);

                 cluster.set( "a", "a");

                 cluster.close();