redis随笔

redis
    redis的安装一
        安装的准备
            首先得买一个服务器（我买的阿里云ecs轻量级）；
            再下载远程客户端（我用的Xshell，Xftp）;
            打开Xftp将下载好得redis压缩包传输Xftp中，在进入Xshell中Linux命令安装；
        rides安装
            下载地址：https://redis.io/
            安装：
                1，Linux进入redis所在目录；
                2,执行命令：tar -zxvf redis-3.2.10.tar.gz        //个人建议将软件安装在/usr/local目录下,执行命令：tar -zxvf redis-3.2.10.tar.gz -C /usr/local/redis，当然解压完了move也可以；
                3，进入解压后的目录进行编译，cd redis-3.2.10. 执行命令：make    ,make命令后可能报错，如果报错，解决如下：
                    报错一：那可能是没有gcc (linux下的一个编译器，是c,c++程序的编译器)
                        使用命令yum进行安装，yum -y install gcc
                    报错二：error：jemalloc/jemalloc.h:No such file or disectoty    //可能找不到c语言中的头文件
                        执行 make MALLOC = libc
                4，安装完gcc之后，make distclean 清理下上次make后产生的文件，再make

            redis启动：
                方式一：前端启动模式，前端模式启动的缺点是ssh命令窗口关闭则redis-server程序结束，而且当前命令窗口处于一种阻塞状态，想要执行其它命令需要重新开启一个新命令窗口
                    执行命令：cd /usr/local/redis/redis-3.2.10/bin
                    再执行命令：./redis-server
                    //ps -f | grep redis     查看进程        kill pid(进程号)        杀掉进程
            
                方式二：后台启动模式，./redis-server &        //建议后台启动
                             后台启动并输出日志到 nohup.out 文件：nohup /usr/local/redis-3.2.10/class="lazy" data-src/-server &
                             再回车确定
                             ls查看文件会发现出现一个nohup.out文件
                             cat nohup.out   就会将日志打在此文件中
            redis关闭：./redis -cli shutdown
    
    redis的安装二
        https://www.jb51.net/article/146751.htm

    redis客户端
        redis命令行客户端：redis -cli （./redis -cli -h 127.0.0.1 -p 6379）    //redis自带基于命令行得redis客户端

        Redis Desktop Manager(远程客户端):                //要下载
            远程连接redis需要修改redis主目录下的redis.conf配置文件：
                1，bind ip 绑定ip注释掉
                2，protected-mode yes 保护模式改为no；
            可以进入目录配置文件改，也可以命令改，命令如下：
                进入目录：cd /usr /local /redis-3.2.10 /
                进入文件：vim redis.conf  回车确定
                注释bind ip；protected-mode yes 保护模式改为no；回车确定
                ps -ef | grep redis    //查看进程
                kill  pid        //杀掉当前进程再重启
                nohup /usr/local/redis-3.2.10/class="lazy" data-src/redis - server  /usr/local/redis-3.2.10/redis.conf &        //重启进程并打出日志文件
            进入下载好的远程客户端：
                Connection 连接自己的远程服务器地址；        //这里一定要填自己的远程ip，不能填本地
                ok

        phpRedisAdmin(远程客户端)：
            需要安装php运行环境
            php开发自行下载xampp

        redis编程客户端：
            redis的Java客户端：
                jedis：
                    jedis源码：https://github.com/xetorhio/jedis
                    api文档：http://xetorthio.geihub.io/jedis/

    redis的使用
        基础命令：
            1， ./redis -cli    //启动
                输入ping,redis会返回PONG表示服务运行正常
            2，redis默认16个库，但是可以再redis.conf中修改。        //可进文件改，也可命令改
                进入文件：vim redis.conf  回车确定
                找到databases 16                //可改
            3，redis默认使用0号库，select db                //切换库    例：select 2
            4，删除
                删除所有库数据 ： flushall
                删除当前库数据 ： flushdb
            5，获取redis的所有配置 ：config get *
            6，退出连接：exit / quit
            7，查看当前数据库中key的数目：dbsize
            8，查看redis服务器的统计信息：info

        命令与使用文档：
            命令：
                key命令
                字符串类型 ：string
                哈希类型 ：hash
                列表类型 ：list
                集合类型 ：set
                有序集合类型 ：zset（sorted set）
            文档：
                中文：https://redis.io/commands
                英文：https://redisdoc.com/
        redis常用命令 ：
            keys *                //列出所有key
            exists key              //检查某个key是否存在
            set key value            //存入key值    例：set k1  v1
            move key db             //将当前的key移动到给定的库db中，例：move k1 2
            expire key seconds            //设置key值过期时间        例：expire k1 8
            ttl key (time to live)            //查看是否过期，-1永不过期，-2 已过期或key不存在
            type key                //查看key所存储值得类型
            del key                //删除key
        redis更多使用方法请移步菜鸟教程：https://www.runoob.com/redis/redis-install.html

        redis5中数据类型命令
            字符串类型 String（可以存储任何形式的字符串）
                set key value            将字符串值value设置到key中
                get key                获取key中的value
                incr key                将key中存储的数字加一，若key不存在，key得值先被初始化为0，再执行incr操作（只对存储的数字有用）
                decr key                将key中存储的数字减一，若key不存在，key得值先被初始化为0，再执行incr操作（只对存储的数字有用）
                setex key seconds value        设置key值及过期时间（set expire）
                setnx key value            给无值或者不存在的key给值，有值则不设置值
                getset key value            给key设置新值并返回旧值
                strlen key                返回key所存储字符串长度
                append key value            若key存在且为字符串，则追加（跟jquery一样）；key不存在将追加的设为新值
                incrby key increment            将key所存储的值加上增质量（自定义量），若key不存在，则key的值初始化为0，再执行incrby
                decrby key increment        将key所存储的值减去增质量（自定义量），若key不存在，则key的值初始化为0，再执行incrby
                getrange key start end        截取key中字符串值，从star开始，end结束（类似subString）
                setrang key offset value        从字符串指定位置替换value，例：k1值为helloworld，执行setrang k1  5(第五个位置) redis  则输出：helloredis
                mset key1 value key2 value2 ...        同时设置多个key-value
                mget key1 key2 keyn ...        同时获取多个key-value
                msetnx key1 value key2 value2 ...    同时设置多个key-value，当且仅当所有给定key都不存在时才能设置成功，有一个key存在值都不行

            哈希类型hash（String类型的映射，适合存储对象）
                hset key field value            将哈希表key中的域field的值设置为value    例：hset k1 id 1001
                hget key field            取值        例：hget k1 id
                hmset key1 field value ...        同时设置多个值    例：hmset k2 id 1002 name likauhua age 10 pwd 123 ...
                hmget key field ...            同时取多个值    例：hmget k2 id name age
                hgetall key            查询哈希表key里所有值
                hdel key                删除哈希表key中一个或多个指定值field
                hkeys key                查看哈希表key中所有field域（查询所有字段）
                hvals key                查看哈希表key中所有域的值（字段所对应的值）
                type key                查案key存储的数据类型
                hlen key                查看哈希表key中域field的个数（字段个数）
                hexists key            查看哈希表key中，给定域field是否存在（字段是否存在还）例：hexists k1 id
                hincrby key field increment        为哈希表key中的域的值加上增量        例：hincrby k1 id 5
                hincrbyfloat key field increment    为哈希表key中的域的值加浮点数上增量    
                hsetnx key field value        将哈希表key中的域field的值设为value，当且仅当field不存在时才设置，否则不设置    例：hsetnx k1 age(这个字段不存在时才能设置)  18

            列表类型list（简单的字符串列表，按照插入排序，元素可重复）
                lpush key value1 value2 value3        将一个或多个值value插入到列表key的表头（最左边）    例：lpush k1 1 2 3 4 5
                rpush key    value1 value2 value3        将一个或多个值value插入到列表key的表尾（最右边）    例：lpush k1 7 8 9 10 11
                lrange key start stop            获取表key中指定区间内元素，0为第一元素，-1为倒数第一元素。 例：lrange key 0 -1    (区间所有元素)
                lpop key                从左边获取列表key的第一个元素，并将该元素移除
                rpop key                从右边获取列表key的第一个元素，并将该元素移除
                lindex key index            获取列表key中下标为指定index元素    例：lindex key 3
                llen key                获取列表key的长度
                lrem key count value            从左至右删除列表中指定个数与指定value值相等的value    例：lrem k1 1 4    4这个元素被删除了
                 ltrim key start stop            删除指定区域外的元素
                rpoplpush source destination        将列表source中的尾元素插入到列表destination中，作为头元素    例：rpoplpush k1 k2    （将本列表尾元素放另一个列表当头元素）
                lset key index value            将列表key下标为index的元素设为value    例：lset k1 0 222（将0下标下的元素替换成22）
                linsert key before|after pivot value    将值插入到指定值之前或之后    例：linsert k1 before  5 100（将k1域内值5前插入100，元素非下标）


            集合类型 set（redis的Set时String类型的无序集合，成员唯一，集合中不重复）
                sadd key member member ...        将一个或多个member元素加入集合key中，已存在集合的member元素不加入      例：sadd k1 1 2 3 4
                smembers key             获取聚合key中所有元素
                sismember key member        判断member是否是集合key的成员    例：sismember k1  1
                scard  key                获取聚合中元素个数
                srem key member            删除聚合中一个或多个元素（指定删除某个元素）    例：srem k1 2
                srandmemner key [count]        随机返回集合中一个或多个元素  count 是返回的个数            
                spop key                随机删除集合中的一个元素
                smove source destination member    将member元素从一个集合移到另一个集合    例：smove k1 k2 2（将元素2从k1 移到k2）

            有序聚合zset（sorted set）:跟set差不多，不同的是zset得每个元素都会关联一个分数（分数可重复），redis通过分数来为集合中的成员进行排序
                zadd key score member        将一个或多个member元素及其score值加入到有序集合        例：zadd k1 100 likaihua 90 likaihua2
                zrange key start stop        获取有序集合key中，指定区间的成员，按score大小排序    例：zrange k1 0 -1
                zrevrange key start stop        获取有序集合key中，指定区间的成员，按score小大排序    例：zrange k1 0 -1
                zrem key member            删除有序集合key中得一个或多个成员        例：zrem k1 likaihua
                zcard key                获取集合个数
                zrank key member            获取有序集合key中，成员member排名，有序集成员按score值从小到大排列    例：zrank k1 likaihua
                zrevrank key member        获取有序集合key中，成员member排名，有序集成员按score值从大到小排列
                zrangebyscore key start stop        获取有序集合key中，所有score值介于min和max之间的成员    例：zrange k1 100 90
                zrevrangebyscore key start stop    获取有序集合key中，所有score值介于max和min之间的成员
                zcount key min max            获取有序集合key中，所有score值介于min和max之间的成员个数    例：zcount k1 10 100
                score（分数）    
                
            Table键        补全命令
            官方命令文档：redisdoc.com
        

    redis的发布和订阅
        发布订阅：redis发布订阅（pub/sub）是一种消息通信模式；也称为生产者模式，实现消息队列的一种方式
        消息队列三要素：1，生产者（producer）2，消费者（consumer）3，消息服务（broker）
        三者关系：1 (producer)——>3 (redis在次充当consumer)——>2（consumer）
        一个消息发布者，多个消息订阅者
        
        命令实现：1，开启4个redis客户端，三个作为消息订阅者，一个作为消息发布者：./redis-cli
            2，消息订阅者：subscribe channel
                // 如果是订阅匹配模式：psubscribe chan *    表示匹配以chan开头的频道主题都能拿到
            3，消息发布者：publish channel message    
                //就跟扶贫一样，国家把钱给政府干部，干部（干部===消息发布者）发钱，带有精准扶贫这个标识人就可以凭此去拿钱（贫困户==消息订阅者）

        jedis编程实现：
            订阅者：
                public void onMessage(String channel, String message){        //封装的回调函数
                    System.out.println("频道"+channel+"发布了消息"+message);
                }

                public static void main (String [ ] arg){
                    Jedis jedis = new Jedis ("192.168.0.1" ,6379);    //连接redis
                    Sub sub = new Sub（）;            //创建订阅者对象
                    jedis.subscribe(sub, "channel");
                }
            发布者：
                public static void main (String [ ] arg){
                    Jedis jedis = new Jedis ("192.168.0.1" ,6379);    //连接redis
                    jedis.publish("channel", "hello world");        //发布消息
                    jedis.close（）;                
                }

        redis事务（redis中的事务是一组命令集合，至少两条以上命令，redis事务保证这些命令被执行时不会被其他操作打断）
            正常流程：1，MULTI：该命令告诉redis接下来的命令暂不执行，将其暂存（开启事务）
                2，SADD "user1" 第一天命令进入等待队列
                3，SADD "user2"第二条命令进入等待队列
                4，EXEC 告知redis执行暂存的命令（提交事务）    //放弃事务：DISCARD，不执行，事务放弃
                    
                    //就跟坐客车（事务 == 大客车）一样，单个不走，包车不准。等人多了，包圆儿了一块走。
                命令示例：
                    MULTI
                    set  k2(key)  v2(value)
                    set  k3(key)  v3(value)
                    EXEC
                也存在异常和例外情况：1，语法错误，事务回滚不执行
                            2，语法正常，逻辑错误，例如incr给一个字符加1，或者不给值，能够入队，但提交事务后会显示该语句存在错误
                
            
            锁：
                悲观锁：当有人读取数据时会被认为要更改数据，因此每次在读取数据时会先上锁，直到这个线程拿到锁为止。（本线程结束后其他线程才能进来读取数据。就跟上厕所似的，进去先锁门，自己拉完了别人才能进来拉）
                
                乐观锁：当有人读取数据时不会被认为更改数据，不上锁。但在更新时会判断在此期间是否有人更改数据，一般用版本号机制进行判断。

                    悲观锁的判断机制：大多数基于数据版本号机制实现。版本号？：即为数据增加一个版本标识。
                                     一般通过为数据库表添加“version”字段来实现读取数据时，也将此版本一同读出。之后来读取数据的人提交数据更新时，会对此版本号加1。
                                     此时提交数据的版本号与数据库表对应记录的当前版本号对比，若提交数据版本号大于数据库表当前版本号，则准予更新（数据库当前版本号只会更新一次）
                    
                        示例：
                            1，A操作员将用户数据读取（version=1），进行修改操作。
                            2，B操作员将用户数据读取（version=1），进行修改操作。
                            3，A完成操作，提交数据时（version +1 =2）,提交更新。此时提交数据版本号大于数据库记录的当前版本号，准许提交。
                            4，B完成操作，提交数据时（version +1 =2）,提交更新。但是此时的数据库记录的版本号已经被A提交数据后更新为2了，所以B提交的版本号不大于数据库记录的当前版本号，则不准予提交数据更新。
                            因为数据库记录的版本号只更新一次，谁快先更新了，版本号就变了，必须等上一个线程完成后再进去操作。（就争媳妇似的的，谁下手快生了娃，谁就稳了）

                    redis的watch机制实现乐观锁（监视一个或多个key，如果在事务exec执行之前这个key被其他命令更改，那么该事务将会被打断）
                        命令如下：
                            set k1 1                //设k1为1
                            watch k1                //监视k1
                            set k1 2                //k1值在被监视时被更改为2，另外人开客户端更改也一样
                            multi                //开始事务
                            set k1 3                //将k1值改为3
                            exec                //提交事务
                            输出null，事务被放弃。检测到k1也被更改为2，不再是1了。
                            （就像本来你跟你女朋友快要结婚了，但是结婚前一天在你爸妈的眼皮子底下决定跟别人私奔，你爹妈知道了不想让你背锅，在你们结婚时强行拆散，唉，真惨。）
                            
        redis的持久化机制
            持久化概述：持久化==存储，就一直存着可以。
            redis持久化：redis数据存储在内存中，内存是瞬时的，如果发生宕机或者系列糟糕情况，内存会丢失。redis提供两者持久化机制
                
                //就跟男人一样，要持久，持之以恒，坚定不移。

            RDB方式：在指定的时间间隔内将内存中的数据快照写入磁盘，数据恢复时将快照文件直接再读到内存
                   步骤：在redis.conf文件中配置
                配置格式：save
                    save 900 1                //900秒内一次数据更改会保存一次
                    save 3000 10
                    save 6000 20

                配置文件redis.conf中搜索SNAPSHTTING：dbfilename：设置RDB文件名。默认文件名为dump.rdb        //就是可以修改保存文件的名字
                                dir：指定RDB和AOF的文件目录                //修改保存文件的指定目录
                    //修改redis.conf文件后要重启一下redis

            AOF方式：redis每收到一条修改命令时，它将命令写道一个AOF文件中（不记录读命令），当redis重启时，再通过AOF中的所有命令在恢复
                   步骤：rdis.conf文件中搜索APPEND ONLY MODE
                       1，将append only改为yes,默认no;

                  AOF相关设置： 1，appengfilename:AOF文件名，可改，默认：appendonly.aof        
                        ////查看aop文件存储的命令：1，ll *.aop；2，cat  appendonly .aof
                              2，appendfsync:配置向aof文件写命令数据策略：
                                1，append fsync always        每次执行写入都会执行同步，慢且安全
                                2，append fsync  everysec        每秒执行一次同步操作
                                3，append fsync  no            不主动进行同步操作，交给系统来做，30秒一次，快但不且不安全

                             3，auto-aof-rewrite-percentage（例如：100）：设置当目前aof文件大小超过上一次重写时aof文件大小的百分之多少时，将再次进行重写；若之前未进行重写，则以启动时最小aof文件大小为依据；
                        //进行文件优化，例：set k1 1 后再执行 set k1 2，那么set k1 1则不被记录，只记录有用的命令
                             4，auto-aof-rewtite-min-size（例如：64mb）：设置允许重写的最小aof文件大小
        总结：可以同时使用两种方式，默认优先加载aof



    redis集群
           主从复制
        主从复制（master/slave）：
            简介：redis做集群，为保证单点故障，就将数据复制多芬岛多台不同服务器，即使其中一台出现故障，其他服务仍可运行。
            实现：部署多台redis，并在配置文件中指定之间的主从关系。主负责写，同时将写入数据实时同步到从机器，即主从复制。master/slave，redis默认master用于写，slave用于读。

        配置方式一：修改配置文件，启动时，服务器读取配置文件，自动成为指定服务器的从服务器，构成主从复制关系。
            主服务器（master）
                include /usr/local/redis-5.0.3/redis.conf
                daemonize yes
                port 6380
                pidfile /var/run/redis6380.pid
                logtile 6380.log
                dbfilename dump6380.rdb

            从服务器（slave）
                include /usr/local/redis-5.0.3/redis.conf
                daemonize yes
                port 6381
                pidfile /var/run/redis6380.pid
                logtile 6381.log
                dbfilename dump6381.rdb
                slaveof 127.0.0.1 6380

        示例：（由于只有一台服务器，因此在一个redis中启三个实例，一个master两个slave）方便观看就开4个客户端窗口。
            以下为客户端窗口 1。
            bin目录下
            cp redis.conf redis6380.conf        //复制原来redis6379.conf配置文件，并生成新的redis6380.conf配置文件
            ll                //出现redis6380.conf文件
            >redis6380.conf            //滞空redis6380.conf文件
            vim redis6380.conf            //进入redis6380.conf文件，添加主服务的配置
                  配置master    
                include /usr/local/redis-5.0.3/redis.conf
                daemonize yes
                port 6380
                pidfile /var/run/redis6380.pid
                logtile 6380.log
                dbfilename dump6380.rdb
                :wq                        //如果无法保存退出，就按下esc键再，:wq a.txt

            配置从slave
                cp redis6380.conf redis6381.conf            //复制redis6380.conf文件
                vim redis6381.conf                    //进配置文件配置从
                    include /usr/local/redis-5.0.3/redis.conf
                    daemonize yes                //表示后台启动
                    port 6380
                    pidfile /var/run/redis6380.pid
                    logtile 6380.log
                    dbfilename dump6380.rdb
                    slaveof 127.0.0.1 6380            //设置是6380的从服务器
                    :wq                    //如果无法保存退出，就按下esc键再，:wq a.txt

                cp redis6380.conf redis6382.conf            //复制redis6380.conf文件
                vim redis6381.conf                    //进配置文件配置从
                    include /usr/local/redis-5.0.3/redis.conf
                    daemonize yes
                    port 6380
                    pidfile /var/run/redis6380.pid
                    logtile 6380.log
                    dbfilename dump6380.rdb
                    slaveof 127.0.0.1 6380            //设置是6380的从服务器
                    :wq                        //如果无法保存退出，就按下esc键再，:wq a.txt
            
            客户端窗口2
            ./redis-server ../redis6380.conf            //后台启动master        
            ./redis-server ../redis6381.conf            //后台启动slave
            ./redis-server ../redis6382.conf            //后台启动slave
            ps -ef | grep redis                //查看这三个进程是否启动
            如果已经有三个进程的了，也可以检查各个端口所处角色
            ./redis -cli -p 6380                //开启6381客户端
            info replication                //插看服务器角色命令
                查看的信息：
                role:master（主）            //角色master
                connected_slaves:2            //两个从，端口号分别为
                slave0:port:6381            
                slave1:port:6382
        
                客户端窗口3
            ./redis -cli -p 6381                //开启6381客户端
            info replication                //插看服务器角色命令
            查看的信息：
                role:slave（从）            //角色slave
                master_host:127.0.0.1        //主是本地的
                master_port:6380            //端口号为6380            
                master_link_status:up        //开启状态

               客户端窗口4
            ./redis -cli -p 6382                //开启6381客户端
            info replication                //插看服务器角色命令
            查看信息与3一样

        配置完成可测试
            1，回到master所在客户端窗口
                set k1 v1
                set k2 v2                //设置两个值，在从服务器去取，看是否能读取值
            
            2，回到任意一个slave所在客户端窗口
                get k1
                get k2
            3，看能否读到值，读到即配置成功
                get k3                //读master为设置的值看是否能读到
                输出null，未读到；
            
            4，回到master所在客户端窗口
                set k3 v3                //设置k3，再去slave读，看是否能读取

            5，回到任意一个slave所在客户端窗口
                get k3
            输出：v3                    //读取成功
        主从关系配置完成

    如果现在出现问题了，master服务器宕机了，关闭了，主没了，只有从了，怎么办？
        引入新的处理方式
            容灾处理（冷处理）：当master服务出现故障后，需要手动将slave中的一个提升为master，将剩下的slave重新挂至新的master上；
                  命令如下：
                slaveof no one :将一台slave服务器提升为master
                slaveof 127.0.0.1 6381(新提上slave端口号)：将slave挂至新的master上

        操作示例：
            1，在master所在服务器客户端
                shutdown                //关闭master，模拟master出故障
                ps -ef | grep redis            //查看redis6380.conf进程是否被关闭

            2，在任意一个slave所在服务器客户端
                slaveof no one             //提升为主
                info replication            //查看所处角色即从服务
                显示信息
                    role:master        //角色为主
                    connected_slaves:0        //没有从服务器

            3，在另外slave中的任意一个slave所在服务器客户端
                slaveof 127.0.0.1 6381        //将本slave挂至新的master上去
                info replication            //查看角色及主服务
                显示信息
                    role:slave
                    master_host:127.0.0.1
                    master_port:6381        //挂在了新的master上了

            4，假如现在原来的master6380服务器修好
                ./redis-server  ../redis6380.conf        //后台启动
                ps -ef | grep redis            //查看进程是否被启动
                ./redis-cli -p 6380            //进入redis
                info replication            //查看角色
                显示信息
                    role:master        //角色为master
                    connected_slaves:0        //slaves为0
                原来master重启后，默认角色为master现在将它挂至新的6381master上去

                slaveof 127.0.0.1 6381        //将本slave挂至新的master上去

            总结：
                1，使用到的相关命令：
                    ./redis-cli -p 6380        进入指定客户端端口
                    info replication        查看redis服务器所处角色
                    如果不配置启动，默认为master
                2，master下线，写请求无法执行；slave下线，读请求处理性能下降
                3，master故障，需要手动提升一个slave为master。其他的slave要重新挂至新的master上去
                4，主从复制模式的故障转移需要手动操作，需要实现自动化处理，就再次引入Sentine哨兵，实现故障自动转移


        哨兵模式（热处理）
        作用：Sentine哨兵可以来监控多个redis服务实例运行情况
        Sentinel配置：
            1，复制三份文件：sentinel26380.conf，sentinel26381.conf，sentinel26382.conf；
            2，修改每个配置文件
                port 26380；port 26381；port 26382；
                sentinel monitor mymaster 127.0.0.1 6380 2
                Sentinel会根据master的配置自动发现master和slave，Sentinel默认端口是26379
            3，启动三个实例
                 ./redis-sentinel  ../sentinel26380.conf
                 ./redis-sentinel  ../sentinel26380.conf
                 ./redis-sentinel  ../sentinel26380.conf    
                启动三个实例后，会创建三个监视master服务的Sentinel实例
            4，哨兵模式已启动；    

        操作示例：
               redis6379客户端窗口
            1， cd usr/local/redis-5.0.3/bin            //进入bin文件夹
            2，ll                    //会看到一个
                //    redis-sentinel            哨兵可执行文件，读取配置文件，站岗
                //    sentinel.conf            哨兵配置文件
              3，复制三个sentinel.conf配置文件
                cp  sentinel.conf  sentinel26380.conf        //复制sentinel26379配置文件生成新的sentinel26380文件
            cp  sentinel.conf  sentinel26381.conf
            cp  sentinel.conf  sentinel26382.conf

               4，逐个修改sentinel.conf文件
            vim  sentinel26380.conf
                port 26380 (进哪个端口改那个)
                sentinel  monitor  mymaster  127.0.0.1   6381  2
                    //  2  投票数：这个投票数就是哨兵的投票数。检测master的这个哨兵发现这个master挂了，但它不能直接确定，
                    //会让其他的哨兵也来检测这个master，认为挂了的哨兵就投一票，等票数过半了，就确定真挂了。
                ：wq    //保存退出
            
            vim  sentinel26381.conf
                port 26381 (进哪个端口改那个)
                sentinel  monitor  mymaster(可修改文件名)  127.0.0.1   6381（主服务端口号，上面新提升的slave） 2（投票数）
                ：wq    //保存退出

            vim  sentinel26382.conf
                port 26382 (进哪个端口改那个)
                sentinel  monitor  mymaster(可修改文件名)  127.0.0.1   6381（主服务端口号，上面新提升的slave） 2（投票数）
                ：wq    //保存退出

                    

                5，ls                        //查看文件会看到三个sentinel.conf文件
                     ./redis-sentinel  ../sentinel26380.conf        //启动文件

                6，在新建两个客户端窗口方便启动，1窗口，2，窗口
            1窗口
            ./redis-sentinel ../sentinel26381.conf
            2窗口
            ./redis-sentinel ../sentinel26382.conf

                7，回到之前的master客户端窗口，关闭master，演示故障转移
            shutdown
            ps -ef | gerp redis            //查看进程，redis6381是否被关闭

               8，看1，2窗口，是否打印的日志信息
            ...
            # + failover-end master mymaster 127.0.0.1 6381                //6381进程end
            # + switch-master mymaster 127.0.0.1 6381  127.0.0.1 6380            //master6381替换成6380

               9，回到6380客户端窗口查看角色
            info replication
            信息显示
                role：slave            //角色slave
                master-port：6380            //它的master是6380
            
               10，回到6381（被停掉的master服务器），重启服务看看
            ./redis-server  ../redis6381.conf            //重启服务
            ./redis -cli -p 6381                //进入redis客户端
            info replication
            显示信息
                role：slave            //角色slave
                master-port：6380            //它的master是6380
               示例完成；

        总结：哨兵模式你补了容灾处理需要手动处理的缺陷。哨兵监控master主服务，当它发现master挂了的时候会自动进行古故障转移。
                  自动将其中的slave与挂了的master进行角色交换，而后就算挂了的master服务重启后也不再是master，而是自动修改成新master服务的slave服务。
        
        

    redis相关安全
        redis设置密码：redis.conf文件配置中 requirepass    123456
            操作示例：
                cd usr/local/redis-5.0.3
                vim redis.conf            //进入配置修改
                找到requirepass去掉注释，后面加上密码    123456
                ：wq
                kill 6379                //杀掉进程重启
                ./redis-server ../redis.conf &        //启动后台
                ./redis -cli -p 6379            //启动6379客户端
                AUTH 123456
            在jedis连接客户端时也要密码
                jedis.auth("123456");

        绑定ip：#bin 127.0.0.1 去点注释，127.0.0.1换成你允许连接的ip.表示只允许这个ip进行访问；

        命令禁止和重命名（也是在redis.conf配置中进行）：
            rename-command FLUSHALL  del    重命名flushall命令为del
                注意：这里重命名前提是appendonly.aof文件中没有flushall命令，否则服务器无法启动
                //因为redis.conf配置里改名了，appendonly.aof文件中还存在flushall命令，那会冲突，无法识别del新命令
            
            rename-command FLUSHALL  ""    禁用flushall    //flushall      清空本库所有信息
            rename-command FLUSHDB  ""    禁用flushdb    //flushdb        清空所有库所有信息
            rename-command CONFIG   JIJJMKXW        重命名config命令
            rename-command CONFIG   ""            禁用config命令        //config查看所有配置   config get *


        redis特点：
            简单稳定；支持丰富的内存结构；读写速度快；有持久化支持；支持部分事务操作；

    总结：纸上得来尚觉浅，绝知此事要躬行；

    set k1 "加油！"
https://www.bilibili.com/video/BV1Q4411N7u4/?p=28