Redis【第二篇总结】

一、Nosql与Redis概述

1、Nosql的优势

（1）使用nosql解决cpu与内存压力

（2）使用nosql解决I/O压力

2、Nosql数据库的概述

（1）NoSql= Not Only SQL

（2）采用key-value模式存储

（3）不遵循SQL标准

（4）性能远超过SQL

3、使用场景

（1）数据的高并发读写

（2）海量数据读写

（3）数据可扩展性

4、不适用场景

（1）需要事务的支持

（2）基于sql的结构化查询存储，需要即席查询

5、 Redis概述

（1）开源的key-value系统

（2）支持String、List、Set、zset、hash等数据类型

（3）数据库支持push/pop/add/remove操作

（3）支持不同方式的排序

（4）可写入内存也可以持久化

（5）主从同步功能

二、Redis6安装与使用

1、官网下载：放入liunx对应目录内

https://redis.io/

2、安装gcc编译环境

yum install centos-release-scl scl-utils-build

yum install -y devtoolset-8-toolchain

scl enable devtoolset-8 bash

测试gcc版本

gcc -version

3、解压缩：

tar zxvf redis-6.2.4.tar.gz

4、进入redis-6.2.4目录执行make命令

5、执行安装make install

6、验证安装成

cd /usr/local/bin

ll

7、相关软件介绍：

（1）redis-benchmar：性能测试工具

（2）redis-check-aof：修改有问题的AOF

（3）redis-check-rdb：修改有问题的rdb文件

（4）redis-sentinel：Redis的集群使用

（5）redis-server：Redis服务器集群使用

（6）redis-cli：客户端，操作入口

8、前台启动（不推荐）

9、后台启动

（1） 复制配置文件

cp -r redis.conf /opt/

（2）修改参数配置，将daemonize no改为daemonize yes，让服务支持在后台启动

[root@localhost redis-6.2.4]# cd /opt/
[root@localhost opt]# vi redis.conf 

（3）启动redis

[root@localhost bin]# cd /usr/local/bin/
[root@localhost bin]# redis-server /opt/redis.conf 
[root@localhost bin]# ps -ef|grep redis

（4）使用redis-cli测试

10、redis关闭

（1）redis-cli shutdown（进入终端shutdown也可以）

（2）kill -9 xxx（进程）

三、常用五大数据类型

3.1、Redis key操作

（1）查看所有key：keys *

127.0.0.1:6379> keys *
(empty array)

（2）添加 key value：set

127.0.0.1:6379> set k1 lucy
OK
127.0.0.1:6379> set k2 mary
OK
127.0.0.1:6379> set k3 jack
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"

（3）判断key是否存在 exists

127.0.0.1:6379> exists k1
(integer) 1
127.0.0.1:6379> exists k4
(integer) 0

（4）查看key的类型：type

127.0.0.1:6379> type k1
string

（5）删除key数据：del

127.0.0.1:6379> del k1
(integer) 1

（6）选择非阻塞删除：unlink（异步删除）

127.0.0.1:6379> unlink k2
(integer) 1

（7）设置key的过期时间（秒）：expire

127.0.0.1:6379> expire k3 10
(integer) 1

（9）查看ttl过期时间（秒）：ttl（-1永久不过期，-2已经过期）

127.0.0.1:6379> ttl k3
(integer) -2

（10）切换数据库：select

127.0.0.1:6379[1]> select 0
OK

（11）查看当前数据库的key数量：dbsize

127.0.0.1:6379> dbsize
(integer) 1

（12）清空当前库内数据（慎用）

127.0.0.1:6379> flushdb
OK

（13）通杀所有库内数据（慎用）

127.0.0.1:6379> flushall
OK

3.2、Redis字符串（String）

（1）简介：字符串，一个key对应一个value，是二进制安全的，是Redis最基本数据类型，value最多512M，底层为动态字符串，ArrayList

（2）设置值，相同key值覆盖：set

set k1 v100

（3）获取值：get

get k1

（4）追加值：append，返回总长度

append k1 abcd

（5）获取值的长度：strlen

strlen k1

（6）当key存在时操作：setnx，设置成功返回1，设置失败返回0

setnx k1 v1

（7）将数字类型值+1/-1：incr/decr，原子性操作，不受多线程机制打断。

incr k3
decr k3

（8）将key存储的数字值递增x/递减x：incrby/decrby

incrby k3 10
decrby k3 5

msetnx k11 v11 k12 v12 k13 v13
msetnx k1 v11 k4 v4

（9）同时设置一个或多个key-value键值对：mset

mset k1 v1 k2 v2 k3 v3

（10）同时获取一个或多个value：mget

mget k1 k2 k3

（11）设置多个key-value（当key都不存在时设置成功）：msetnx

127.0.0.1:6379> msetnx k11 v11 k12 v12 k13 v13
(integer) 1
127.0.0.1:6379> msetnx k1 v11 k4 v4
(integer) 0

（12）获取范围的值（开始-结束）：getrange

127.0.0.1:6379> getrange name 0 3
"luck"

（13）设置范围的值（开始位置-覆盖）：setrange，返回总长度

127.0.0.1:6379> setrange name 3 abc
(integer) 8

（14）设置key的同时设置过期时间：setex

127.0.0.1:6379> setex age 20 value30
OK

（15）以新值换旧值（显示旧值）：getset

127.0.0.1:6379> getset name jack
"lucabcry"

3.3、Redis列表（List）

（1）简介：单键多值的字符串列表，可以按照插入顺序排序，底层为双向链表（zipList（数据少时）->quickList（数据多时））

（2）从左边/右边插入一个或多个值：lpush/rpush，返回数组长度

127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> rpush k1 v7 v8 v9
(integer) 6

（3）按照索引下标（范围）获取元素，从左到右（0表示左边第一个，-1表示右边第一个）：lrange

127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "v7"
5) "v8"
6) "v9"

（4）从左边或右边取出一个值：lpop/rpop

127.0.0.1:6379> lpop k1
"v3"
127.0.0.1:6379> rpop k1
"v9"

（5）从k1列表右边吐出一个值，插入到v2列表的左边：rpoplpush

127.0.0.1:6379> rpoplpush k1 k2
"v1"

（6）按照索引下标（单值）获取元素（从左到右）：lindex

127.0.0.1:6379> lindex k2 0
"v1"

（7）获取列表的长度：llen

llen k1

（8）在key对应的value前面/后面插入new value：linset before/after

127.0.0.1:6379> linsert k1 before "v3" "v31"
(integer) 3
127.0.0.1:6379> linsert k1 after "v2" "v21"
(integer) 4

（9）从左边删除n个对应的value：lrem

127.0.0.1:6379> lrem k1 2 "new11"
(integer) 2

（10）将列表key下标为index的值替换成value：lset

127.0.0.1:6379> lset k1 1 "new31"
OK

3.4、Redis集合（Set）

（1）Redis Set是String类型的无序集合，它的底层其实是一个value为null的hash表，value自动排重且无序

（2）将一个或多个元素加入到集合key中：sadd，已经存在元素将忽略

127.0.0.1:6379> sadd k1 v1 v2 v3
(integer) 3

（3）取出集合中的所有值：smembers

127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"

（4）判断key集合中是否包含对应的value：sismember，1有0无

127.0.0.1:6379> sismember k1 v1
(integer) 1

（5）返回集合中元素个数：scard

127.0.0.1:6379> scard k1
(integer) 3

（6）从集合中删除某一个或多个元素：srem

127.0.0.1:6379> srem k1 v1
(integer) 1

（7）随机从该集合吐出一个元素：spop

127.0.0.1:6379> spop k1
"v3"

（8）随机从集合中取出n个值，不会从集合中删除：srandmember

127.0.0.1:6379> srandmember k1 2
1) "v1"
2) "v2"

（9）把集合中的一个值从一个集合移动到另一个集合：smove

127.0.0.1:6379> smove k1 k2 v3
(integer) 1

（10）取两个集合的交集/并集/差集（key1中存在，key2中不存在）：sinter/sunoin/sdiff

127.0.0.1:6379> sinter k2 k3
1) "v4"
127.0.0.1:6379> sunion k2 k3
1) "v3"
2) "v5"
3) "v4"
4) "v7"
5) "v6"
127.0.0.1:6379> sdiff k2 k3
1) "v3"
2) "v5"

3.5、Redis哈希（Hash）

（1）简介：是一个String类型的field和value的映射表，hash适合用来存储对象。类似java中Map<String,Object>，底层为zipList（数据量少）或hashtable（数据量较多）

（2）向hash内添加数据（key-field-value）：hset

127.0.0.1:6379> hset user:1001 id 1
(integer) 1
127.0.0.1:6379> hset user:1001 name zhangsan
(integer) 1

（3）从集合中取出数据（key-field）：hget

127.0.0.1:6379> hget user:1001 id
"1"
127.0.0.1:6379> hget user:1001 name
"zhangsan"

（4）批量添加数据：hmet

127.0.0.1:6379> hmset user:1002 id 2 name lisi age 30
OK

（5）判断哈希表key中，field是否存在：hexists，1有0无

127.0.0.1:6379> hexists user:1002 id
(integer) 1
127.0.0.1:6379> hexists user:1002 name
(integer) 1
127.0.0.1:6379> hexists user:1002 gender
(integer) 0

（6）查看哈希表中所有field：hkeys

127.0.0.1:6379> hkeys user:1002
1) "id"
2) "name"
3) "age"

（7）查看哈希表内所有value：hvals

127.0.0.1:6379> hvals user:1002
1) "2"
2) "lisi"
3) "30"

（8）对应的key、field的值增量+1：hincrby

127.0.0.1:6379> hincrby user:1002 age 2
(integer) 32

（9）添加数据，仅当field不存在时：hsetnx

127.0.0.1:6379> hsetnx user:1002 age 40
(integer) 0
127.0.0.1:6379> hsetnx user:1002 gender 1
(integer) 1

3.6、Redis有序集合（Zset）

（1）简介：有序的，类似set，没有重复元素，关联了score并可以进行排序,底层架构类似Map<String,value>，Zset底层为hash以及跳跃表

（2）将一个或多个元素以及score < key> < score1> < value1> < score2> < value2>加入到有序集合key中：zadd

127.0.0.1:6379> clear
127.0.0.1:6379> zadd topn 200 java 300 c++ 400 mysql 500 php
(integer) 4

（3）取出返回有序集合key中，下标在< start>< stop>之间：zrange，自动按照score排序，[withscores]可以返回评分

127.0.0.1:6379> zrange topn 0 -1
1) "java"
2) "c++"
3) "mysql"
4) "php"
127.0.0.1:6379> zrange topn 0 -1 withscores
1) "java"
2) "200"
3) "c++"
4) "300"
5) "mysql"
6) "400"
7) "php"
8) "500"

（4）取出score值介于min和max之间的成员，按照score从小到大排序：zrangebyscore < key>< min>< max>【withscores ][ limit offset count ]

127.0.0.1:6379> zrangebyscore  topn 300 500  withscores 
1) "c++"
2) "300"
3) "mysql"
4) "400"
5) "php"
6) "500"

（5）zrevngebyscore < key>< max>< min>【withscores ][ limit offset count ]

127.0.0.1:6379> zrevrangebyscore  topn 500 300  withscores 
1) "php"
2) "500"
3) "mysql"
4) "400"
5) "c++"
6) "300"

（6）为元素score加上增量：zincrby< key>< increment>< value>

127.0.0.1:6379> zincrby topn 50 java
"250"

（7）删除该集合中下，指定元素的值：zrem< key>< value>

127.0.0.1:6379> zrem topn php
(integer) 1

（8）统计该集合，分数区间内的元素个数：zcount< key>< min>< max>

127.0.0.1:6379> zcount topn 200 300
(integer) 2

（9）返回该值在集合中的排名，从0开始：zrank< key>< value>

127.0.0.1:6379> zrank topn c++
(integer) 1

四、Redis6配置文件详解

1、units单位：

只支持bytes，支持bit，不区分大小写

2、INCLUDES：

包含其他的配置文件

3、NETWORK：网络相关配置

（1）bind：限定是否只能本机连接等

（2）protected-mode：是否开启本机保护模式，只可本机访问

（3）port：默认端口号6379

（4）tcp-backlog：正在进行三次握手的队列总和默认值为511

（5）timeout：超时时间默认0，永不超时

（6）tcp-keepalive：检测心跳时间默认300秒

（7）daemonize：是否支持后台启动

（8）pidfile：保存对应的进程号文件

（9）loglevel：保存日志的级别

（10）logfile：设置日志的路径

（11）databases：默认使用16个库

（12）Security密码设置：

• foobared 取消注释，设置对应的密码信息

（13）LIMITS限制：

• maxclients：最大连接数，默认10000

（14)maxmemory：内存上限：

五、Redis6的发布和订阅

1、发布与订阅：

（1）发送者：pub发送消息

（2）订阅者：sub接受消息

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

2、发布订阅流程

（1）客户端可以订阅频道

（2）当这个频道发布消息后，消息就会发送给订阅的客户端

3、发布订阅的命令行实现

（1）打开一个客户端订阅channel1

127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1

（2）打开另一个客户端，给channel1发布消息hello

127.0.0.1:6379> publish channel1 hello
(integer) 1

（3）打开第一个客户端，可以看到发送的消息

127.0.0.1:6379> subscribe channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel1"
3) (integer) 1
1) "message"
2) "channel1"
3) "hello"

六、Redis6新数据类型

6.1、Bitmaps

（1）简介：实现对字符串的位的操作的字符串。是一个以位位单元的数组，数组每个单元只能存储0与1，下标与偏移量,与set相比节省gongjinaq

（2）设置Bitmaps中某个偏移量的值（0或1）：setbit< key>< offset>< value>

127.0.0.1:6379> setbit users:20210101 1 1
(integer) 0
127.0.0.1:6379> setbit users:20210101 6 1
(integer) 0
127.0.0.1:6379> setbit users:20210101 11 1
(integer) 0
127.0.0.1:6379> setbit users:20210101 15 1
(integer) 0
127.0.0.1:6379> setbit users:20210101 19 1
(integer) 0

（3）获取Bitmaps中某个偏移量的值：getbit< key>< offset>

127.0.0.1:6379> getbit users:20210101 1
(integer) 1

（4）统计字符串被设置位1的bit数量：bitcount【begin][end]

127.0.0.1:6379> bitcount users:20210101
(integer) 5
127.0.0.1:6379> bitcount users:20210101 1 5
(integer) 3

（5）复合操作（交集/并集/非/异或）：bitop and/or/not/xor

设置初始数据：

127.0.0.1:6379> setbit unique:users:20201104 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 2 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 5 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 9 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 0 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 4 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 9 1
(integer) 0

计算出两天都访问过网站的用户数量：（1与9号用户两天都访问了）

127.0.0.1:6379> bitop and unique:users:and:20201104_03 unique:users:20201103 unique:users:20201104
(integer) 2127.0.0.1:6379> bitcount unique:users:and:20201104_03
(integer) 2

计算出任意一天都访问过网站的用户数量

127.0.0.1:6379> bitop or unique:users:or:20201104_03 unique:users:20201103 unique:users:20201104
(integer) 2
127.0.0.1:6379> bitcount unique:users:or:20201104_03
(integer) 6

6.2、HyperLogLog

（1）简介：适用于独立IP数、搜索记录等需要去重和计数时。

（2）添加指定元素到HyperLogLog：pdadd< key>< element>[element]，1成功0失败

127.0.0.1:6379> pfadd program "java"
(integer) 1
127.0.0.1:6379> pfadd program "php"
(integer) 1
127.0.0.1:6379> pfadd program "java"
(integer) 0
127.0.0.1:6379> pfadd program "c++" "mysql"
(integer) 1

（3）统计HLL的pfcount< key>

127.0.0.1:6379> pfcount program
(integer) 4

（4）将一个或多个HLL合并的结果存储在另一个HLL：pfmeger

127.0.0.1:6379> pfmerge k100 k1 program
OK

6.3、Geospatial

（1）简介：redis3.2后增加GEO类型，即地理信息的缩写，提供了经纬度的设置、查询、范围查询、举例查询、经纬度hash等

（2）加地理位置（经度、纬度、名称）：geoadd< key>< longitude>< latitude>< member>[< longitude>< latitude>< member>]…

有效经纬度：-180°-180°，纬度：-85.05112878°-85.05112878°

127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52 shenzhen 116.38 39.90 beijing
(integer) 3

（3）获取指定地区的坐标值：geoos< key>< member>[member]…

127.0.0.1:6379> geopos china:city shanghai
1) 1) "121.47000163793563843"
   2) "31.22999903975783553"
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.38000041246414185"
   2) "39.90000009167092543"

(4)获取两个位置之间的直线距离：geodist< key>< member2>< member2><单位>

127.0.0.1:6379> geodist china:city beijing shanghai km
"1068.1535"

（5）以给定的经纬度为中心，找出某一半径内的元素：georadius< key>< longitude>< latitude>radius m|km|ft|mi

127.0.0.1:6379> georadius china:city 110 30 1000 km
1) "chongqing"
2) "shenzhen"

七、Jedis操作Redis6

1、idea建立maven工程

2、引入相关依赖：

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

3、jedis连接redis测试(Maven)

package com.testbk.jedis;
import redis.clients.jedis.Jedis;

public class jedisDemo1 {
    public static void main(String[] args) {
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //测试
        String value = jedis.ping();
        System.out.println(value);
    }
}

显示结果如下：

PONG

4、Jedis-API：操作key

//操作key
    @Test
    public void demo1(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.set("k1","v1");
        jedis.set("k2","v2");
        jedis.set("k3","v3");
        //查询所有key值
        Set<String> keys = jedis.keys("*");
        for(String key:keys){
            System.out.println(key);
        }
        //根据key获取value
        String value = jedis.get("k1");
        System.out.println("k1对应的value为："+value);
    }

查看运行结果：

k3
k1
k2
k1对应的value为：v1

5、Jedis-API：操作String

//操作String
    @Test
    public void demo2(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加多个数据
        jedis.mset("str1","v1","str2","v2","str3","v3");
        //查询所有key值
        System.out.println(jedis.mget("str1","str2","str3"));
    }

查看运行结果：

[v1, v2, v3]

6、Jedis-API：操作List

//操作List
    @Test
    public void demo3(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.lpush("k1","lucy","mary","jack");
        //查询数据
        List<String> value = jedis.lrange("k1", 0, -1);
        System.out.println(value);
    }

查看运行结果：

[jack, mary, lucy]

7、Jedis-API：操作set

//操作set
    @Test
    public void demo4(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.sadd("name","luck","mary","jack");
        //查询数据
        Set<String> names = jedis.smembers("name");
        System.out.println(names);
    }

查看运行结果：

[jack, mary, luck]

8、Jedis-API：操作set

//操作set
    @Test
    public void demo4(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.sadd("orders","order1");
        jedis.sadd("orders","order2");
        jedis.sadd("orders","order3");
        jedis.sadd("orders","order4");
        //查询数据
        Set<String> orders1 = jedis.smembers("orders");
        System.out.println(orders1);
        //删除后再查询
        jedis.srem("orders","order1");
        Set<String> orders2 = jedis.smembers("orders");
        System.out.println(orders2);
    }

查看运行结果：

[order3, order4, order1, order2]
[order3, order4, order2]

9、Jedis-API：操作Hash

//操作Hash
    @Test
    public void demo5(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.hset("users","age","20");
        //查询数据
        String hget = jedis.hget("users", "age");
        System.out.println(hget);
    }

查看运行结果：

20

10、Jedis-API：操作Zset

//操作Zset
    @Test
    public void demo6(){
        //创建Jedis对象,需要修改redis.conf的bind（注释）与protected-mode（no）配置
        Jedis jedis =new Jedis("192.168.37.8",6379);
        //清空redis
        jedis.flushDB();
        //添加数据
        jedis.zadd("china",100d,"shanghai");
        //查询数据
        Set<String> china = jedis.zrange("china", 0, -1);
        System.out.println(china);
    }

查看运行结果：

[shanghai]

八、Redis6与Spring Boot整合

1、idea创建springboot工程

2、pom文件引入springboot-redis的两个依赖

<!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--spring2.X集合redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>

3、springboot配置文件中配置redis相关内容

文件位置为resources下面的application.properties

# Redis服务器地址
spring.redis.host=192.168.37.8
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# Redis数据库索引（默认为0）
spring.redis.database=0
# 连接超时时间（毫秒）
spring.redis.timeout=1800000
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0

4、创建redis配置类：

package com.testbk.redis_springboot.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

5、编写RedisTestControll添加测试方法：

package com.testbk.redis_springboot.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;
    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return  name;
    }
}

6、启动类启动Springboot类：RedisSpringbootApplication

显示运行结果：

.   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.5.1)

浏览器访问验证：http://localhost:8080/redisTest，显示结果：

lucy

九、Redis6的事务操作

9.1、Redis事务定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序的执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队

9.2、Multi、Exec、discard

（1）基本概念

输入Multi命令开始：输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。

组队的过程中可以通过discard来放弃组队

正常场景：

异常场景2种：

9.3、事务命令演示

（1）组队-执行案例

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set key1 value1 
QUEUED
127.0.0.1:6379(TX)> set key2 value2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK

（2）组队-取消案例

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set a1 v1
QUEUED
127.0.0.1:6379(TX)> set a2 v2
QUEUED
127.0.0.1:6379(TX)> discard
OK

（3）组队-错误处理

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set b1 v1
QUEUED
127.0.0.1:6379(TX)> set b2 v2
QUEUED
127.0.0.1:6379(TX)> set b3 
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.

（4）组队-执行-错误处理

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set c1 v1
QUEUED
127.0.0.1:6379(TX)> incr c1
QUEUED
127.0.0.1:6379(TX)> set c2 v2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) (error) ERR value is not an integer or out of range
3) OK

9.4、事务冲突的问题

场景：多个人同时使用一个账户，参加双十一抢购，购买不同的商品，未加事务会产生冲突。

（1）悲观锁

每次拿数据适都认为别人会修改，所以每次在拿数据适都会上锁，这样别人想拿数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁，读锁，写锁，都是操作前上锁。

（2）乐观锁

每次拿数据的适合都认为别人不会修改，所以不会上锁，但是在更新的适合会判断一下在此期间别人有没有取更新这个数据，可以使用版本号等机制，乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用check-and-set机制实现事务的。

（3）WATCH key[key …]

含义：在执行multi之前，先执行wath key1[key2] 可以监视一个或多个key，如果在事务执行之前这些key被其他命令所改动，那么事务讲被打断。

举例，同时打开两个客户端，都watch 同一个key，然后第一个窗口exec，第二个窗口再执行exec，被乐观锁住：

127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> keys *
1) "balance"
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby balance 10
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 110
127.0.0.1:6379>

127.0.0.1:6379> keys *
1) "balance"
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby balance 20
QUEUED
127.0.0.1:6379(TX)> exec
(nil)
127.0.0.1:6379>

（4）UNWATCH：

取消命令对所有key的监视。

9.5、Redis事务三特性

（1）单独的隔离操作：

事务种的所有名历经都会序列化、按顺利执行，事务在执行的过程中，不会被其他客户端发送来的命令所打断

（2）没有隔离级别的概念：

队列中的命令没有提交之前不会实际被执行，因为事务提交前任何执行都不会被实际执行

（3）不保证原子性

事务中如果有一条命令执行失败，其中的命令任然会被执行，没有回滚

十、Reids6持久化

10.1、简介

两种持久化方式

（1）RDB（Redis DataBase）：内存中数据直接写入文件中

（2）AOF（Append Of File）：以追加的行为把内容写入文件中

10.2、RDB

（1）概念：

指定的时间间隔内讲内存中的数据集快照写入磁盘，它恢复时可以将快照文件直接读到内存里

（2）RDB持久化流程：

Redis会单独创建fork一个子进程来进行持久化，先将数据写入一个临时文件中，待持久化过程结束后，再用这个临时文件替换上次持久化的文件，RDB方式比AOF文件更加高效，缺点是最后一次持久化的数据可能丢失。

（3）Fork：写时复制技术：新进程的所有数据（变量、环境变量、程序计数器等）数值都有原进程一致。

（4）redis.conf配置内RDB相关配置（SNAPSHOTTING内配置）

rdb文件名：dbfilename dump.rdb

文件产生的路径，默认值(启动程序的位置)：dir ./

dbfilename dump.rdb
dir ./

快照的时间间隔：

# save 3600 1
# save 300 100
# save 60 10000

设置手动持久化或自动持久化

save Vs bgsave：建议设置自动持久化

# save ""

Redis无法写入磁盘的化，直接关掉Redis的写操作，默认yes

stop-writes-on-bgsave-error yes

是否进行文件压缩：rdbcompre，默认yes

rdbcompression yes

检查数据的完整性：rdbchecksum yes，默认yes

rdbchecksum yes

（5）RDB恢复备份文件

将持久化的备份文件恢复，重新redis，数据恢复

127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> shutdown
not connected> exit
[root@localhost bin]# /usr/local/bin/redis-server /opt/redis.conf
[root@localhost bin]# /usr/local/bin/redis-cli
127.0.0.1:6379> keys *
1) "program"
2) "k100"
3) "k1"
4) "china:city"

另一个命令行恢复操作：

[root@localhost bin]# ll
total 18884
-rw-r--r--. 1 root root      92 Jun 14 09:57 dump.rdb
-rw-r--r--. 1 root root     302 Jun 14 09:54 dump.rdb.bak
-rwxr-xr-x. 1 root root 4829592 May 20 06:16 redis-benchmark
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-aof -> redis-server
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-rdb -> redis-server
-rwxr-xr-x. 1 root root 5002840 May 20 06:16 redis-cli
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-sentinel -> redis-server
-rwxr-xr-x. 1 root root 9486688 May 20 06:16 redis-server
[root@localhost bin]#  
[root@localhost bin]# rm -rf dump.rdb
[root@localhost bin]# mv dump.rdb.bak dump.rdb

10.3、AOF

（1）概念：

以日志形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数。

优点：备份机制更稳健，丢失数据概率更低，通过操作AOF文件可以处理误操作

缺点：比RDB占用更多磁盘，恢复备份速度慢，每次读写都同步的话有性能压力

（2）AOF持久化流程

客户端在请求写命令时会被append追加到AOF缓冲区内

AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中

AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量

Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的

（3） redis.conf关于AOF相关配置：

开启AOF默认：，默认不开启no，开启需要修改为yes

appendonly no

AOF生成文件名：默认为appendonly.aof，生成的路径同RDB

appendfilename "appendonly.aof"

保存文件生成，同时开启AOF与RDB时，系统会使用AOF保存数据：

（4）AOF使用与恢复

执行操作命令：appendonly.aof文件追加了内容：

127.0.0.1:6379> set k11 v11
OK
127.0.0.1:6379> set k12 v12
OK
127.0.0.1:6379> set k13 v13
OK

-rw-r--r--. 1 root root       0 Jun 14 11:29 appendonly.aof
-rw-r--r--. 1 root root     302 Jun 14 09:54 dump.rdb
-rwxr-xr-x. 1 root root 4829592 May 20 06:16 redis-benchmark
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-aof -> redis-server
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-rdb -> redis-server
-rwxr-xr-x. 1 root root 5002840 May 20 06:16 redis-cli
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-sentinel -> redis-server
-rwxr-xr-x. 1 root root 9486688 May 20 06:16 redis-server
[root@localhost bin]# 
[root@localhost bin]# 
[root@localhost bin]# 
[root@localhost bin]# ll
total 18884
-rw-r--r--. 1 root root     116 Jun 14 11:33 appendonly.aof
-rw-r--r--. 1 root root     302 Jun 14 09:54 dump.rdb
-rwxr-xr-x. 1 root root 4829592 May 20 06:16 redis-benchmark
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-aof -> redis-server
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-check-rdb -> redis-server
-rwxr-xr-x. 1 root root 5002840 May 20 06:16 redis-cli
lrwxrwxrwx. 1 root root      12 May 20 06:16 redis-sentinel -> redis-server
-rwxr-xr-x. 1 root root 9486688 May 20 06:16 redis-server

AOF备份恢复

127.0.0.1:6379> keys *
1) "k12"
2) "k11"
3) "k13"
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> shutdown
not connected> exit
[root@localhost bin]# redis-server /opt/redis.conf 
[root@localhost bin]# redis-cli 
127.0.0.1:6379> keys *
1) "k11"
2) "k13"
3) "k12"

[root@localhost bin]# cp -r appendonly.aof appendonly.aof.bak
[root@localhost bin]# rm -rf appendonly.aof
[root@localhost bin]# mv appendonly.aof.bak appendonly.aof

异常恢复：

当AOF文件损坏，可通过如下命令执行文件修复：

redis-check-aof --fix appendonly.aof

（5）AOF同步频率设置

设置始终同步：appendfsync always，性能较差，但是数据完整性好

每秒同步：appendfsync everysec
把同步时机交给操作系统：appendfsync no

# appendfsync always
appendfsync everysec
# appendfsync no

（6）Rewrite压缩

当AOF文件大小超过所设定的阈值时（>=64M*2），Redis会启动AOF的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令bgrewriteaof开启此功能。

使用fork子进程将原来文件重写，把rdb的快照已二进制形式附在新的aof头部，作为已有的历史数据据，替换原有的流水账操作。

no-appendfsync-on-rewrite no

十一、Redis6的主从复制

11.1、概念

主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主

11.2、优势

（1）读写分离，性能扩展

（2）容灾快速恢复

11.3、主从复制的实现

（1）创建/myredis文件夹

（2）复制redis.conf配置文件到文件夹中

（3）配置一主两从，创建三个配置文件

redis6379.conf

redis6380.conf

redis6381.conf

（4）在三个配置文件中写入内容

配置先关闭AOF或改名，配置redis6379、redis6380、redis6381配置文件

include /myredis/redis.conf
pidfile /var/run/redis_6379.pid
port 6379
dbfilename dump6379.rdb

include /myredis/redis.conf
pidfile /var/run/redis_6380.pid
port 6380
dbfilename dump6380.rdb

include /myredis/redis.conf
pidfile /var/run/redis_6381.pid
port 6381
dbfilename dump6381.rdb

（5）启动三台redis服务器并查看进程：

[root@localhost myredis]# redis-server redis6379.conf 
[root@localhost myredis]# redis-server redis6380.conf 
[root@localhost myredis]# redis-server redis6381.conf 
[root@localhost myredis]# ps -ef | grep redis
root       3906      1  0 11:53 ?        00:00:08 redis-server *:6379
root       4024      1  0 13:07 ?        00:00:00 redis-server *:6380
root       4030      1  0 13:07 ?        00:00:00 redis-server *:6381
root       4036   3743  0 13:07 pts/3    00:00:00 grep --color=auto redis

（6）查看三个redis主机运行情况

[root@localhost myredis]# redis-cli -p 6379
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:cc2e7d7d4336c03f7e4333a94a56f4bc9fdbf464
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

（7）只配从(库)，不配主(库):

slaveof < ip>< port>：成为某个实例的从服务器：

在6380与6381上执行(让它们成为6379的从机)

127.0.0.1:6380> slaveof 127.0.0.1 6379

127.0.0.1:6381> slaveof 127.0.0.1 6379

11.4、test主从测试

场景：主服务6379做写操作，查看从服务器，且从服务器不能做写操作

11.5、常用三招

（1）一主两从：

从服务器挂掉后，重启会变成主服务，需要重新加入，数据会从主服务器重新复制一份

主服务器挂掉后，从服务器还是从服务器，主服务器重启后还是主服务器

（2）薪火相传：

从服务器可以配置为别的从服务器的从服务器

（3）反客为主：

当一个master宕机后，可以让一台slave升为master，其后面的slave不用做任何修改

slaveof no one

11.6、主从复制原理

（1）当从服务器连上主服务器之后，从服务器向主服务器发送进行数据同步消息

（2）主服务器接到从服务器发送过来同步消息，把主服务器数据进行持久化，生成RDB文件，把RDB文件发送给从服务器，从服务器拿到RDB进行读取

（3）每次主服务器进行写操作之后，和从服务器进行数同步

11.7、哨兵模式（sentinel）

（1）含义：（自动选举老大的模式）

反客为主的自动版，能否后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。

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

这里的哨兵有两个作用：

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

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

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。

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

（2）启动哨兵模式：

如一主二从的场景下，在myredis文件夹下建立sentinel.conf，配置哨兵模式，启动哨兵

sentinel monitor mymaster 127.0.0.1 6379 1

mymaster为监控对象别名，1为至少多少个哨兵同意迁移的数量

[root@localhost myredis]# redis-sentinel sentinel.conf

哨兵默认端口为26379

（3）当主机挂掉，从服务器选举成为主服务器：

（4）再次启动原来的主服务器，变为从服务器

（5）配置哨兵的优先级：

redis.conf配置文件中：slave-priority 100，值越小优先级越高。

当优先级相同时选举偏移量最大的

当偏移量一样的时选举runid最小的（随机）

十二、Reids集群

12.1、集群概念

Redis集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数量的1/N。

Redis集群通过分区（partition）来提供一定程序的可用性（avaliability）：即使集群中有一部分节点失效或者无法通讯，集群也可以继续处理命令请求。

Redis集群的优势：实现扩容、分摊压力、无中心配置相对简单

Redis集群的不足：多键操作不被支持、多键事务不支持（lua脚本不支持）、技术出现较晚，已有redis服务迁移到集群复杂度较高

12.2、redis集群搭建

（1）清除原备份文件，并将appendonly配置关闭

（2）制作6个实例，6379，6380，6381，6389，6390，6391

[root@localhost myredis]# vi redis6379.conf 

include /myredis/redis.conf
pidfile "/var/run/redis_6379.pid"
port 6379
dbfilename "dump6379.rdb"
#开启集群模式
cluster-enabled yes
#设置节点的名字
cluster-config-file nodes-6379.conf
#超时切换时间
cluster-node-timeout 15000

同样方式复制并修改（VI命令替换操作:%s/6379/6380）：

[root@localhost myredis]# cp redis6379.conf redis6380.conf
[root@localhost myredis]# ll
total 104
-rw-r--r--. 1 root root   244 Jun 27 17:42 redis6379.conf
-rw-r--r--. 1 root root   244 Jun 27 17:44 redis6380.conf
-rw-r--r--. 1 root root 93721 Jun 27 17:38 redis.conf
-rw-r--r--. 1 root root   392 Jun 27 15:45 sentinel.conf
[root@localhost myredis]# cp redis6379.conf redis6381.conf
[root@localhost myredis]# cp redis6379.conf redis6389.conf
[root@localhost myredis]# cp redis6379.conf redis6390.conf
[root@localhost myredis]# cp redis6379.conf redis6391.conf
[root@localhost myredis]# vi redis6380.conf 
[root@localhost myredis]# vi redis6381.conf 
[root@localhost myredis]# vi redis6381.conf 
[root@localhost myredis]# vi redis6389.conf 
[root@localhost myredis]# vi redis6390.conf 
[root@localhost myredis]# vi redis6391.conf

（3）启动6个redis服务

[root@localhost myredis]# redis-server redis6379.conf
[root@localhost myredis]# redis-server redis6380.conf
[root@localhost myredis]# redis-server redis6381.conf
[root@localhost myredis]# redis-server redis6389.conf
[root@localhost myredis]# redis-server redis6390.conf
[root@localhost myredis]# redis-server redis6391.conf
[root@localhost myredis]# ps -ef |grep redis
root       1596      1  0 15:33 ?        00:00:11 redis-server *:6380
root       1603      1  0 15:33 ?        00:00:10 redis-server *:6381
root       1644      1  0 15:42 ?        00:00:18 redis-sentinel *:26379 [sentinel]
root       1661      1  0 15:52 ?        00:00:09 redis-server *:6379
root       1926      1  0 17:53 ?        00:00:00 redis-server *:6389 [cluster]
root       1932      1  0 17:53 ?        00:00:00 redis-server *:6390 [cluster]
root       1938      1  0 17:53 ?        00:00:00 redis-server *:6391 [cluster]

（4）将6个节点合成一个集群

[root@localhost myredis]# cd /opt/redis-6.2.4/src/
[root@localhost src]# redis-cli --cluster create --cluster-replicas 1 192.168.37.8:6379 192.168.37.8:6380 192.168.37.8:6381 192.168.37.8:6389 192.168.37.8:6390 192.168.37.8:6391

[ERR] Node 192.168.37.8:6379 is not configured as a cluster node.错误需要将redis.conf下的cluster-enabled yes 的注释打开

配置6379、6380、6381为master，6389、6390、6391为slaver，yes确认

配置完成：

（5）连接集群并查看：

[root@localhost src]# redis-cli -c -p 6379
127.0.0.1:6379> cluster nodes

12.3、redis集群分配原则

分配原则：尽量保证每个主数据运行在不同的IP地址，每个主库和从库不在一个IP地址上

选项 --cluster-replicas 1表示我们希望为集群中的每个主节点创建一个从节点。

12.4、slots（插槽）

一个Redis集群包含16384个插槽（hash slot），数据库中每个键都属于这16384个插槽的其中之一。

集群使用公式CRC16(key)%16384来计算键key属于哪个槽，其中CRC176(key)语句用于计算键key和CRC16校验和。

集群中的每个节点负责处理一部分插槽。

添加数据，即往插槽内添加数据

添加多个数据时会报错

如要插入多条数据，需要分组操作

计算key对应的插槽值

cluster keyslot k1

计算对应插槽中的数值数量（只能看到属于自己集群的插槽）

cluster countkeysinslot 12706

返回操作中n个数值

cluster getkeysinslot 449 1

12.5、故障恢复

（1）使6379集群shutdown，6380从机替换变为主机

（2）主-从均挂掉的情况

cluster-require-full-coverage为yes，那么某一段插槽主从挂掉，整个集群都挂掉

cluster-require-full-coverage为no，那么某一段插槽主从挂掉，该段集群的插槽不能提供服务，其他插槽依然可以提供服务

12.6、集群的jedis开发

package com.testbk.jedis;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

/**
 * 演示redis集群操作
 */
public class RedisClusterDemo {
    public static void main(String[] args) {
        //创建对象
        HostAndPort hostAndPort = new HostAndPort("192.168.37.8", 6379);
        JedisCluster jedisCluster = new JedisCluster(hostAndPort);
        //进行操作
        jedisCluster.set("b1","value1");
        String value = jedisCluster.get("b1");
        System.out.println(value);
        //关闭jedis连接
        jedisCluster.close();
    }

}

查看运行结果：

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
value1

十三、Redis6应用问题解决

13.1、缓存穿透（查不到）

（1）现象：

应用服务器压力变大

redis命中率降低

一直查询数据库

（2）造成原因：

redis查询不到数据库

出现很多非正常url访问

（3）解决方案：

对空值进行缓存：缓存空结果null值

设置访问白名单：使用bitmaps类型定义一个可以访问的名单，每次访问时进行拦截

布隆过滤器：（Bloom Filter）1970年布隆提出的，它实际上是一个很长的二进制向量（位图）和一系列随机映射函数（哈希函数）。布隆过滤器用于检索一个元素是否在一个集合，但是也存在误识别的情况

进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，设置黑名单

13.2、缓存击穿（量太大，突然缓存过期）

（1）现象：

数据库的访问压力瞬时增加、redis里面没有出现大量key过期、redis正常运行。

这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。

（2）造成原因：

redis某个key过期了，而此时还有大量的访问在使用这个key

（3）解决方案：

预先设置热门数据：在redis高峰访问之前，把一些热门数据提前存入到redis内，加大这些热门数据key的时长

实时调整：现场监控哪些数据热门，实时调整key的过期时长

使用锁的方式：设置排它锁：在根据key获得的value值为空时，先锁上，再从数据库加载，加载完毕，释放锁。若其他线程发现获取锁失败，则睡眠一段时间后重试

13.3、缓存雪崩

（1）现象：

数据库压力变大、服务器崩溃。

缓存雪崩，是指在某一个时间段，缓存集中过期失效。Redis 宕机！

（2）造成原因：

在极少的时间段，查询大量key的集中过期情况。

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

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

（3）解决方案：

构建多级缓存架构：nginx缓存+redis缓存+其他缓存（ehcache等）

使用锁或队列：用加锁或者队列保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量并发请求落到底层存储系统上，不适用于高并发情况

设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台更新实际key的缓存

将缓存失效实际分散开：可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，很难引发集体失效的事件

13.4、分布式锁

（1）解决问题：

随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式多线程，多进程并且分布在不同机器上，这将使原单机部署的情况下并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力，为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题。

（2）分布式锁主流的实现方案

基于数据库实现分布式锁

基于缓存Redis等

基于Zookeeper

（3）每一种分布式锁解决方案都有各自的优缺点：

性能：redis最高

可靠性：zookeeper最高

这里介绍的是基于redis实现的分布式锁

（4）实现方案：使用redis实现分布式锁

使用setnx实现分布式锁：

127.0.0.1:6379> setnx users 10

删除key释放setnx分布式锁：

192.168.37.8:6381> del users

使用setnx设置分布式锁，再设置过期时间，过期后自动解锁

192.168.37.8:6381> setnx users 10
(integer) 1
192.168.37.8:6381> expire users 10
(integer) 1
192.168.37.8:6381> ttl users

为防止上锁后redis机器故障，使用set nx ex上锁同时设置过期时间：（原子操作）

set users 10 nx ex 12

（5）java代码实现分布式锁

springboot编写的代码如下：

package com.testbk.redis_springboot.controller;

import io.netty.util.internal.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("testLock")
    public void testLock(){
        //1获取锁，sentne,并设置锁的过期时间3s
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock","111",3, TimeUnit.SECONDS);
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断numb为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num",++num);
            //2.4释放锁，del
            redisTemplate.delete("lock");
        }
        else {
            //3获取锁失败，每隔0.1秒再获取
            try{
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return  name;
    }
}

运行，并在管理台测试，首先建立key->num赋值为0

127.0.0.1:6379> set num "0"
OK
127.0.0.1:6379> get num
"0"

另一个窗口通过ab压力测试工具进行测试，1000个请求，100个请求并发，并且触发分布式锁

ab -n 1000 -c 100 http://192.168.31.12:8080/redisTest/testLock

查看num，值累加到1000

127.0.0.1:6379> get num
"1000"

（6）解决释放错锁的问题（防误删）

第一步：通过uuid表示不同的操作

set lock uuid nx ex 10

第二部：释放锁时候，首先判断当前uuid和要适当锁uuid是否一样

改造测试代码如下：

package com.testbk.redis_springboot.controller;

import io.netty.util.internal.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("testLock")
    public void testLock(){
        String uuid = UUID.randomUUID().toString();
        //1获取锁，sentne,并设置锁的过期时间3s
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,3, TimeUnit.SECONDS);
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断numb为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num",++num);
            //2.4释放锁，del
            //判断比较uuid值是否一样
            Object lockUuid = redisTemplate.opsForValue().get("lock");
            if(lockUuid.equals(uuid)){
                redisTemplate.delete("lock");
            }
        }
        else {
            //3获取锁失败，每隔0.1秒再获取
            try{
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return  name;
    }
}

（7）解决删除操作非原子性问题：

场景：当比较uuid一样，当a删除操作的时候，正要删除还没有删除时，锁到了过期时间自动释放，此时b上了这把锁，会导致a把b的锁删除掉。

可以通过定义lua脚本优化代码

package com.testbk.redis_springboot.controller;

import io.netty.util.internal.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("testLock")
    public void testLock(){
        //1声音一个uuid，讲作为一个value放入我们的key对应的值中
        String uuid = UUID.randomUUID().toString();
        //2定义一个锁：lua脚本可以使用同一把锁，来实现删除!
        String skuId = "25";
        String locKey= "lock" + skuId;
        //3取锁，sentne,并设置锁的过期时间3s
        Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey,uuid,3, TimeUnit.SECONDS);

        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断numb为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num",String.valueOf(++num));
            /*使用lua脚本来锁*/
            //定义lua脚本
            String script = "if redis.call('get',KEY[1]) == ARGV[1] then return redis.call('del',KEY[1]) else return 0 end";
            //使用redis执行lua脚本
            DefaultRedisScript<Long> redisScript= new DefaultRedisScript<>();
            redisScript.setScriptText(script);
            //设置一下返回类型为Long
            //因为删除的时候，返回为0，给其封装为数据类型，如果不封装那么默认返回String
            //那么返回字符串与0会发成错误
            redisScript.setResultType(Long.class);
            //第一个要是script脚本，第二个需要判断的key，第三个就是key对应的值
            redisTemplate.execute(redisScript, Arrays.asList(locKey),uuid);
        }
        else {
            //3获取锁失败，每隔0.1秒再获取
            try{
                Thread.sleep(1000);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return  name;
    }
}

（8）总结-分布式锁可用性需要同时满足四个条件：

• 互斥性：在任意时刻，只有一个客户端能持有锁。

• 不发生死锁：即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

• 解铃还须系铃人：加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

• 加锁和解锁必须具有原子性。

十四、Redis6新功能

14.1、ACL（访问控制列表）

（1）简介

Access Control List：Redis6提供ACL功能对用户进行更细粒度的权限控制。

（2）命令

使用acl list展现用户权限列表

127.0.0.1:6379> acl list

使用acl cat查看添加权限的指令类别

查看当前acl用户：

127.0.0.1:6379> acl whoami

添加acl用户：（可用，包含密码，可操作包含cached的key，只能get命令操作）

127.0.0.1:6379> acl setuser mary on >password ~cached:* +get

切换用户，进行测试：

127.0.0.1:6379> auth mary password

14.2、IO多线程

（1）简介：

Redis6加入了多线程：值得是客户端交互部分的网络IO交互处理模板多线程，而非执行命令多线程，Redis6执行命令依然是单线程的。

（2）原理架构：

Redis的多线程部分只是用户处理网路数据的读写和协议解析，执行命令依然是单线程的，因为是需要控制key、lua、事务。

多线程默认是不开启的，需要配置文件中配置

io-threads 4

3、工具支持cluster

Redis5之前的版本搭建集合需要单独安装ruby环境，Redis5讲redis-trib.rb的功能集成到了redis-cli，另外官方redis-benchmark工具开始支持cluster模式，通过多线程的方式对多个分片进行压测。