---------------------------------------分割线：正文--------------------------------------------------------
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、不适用场景
需要事务的支持
基于sql的结构化查询存储，需要即席查询
5、 Redis概述
（1）开源的key-value系统
（2）支持String、List、Set、zset、hash等数据类型
（3）数据库支持push/pop/add/remove操作
（3）支持不同方式的排序
（4）可写入内存也可以持久化
（5）主从同步功能
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、相关软件介绍：
redis-benchmar：性能测试工具
redis-check-aof：修改有问题的AOF
redis-check-rdb：修改有问题的rdb文件
redis-sentinel：Redis的集群使用
redis-server：Redis服务器集群使用
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（进程）
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
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、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
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"
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
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
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：内存上限：
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"
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) 2
127.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
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
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"
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]
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
1、Redis事务定义
Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序的执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
Redis事务的主要作用就是串联多个命令防止别的命令插队
2、Multi、Exec、discard
（1）基本概念
输入Multi命令开始：输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
组队的过程中可以通过discard来放弃组队
正常场景：
异常场景2种：
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
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的监视。
5、Redis事务三特性：
（1）单独的隔离操作：
事务种的所有名历经都会序列化、按顺利执行，事务在执行的过程中，不会被其他客户端发送来的命令所打断
（2）没有隔离级别的概念：
队列中的命令没有提交之前不会实际被执行，因为事务提交前任何执行都不会被实际执行
（3）不保证原子性
事务中如果有一条命令执行失败，其中的命令任然会被执行，没有回滚
1、简介
两种持久化方式
（1）RDB（Redis DataBase）：内存中数据直接写入文件中
（2）AOF（Append Of File）：以追加的行为把内容写入文件中
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
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
1、概念：
主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主
2、优势：
（1）读写分离，性能扩展
（2）容灾快速恢复
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上执行
127.0.0.1:6380> slaveof 127.0.0.1 6379
127.0.0.1:6381> slaveof 127.0.0.1 6379
4、test主从测试：
场景：主服务6379做写操作，查看从服务器，且从服务器不能做写操作
5、常用三招：
（1）一主两从：
从服务器挂掉后，重启会变成主服务，需要重新加入，数据会从主服务器重新复制一份
主服务器挂掉后，从服务器还是从服务器，主服务器重启后还是主服务器
（2）薪火相传：
从服务器可以配置为别的从服务器的从服务器
（3）反客为主：
当一个master宕机后，可以让一台slave升为master，其后面的slave不用做任何修改
slaveof no one
6、主从复制原理
（1）当从服务器连上主服务器之后，从服务器向主服务器发送进行数据同步消息
（2）主服务器接到从服务器发送过来同步消息，把主服务器数据进行持久化，生成RDB文件，把RDB文件发送给从服务器，从服务器拿到RDB进行读取
（3）每次主服务器进行写操作之后，和从服务器进行数同步
7、哨兵模式（sentinel）
（1）含义：
反客为主的自动版，能否后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库
（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最小的（随机）
1、集群概念：
Redis集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数量的1/N。
Redis集群通过分区（partition）来提供一定程序的可用性（avaliability）：即使集群中有一部分节点失效或者无法通讯，集群也可以继续处理命令请求。
Redis集群的优势：实现扩容、分摊压力、无中心配置相对简单
Redis集群的不足：多键操作不被支持、多键事务不支持（lua脚本不支持）、技术出现较晚，已有redis服务迁移到集群复杂度较高
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
3、redis集群分配原则：
分配原则：尽量保证每个主数据运行在不同的IP地址，每个主库和从库不在一个IP地址上
选项 --cluster-replicas 1表示我们希望为集群中的每个主节点创建一个从节点。
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
5、故障恢复
（1）使6379集群shutdown，6380从机替换变为主机
（2）主-从均挂掉的情况
cluster-require-full-coverage为yes，那么某一段插槽主从挂掉，整个集群都挂掉
cluster-require-full-coverage为no，那么某一段插槽主从挂掉，该段集群的插槽不能提供服务，其他插槽依然可以提供服务
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
1、缓存穿透：
（1）现象：
应用服务器压力变大
redis命中率降低
一直查询数据库
（2）造成原因：
redis查询不到数据库
出现很多非正常url访问
（3）解决方案：
对空值进行缓存：缓存空结果null值
设置访问白名单：使用bitmaps类型定义一个可以访问的名单，每次访问时进行拦截
布隆过滤器：（Bloom Filter）1970年布隆提出的，它实际上是一个很长的二进制向量（位图）和一系列随机映射函数（哈希函数）。布隆过滤器用于检索一个元素是否在一个集合，但是也存在误识别的情况
进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，设置黑名单
2、缓存击穿：
（1）现象：
数据库的访问压力瞬时增加、redis里面没有出现大量key过期、redis正常运行
（2）造成原因：
redis某个key过期了，大量访问使用这个key
（3）解决方案：
预先设置热门数据：在redis高峰访问之前，把一些热门数据提前存入到redis内，加大这些热门数据key的时长
实时调整：现场监控哪些数据热门，实时调整key的过期时长
使用锁的方式：设置排它锁：在根据key获得的value值为空时，先锁上，再从数据库加载，加载完毕，释放锁。若其他线程发现获取锁失败，则睡眠一段时间后重试
3、缓存雪崩：
（1）现象：
数据库压力变大、服务器崩溃
（2）造成原因：
在极少的时间段，查询大量key的集中过期情况
（3）解决方案：
构建多级缓存架构：nginx缓存+redis缓存+其他缓存（ehcache等）
使用锁或队列：用加锁或者队列保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量并发请求落到底层存储系统上，不适用于高并发情况
设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台更新实际key的缓存
将缓存失效实际分散开：可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，很难引发集体失效的事件
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）总结-分布式锁可用性需要同事满足四个条件：
互斥性：在任意时刻，只有一个客户端能持有锁。
不发生死锁：即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
解铃还须系铃人：加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
加锁和解锁必须具有原子性。
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
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模式，通过多线程的方式对多个分片进行压测。
