Redis
2024/12/19大约 31 分钟
Redis
一：Redis前提
缓存数据库/缓存
List Map Set :本地缓存
Redis：缓存数据库
在Java中使用非常频繁的缓存数据库
二：Redis简介
2.1：Redis简介
官网：https://redis.io/
Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis ClusterRedis 是完全开源的，C语言编写，基于内存，是一个高性能的 Nosql（非关系型） 数据库。
一.关系型数据库（mysql、oracle、PostgreSQL、SqlServer）
定义：关系型数据库最典型的数据结构是表，由二维表及其之间的联系所组成的一个数据组织.
【优点：】
1.易于维护：都是使用表结构，格式一致；
2.使用方便：SQL语言通用，可用于复杂查询，可用于一个表及多个表之间非常复杂关联查询；
【缺点：】
1.关系型数据库操作的是磁盘，硬盘I/O是一个很大的瓶颈
2.固定的表结构，灵活度稍欠；
稀疏型
{name:'jack'}
{course:'java'}
{name:'jack,sex:'1'}
二.非关系型数据库（Redis(KV)、Memcache（KV）、ElasticSearch(JSON)）
定义：非关系型数据库是一种数据结构化存储方法的集合，可以是文档或者键值对。
【优点：】
1.格式灵活：存储数据的格式可以是key,value形式、文档形式。
2.速度快：nosql可以使用内存存储，而关系型数据库只能使用硬盘；
【缺点：】
不支持sql，数据间没有关联关系2.2：Redis特性
1、性能极高 – Redis 读的速度是110000次/s,写的速度是81000次/s 。
2、丰富的数据类型 – Redis支持五种常用数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)
3、原子 – Redis的所有操作都是原子性的，意思就是要么成功执行要么失败完全不执行。单个操作是原子性的。多个操作也支持事务
4、丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。Redis 与其他 key - value（Memcache） 缓存产品有以下三个特点：
1：Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
2：Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
3：Redis支持数据的备份，即master-slave模式的数据备份。2.3：Redis:使用场景
1：查询缓存 mybatis 的一二级缓存 list map set
2：分布式锁 setnx
3：秒杀活动数据存储(将Redis当做database来存储商品信息以及用户的下单信息)
4：注册、登录 使用Redis存储验证码（Redis的key可以设置过期时间）三：Redis安装
Window安装Redis
下载地址：https://github.com/microsoftarchive/redis/releases
闪退：路径下cmd ，redis-server.exe redis.windows.conf
docker安装Redis
第一步：搜索redis镜像 先去 hub.docker.com
docker search redis第二步：下载redis镜像
docker pull redis:6.0.9第三步：创建redis容器
docker run -d --name redis01 -p6379:6379 redis:6.0.9第四步：远程连接redis
Linux安装Redis
redis-6.0.8.tar.gz gcc c语言的编译器
注意：redis6版本要求gcc版本必须5.3以上，centos7默认安装的版本是4.8.5，查看gcc版本命令 gcc-v
升级gcc,以下每行命令依次执行即可升级gcc到9.3.1
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
scl enable devtoolset-9 bash
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile --使永久生效
yum install tcl -y上传redis的压缩包到服务器,并解压
（如果之前安装过，server下有redis*，先到server下，执行rm -rf ./redis* * ）
[root@zhuxm01 soft]# tar -zxvf redis-6.0.8.tar.gz -C /usr/local/编译（ 在redis的解压路径执行以下命令)
[root@zhuxm01 redis-6.0.8]# cd /usr/local/redis-6.0.8/
[root@zhuxm01 redis-6.0.8]# make安装
[root@zhuxm01 redis-6.0.8]# cd /usr/local/redis-6.0.8/
[root@zhuxm01 redis-6.0.8]# make PREFIX=/usr/local/redis install
前台启动(先切换到 /usr/local/redis/bin，在执行./redis-server)
四：Redis数据类型 (列举数据类型)
面试：Redis常用的数据类型
String, List ,Set,Hash ,ZSet
K string
V String
4.1：String
set k v
get k
del k
strlen k
#自加、自减
incr age
incrby age 3
decr age
decrby age
#value字符串操作
getrange name 0 -1 #取整个字符串
getrange name 0 1
setrange name 0 x
# SETEX 是一个原子性(atomic)操作，设置值和设置生存时间两个动作会在同一时间内完成
SETEX pro 10 华为 （查看剩余时间ttl pro）
set pro 华为
expire pro 10
#在分布式系统里面可以使用如下命令实现分布式锁 (synchronized)
setnx(set if not exist)
setnx name a
如果返回1：设置成功
如果返回0：设置失败
redis分布式锁 setIfAbsent()4.2：List
K string
V List
list特点：有序、可重复
git push
vue2 代码 push
存
lpush num 1 2 3 4 5
rpush num2 1 2 3 4 5
查
lrange num 0 -1 查所有
lrange num2 0 -1
#根据下标获取元素
lindex num index
弹出（获取数据的同时将数据从list中删除）
lpop
rpop
大小
llen num
#队列:先进先出
lpush num3 1 2 3 #左边推进去
rpop num3 1 #右边取出来
或者
rpush num4 1 2 3
lpop num4
#栈:先进后出
lpush num5 1 2 3
lpop num5
或者
rpush num6 1 2 3
rpop num6
lpush rpop / rpush lpop 队列
lpush lpop / rpush rpop 栈
#list的长度
llen num5lindex num index
4.3：Set
K string
V Set
set特点：无序，不可重复
存
sadd ips '192.168.22.1' '192.168.22.2' '192.168.22.2'
查
smembers ips
sismember ips member （返回1存在，0 不存在）
删
srem ips '192.168.22.1'
大小
scard ips #获取set的长度
sadd nums 3 4 5 0 9 8 9 0 8 6
#随机
srandmember nums 3
#随机并移除
spop nums 3
交集
redis 127.0.0.1:6379> SADD myset "hello"
(integer) 1
redis 127.0.0.1:6379> SADD myset "foo"
(integer) 1
redis 127.0.0.1:6379> SADD myset "bar"
(integer)
redis 127.0.0.1:6379> SADD myset2 "hello"
(integer) 1
redis 127.0.0.1:6379> SADD myset2 "world"
(integer) 1
redis 127.0.0.1:6379> SINTER myset myset2
1) "hello"
并集
redis> SADD key1 "a"
(integer) 1
redis> SADD key1 "b"
(integer) 1
redis> SADD key1 "c"
(integer) 1
redis> SADD key2 "c"
(integer) 1
redis> SADD key2 "d"
(integer) 1
redis> SADD key2 "e"
(integer) 1
redis> SUNION key1 key2
1) "a"
2) "c"
3) "b"
4) "e"
5) "d"4.4：Hash
> KEY VALUE (key value )
>
> Redis 购物车： KEY : "shopcart" field:userid value :List<Goods>-->string
>
> 1 频率使用高
>
> 2购物车意向购买，未必真正去支付，下订单的话可以把订单数据放到数据库中
>
> 没有下订单，用redis存商品信息
>
> 秒杀 Redis ：快
>
>
>
>
>
> K string
>
> V Hash
>
> hash特点：hash的key不能重复，如果重复就覆盖 <key,<key,value>>
>
>
>
>
```shell
存
hset person name 'jack' dicts 1 件
hset person age 40 dicts 2 套
取
hget person name
hget person age
存多个
hmset person name 'rose' age 12
大小
hlen person
判断k是否存在
hexists person age
hkeys person
hvals person
#hash可以大大减少redis中的K 同时hash结构特别适合存放对象
person :
name 'jack'
age '18'
hget person age
购物车的例子:每个人->每个商品的信息 redis 中 (hash)
uid, goodid, count~price~sum4.5：Zset(sorted set)
K string
V ZSet
zset特点：有序，不可重复，通过score来进行排序，score必须是数字
通过score进行排序
zadd hot 300 '华为met10' 10 '苹果10' 19 '小米'
zrange hot 0 -1 升序
zrevrange hot 0 -1 降序
#分数范围过滤
zrangebyscore hot 11 100
zrangebyscore hot 10 100 limit 0 1
#删除
zrem hot '小米'
zcard hot #查看集合的元素个数1)数据量不要太大
2)数据比较稳定，变化不大
3)访问频繁
redis / String Hash
五：其他指令
#########################key相关指令##############
keys parttern
127.0.0.1:6379> keys art*
1) "article2"
2) "artile1"
127.0.0.1:6379>
#如果存在返回1，否则返回0
exists key
del key
keys * 查看所有key
#给key设置过期时间
expire key seconds
#查看key的剩余时间 -1：表示没有过期时间 >0 表示剩余的时间 -2:过期，数据被回收
ttl key
#不设置过期时间，让它常驻内存
persist key
################db相关的指令##########################
Redis有16个db 分别为0，1,...,15【redis的默认数据库为0】
#切换数据库
select index
#清空数据库
flushdb
#清空所有的数据库
flushall
#数据库的数据总条数
dbsize
#最近一次保存数据的时间戳
lastsave六：Redis事务
Redis中的事务跟mysql不一样，mysql可以保证acid 但是redis的事务在运行时异常不能保证原子性，只能在编译时异常保证原子性
mutli #开启事务 begin transation
exec #提交事务 commit
discard #回滚事务 rollback#正常事务提交
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name jack
QUEUED
127.0.0.1:6379> get name
QUEUED
127.0.0.1:6379> set age 18
QUEUED
127.0.0.1:6379> exec
#redis事务保证顺序执行、同时一起执行#放弃事务
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name sdf
QUEUED
127.0.0.1:6379> set age 12
QUEUED
127.0.0.1:6379> discard#编译时异常,回滚
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name 123
QUEUED
127.0.0.1:6379> kset xx sdf
ERR unknown command `kset`, with args beginning with: `xx`, `sdf`,
127.0.0.1:6379> set age 21
QUEUED
127.0.0.1:6379> exec
EXECABORT Transaction discarded because of previous errors.#运行时异常，不回滚
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set name jack
QUEUED
127.0.0.1:6379> incr name
QUEUED
127.0.0.1:6379> set age 12
QUEUED
127.0.0.1:6379> exec
OK
ERR value is not an integer or out of range
OK
127.0.0.1:6379> get age
12七：Jedis
pom依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.0.0</version>
</dependency>java代码
@Test
public void testRedis (){
Jedis jedis = new Jedis("192.168.234.122", 6379);
jedis.set("name", "jack");
System.out.println(jedis.get("name"));
jedis.close();
}
@Test
public void testJedispwd (){
Jedis jedis = new Jedis("192.168.234.131",6379);
jedis.auth("123456");
jedis.set("name","jack");
String name = jedis.get("name");
System.out.println(name);
jedis.close();
}//最大连接和空闲连接设置一样的
@Test
public void testJedisPool() {
JedisPoolConfig config = new JedisPoolConfig();
//最大空闲连接数, 默认8个（可用的最大连接）
config.setMaxIdle(8);
//最大连接数, 默认8个 (理论上的最大连接)
config.setMaxTotal(8);
JedisPool jedisPool = new JedisPool(config,"192.168.234.122", 6379);
Jedis jedis = jedisPool.getResource();
jedis.set("name", "rose");
System.out.println(jedis.get("name"));
jedis.close();
jedisPool.close();
}查看防火墙状态：systemctl status firewalld
关闭防火墙：systemctl stop firewalld
查看redis是否启动： ps -ef | grep redis
查看tcp端口：netstat -nltp | grep 6379 //--（ 全局搜索带redis的find / -name redis*）
强制关闭 pkill -9 redis
客户端连上 shutdown 、或者是服务端 ctrl +c
注意：
1：修改bind
bind ip错误理解：不是说bind哪个ip ，就只能哪个ip来访问redis
bind ip正确理解： bind本机的网卡对应的ip地址，只有通过指定网卡进来的主机才能访问redis
bind 127.0.0.1（默认），本地回环地址。那么访问redis服务只能通过本机的客户端连接，而无法通过远程连接
bind 192.168.88.100 通过本机ens33网卡进来的主机都可以访问redis，这样设置后基本所有的主机都可以访问
如果要限制只允许某些host访问，那么可以通过配置安全组实现jedis常见api
字符串
// 1.string
//输出结果: OK
jedis.set("hello", "world");
//输出结果: world
jedis.get("hello");
//输出结果:1
jedis.incr("counter");
哈希
// 2.hash
jedis.hset("myhash", "f1", "v1");
jedis.hset("myhash", "f2", "v2");
//输出结果 : {f1=v1, f2=v2}
jedis.hgetAll("myhash");
列表
// 3.list
jedis.rpush("mylist", "1");
jedis.rpush("mylist", "2");
jedis.rpush(" mylist", "3");
//输出结果 : [1, 2, 3]
jedis.lrange("mylist", 0, -1);
集合
// 4.set
jedis.sadd(" myset", "a");
jedis.sadd(" myset", "b");
jedis.sadd(" myset", "a");
//输出结果 : [b, a]
jedis.smembers("myset");
有序集合
// 5.zset
jedis.zadd("myzset", 99, "tom");
jedis.zadd("myzset", 66, "peter");
jedis.zadd("myzset", 33, "james");
//输出结果 : [[["james"],33.0], [["peter"],66.0], [["tom"],99.0]]
jedis.zrangeWithScores("myzset", 0, -1);八：Spring-data-redis
官网：https://spring.io/projects/spring-data-redis
8.1：基于springboot (重点)
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-pool2 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.8.0</version>
</dependency>#redis的连接信息
spring:
redis:
host: 192.168.234.110
port: 6379
password: 123456
#redis连接池的配置信息
lettuce:
pool:
max-active: 8测试
package com.qf;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
import java.util.Set;
/**
* <p>title: com.qf</p>
* <p>Company: wendao</p>
* author zhuximing
* date 2021/6/24
* description:
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:app-redis.xml"})
public class RedisTest {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
public void testString(){
stringRedisTemplate.boundValueOps("name").set("lisi");
String name = stringRedisTemplate.boundValueOps("name").get();
System.out.println(name);
}
@Test
public void testList(){
//存
BoundListOperations<String, String> operations = stringRedisTemplate.boundListOps("names");
operations.rightPush("张飞");
operations.rightPush("关羽");
//取
String s = operations.rightPop();
System.out.println(s);
}
@Test
public void testHash(){
BoundHashOperations<String, Object, Object> operations = stringRedisTemplate.boundHashOps("person");
//存
operations.put("name", "jack");
operations.put("age", "18");
//取
Object name = operations.get("name");
System.out.println(name);
//取所有的value
Set<Object> keys = operations.keys();
List<Object> values = operations.values();
values.forEach(System.out::println);
}
@Test
public void testSet(){
BoundSetOperations<String, String> operations = stringRedisTemplate.boundSetOps("ips");
//存
operations.add("110","110","111","112");
//取
Set<String> members = operations.members();
members.forEach(System.out::println);
//判断元素是否存在
Boolean member = operations.isMember("110");
System.out.println(member);
}
@Test
public void testZset(){
BoundZSetOperations<String, String> operations = stringRedisTemplate.boundZSetOps("pro");
//存
operations.add("华为", 12);
operations.add("小米", 2);
operations.add("iphone", 1);
//取
Set<String> range = operations.range(0, -1);
range.forEach(System.out::println);
Set<String> strings = operations.reverseRange(0, -1);
strings.forEach(System.out::println);
//显示分数信息
Set<ZSetOperations.TypedTuple<String>> typedTuples = operations.rangeWithScores(0, -1);
for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
String value = typedTuple.getValue();
Double score = typedTuple.getScore();
System.out.println(score+" --"+value);
}
}
@Test
public void test6(){
SessionCallback<Object> callback = new SessionCallback<Object>() {
@Override
public Object execute(RedisOperations operations) throws DataAccessException {
//开启事务
operations.multi();
try{
BoundValueOperations name = operations.boundValueOps("name");
name.set("张三");
// int i=1/0;
//事务提交
return operations.exec();
}catch (Exception e){
//事务回滚
operations.discard();
return null;
}
}
};
stringRedisTemplate.execute(callback);
}
}九：Redis应用
短信验证码
缓存
Redis分布式锁 (setIfAbsent())
9.1：短信验证码
用Redis存放短信验证码
why not session？
Session依赖于Cookie
hutool工具包：
糊涂工具官网：https://www.hutool.cn/docs/#/
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.12</version>
</dependency>模拟：1生成随机生成4个数字，key为手机号,数字为val值，放在redis 中，设置超时时间2分钟
2 做一个简易的页面，输入手机号，验证码，后台比对输入的验证和redis中的存储数据
3 一样登录，不一样登录失败
hutoo工具包使用：
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.7.19</version>
</dependency>
如需使用thymeleaf，则可以引入：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>代码：
@Service
public class LoginServiceImpl implements LoginService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Override
public void getCode() {
//1 产生验证码
String code = RandomUtil.randomNumbers(4);
//2 放到redis ，设置一下超时2分钟 <KEY,<key,value> "phonecode","13112341234","5467"
BoundValueOperations<String, String> mycode = stringRedisTemplate.boundValueOps("13112341234");
mycode.set(code);
mycode.expire(2, TimeUnit.MINUTES);
}
@Override
public String checkCode(String phone,String code) {
BoundValueOperations<String, String> phonecode = stringRedisTemplate.boundValueOps(phone);
String codeRedis = phonecode.get();
if(codeRedis!=null && codeRedis.equals(code)){
return "校验通过";
}
return "校验失败";
}9.2：Redis查询缓存
查询缓存： 数据字典表
电商项目
金额单位：元 / 万元
衣服数量量级：件 /套
鞋子: 只/双
以字典表为例： 1先从redis缓存中查询是否有所有字典表数据
2 如果有，直接返回到前端，不到数据库中查
3 如果没有，查询db，返回到前端，并放到redis中
@Override
public List<Dict> getAllDicts() {
BoundValueOperations<String, String> redisCache = stringRedisTemplate.boundValueOps("dicts1234");
if(StringUtils.isEmpty(redisCache.get())){//缓存中有数据
System.out.println("query from db");
List<Dict> dicts1 = this.baseMapper.selectList(null);
redisCache.set(JSONUtil.toJsonStr(dicts1));
return dicts1;
}else{//没有，查db，放到redis中
System.out.println("query from redis");
String s = redisCache.get();
//hutool中的方法转化
List<Dict> lists = JSONUtil.toList(s, Dict.class);
return lists;
}
}10：Redis持久化 (重点)
面试题：redis 持久化方式RDB和AOF
RDB默认开启，不能保证数据不丢失
AOF默认不开启，能保证数据不丢失
mybatis缓存：一级缓存,会话级别，默认开启
二级缓存，工厂级别，默认关闭
为什么要持久化
Redis是基于内存存储数据的，如果Redis服务器宕机，数据就丢失了
持久化：将内存中的数据不定期备份到磁盘中
数据恢复：将磁盘中的数据 加载（恢复）到内存中Redis持久化方案2种
RDB(Redis Databases):内存中的数据集快照写入磁盘，也就是 Snapshot 快照,恢复时是将快照文件直接读到内存里。
AOF(Append Of File):以日志的形式记录每个写操作，当redis重启时，加载aof文件，将修改命令执行一遍。10.1：RDB
RDB持久化方案的特点
Redis会单独fork一个子进程进行持久化工作，该子进程先将数据写入一个临时文件，等待持久化完毕，再将临时文件覆盖替换上此持久化好的文件，整个过程主进程是不会进行任何的IO操作，确保了极高的性能，而且当进行大规模数据恢复的时候RDB性能也非常高. 但是RDB有缺点，没法保证数据不丢失
Redis默认的持久化方案就是rdb
rdb相关配置
#可以通过该配置修改文件名
dbfilename dump.rdb
#指定rdb文件存储的路劲
dir /user/local/redis/data/触发方式
自动触发（满足条件）可配置
#配置rdb数据持久化自动触发的条件
save 900 1
save 300 10
save 60 10000 #rdb默认开启无法关闭手动触发：
- 1.正常关闭redis-server（shutdown，flushdb手动）
- 2.save该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令，直到RDB过程完成为止。 显然该命令对于内存比较大的实例会造成长时间阻塞，这是致命的缺陷。
- 3.bgsave
执行该命令时，Redis会在后台异步进行快照操作，快照同时还可以响应客户端请求。具体操作是Redis进程执行fork操作创建子进程，RDB持久化过程由子进程负责，完成后自动结束。阻塞只发生在fork阶段，一般时间很短。
10.2：AOF
AOF持久化方案的特点
将Redis所有的写操作命令记录下来（读操作不记录），以文件追加的方式存放起来，当Redis重启恢复数据时，将操作日志从头到尾执行一遍，恢复数据
aof默认是关闭的，如果要开启aof必须要配置
appendonly yes
AOF相关配置
#AOF持久化方案默认是关闭，如果要开启，需要如下配置
appendonly yes
#自定义aof日志文件名
appendfilename "appendonly.aof"
#指定aof文件存储目录
dir触发方式
#aof的触发条件
appendfsync always
AOF重写
由于AOF持久化是Redis不断将写命令记录到 AOF 文件中，随着Redis不断的进行，AOF 的文件会越来越大，文件越大，占用服务器内存越大以及 AOF 恢复要求时间越长。为了解决这个问题，Redis新增了重写机制，当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集。可以使用命令 bgrewriteaof 来重新。
10.3：RDB对比AOF
建议:
如果对数据的安全性要求比较高（Redis存储秒杀的订单数据） 必须要开启aof
如果对数据的安全性要求不高（Redis查询缓存） ，可以不开启aof
秒杀： redis分布式锁 定时任务11：Redis集群 (伪集群)
关闭防火墙 systemctl stop firewalld
不随机启动 systemctl disable firewalld
集群配置
1：复制配置文件: cp redis.conf /usr/local/redis/conf/redis.conf
2: 复制出三份 redis7001.conf / redis7002.conf / redis7003.conf
3 :情况文件内容 可以打开后用： 10000dd
主节点配置
7001节点配置 :redis7001.conf
include /usr/local/redis/conf/redis.conf
port 7001
pidfile /var/run/redis7001.pid
dbfilename redis7001.rdb
appendfilename "appendonly7001.aof"7002从节点配置 :redis7002.conf
include /usr/local/redis/conf/redis.conf
port 7002
pidfile /var/run/redis7002.pid
dbfilename redis7002.rdb
appendfilename "appendonly7002.aof"
slaveof 192.168.88.100 7001
# masterauth 1234567003从节点配置 :redis7003.conf
include /usr/local/redis/conf/redis.conf
port 7003
pidfile /var/run/redis7003.pid
dbfilename redis7003.rdb
appendfilename "appendonly7003.aof"
slaveof 192.168.88.100 7001
#masterauth 123456启动集群
[root@root bin]# ./redis-server ../conf/redis7001.conf
[root@root bin]# ./redis-server ../conf/redis7002.conf
[root@root bin]# ./redis-server ../conf/redis7003.conf
[root@root bin]# ps -ef|grep redis
连接的话用：./redis-cli -p 7001 ./redis-cli -p 7002 ./redis-cli -p 7003
root 13195 1 0 10:49 ? 00:00:00 redis-server 192.168.234.131:7001
root 13204 1 0 10:49 ? 00:00:00 redis-server 192.168.234.131:7002
root 13213 1 0 10:49 ? 00:00:00 redis-server 192.168.234.131:7003
先连接再 查看节点状态：info replication12：哨兵模式sentinel
关联图：Redis集群.bmp
哨兵模式介绍
哨兵职责：
监控(Monitoring)：Sentinel 会不断地定期检查你的主服务器和从服务器是否运作正常。
提醒(Notification): 当被监控的某个 Redis 服务器出现问题时， Sentinel 可以通过 API 向管理员或者其他应用程序发送通知。
自动故障迁移(Automaticfailover): 当主服务器不能正常工作时， Sentinel 会开始一次自动故障迁移操作，选举新主
哨兵：是整个集群的入口 ，程序连的时候连的是哨兵哨兵模式配置
在redis下创建文件夹sentinel-conf
1：先启动redis集群
2：三个哨兵就新建3个分别sentinel01.conf 、sentinel02.conf、sentinel03.conf，注意区分端口
bind 0.0.0.0
#哨兵的端口
port 26379
#mymaster自定义
sentinel monitor mymaster 192.168.44.100 7001 1 #一个哨兵认为挂掉就挂掉
#设置redis主节点的访问密码
#sentinel auth-pass mymaster 123456bind 0.0.0.0
#哨兵的端口
port 26380
#mymaster自定义
sentinel monitor mymaster 192.168.88.100 7001 1
#设置redis主节点的访问密码
#sentinel auth-pass mymaster 123456bind 0.0.0.0
#哨兵的端口
port 26381
#mymaster自定义
sentinel monitor mymaster 192.168.88.100 7001 1
#设置redis主节点的访问密码
#sentinel auth-pass mymaster 1234563：启动哨兵,先进入到redis/bin下，./redis-sentinel ../sentinel-conf/sentinel01.conf
redis-sentinel sentinel01.conf
redis-sentinel sentinel02.conf
redis-sentinel sentinel03.conf4：哨兵详细配置项 ，#可以不配
# 哨兵sentinel实例运行的端口 默认26379
port 26379
#以守护进程模式启动
daemonize yes
# 哨兵sentinel的工作目录
dir /tmp
#日志文件名
logfile "sentinel_26379.log"
# sentinel监控的master主机
sentinel monitor mymaster 192.168.1.108 6379 2
# sentinel连接主从密码验证，注意必须为主从设置一样的密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster 1234
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
sentinel down-after-milliseconds mymaster 5000
#在发生failover主备切换时，这个选项指定了最多可以有多少个slave同时对新的master进行同步数据。这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以设为 1 来保证每次只有一个slave处于不能处理命令请求的状态
sentinel parallel-syncs mymaster 1
# 失效转移最大时间设置
sentinel failover-timeout mymaster 180000
#如果设置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
sentinel notification-script mymaster /var/redis/notify.sh
基于springboot
永久关闭防护墙:systemctl disable firewalld.service
spring:
redis:
sentinel:
master: mymaster
nodes:
- 192.168.88.100:26379
- 192.168.88.100:26380
- 192.168.88.100:26381package com.qf;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* <p>title: com.qf</p>
* <p>Company: wendao</p>
* author zhuximing
* date 2021/6/25
* description:
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:app-sentinel.xml"})
public class TestSentinel {
@Autowired
private StringRedisTemplate redisTemplate;
@Test
public void testSentinel(){
redisTemplate.boundValueOps("name").set("rose");
String name = redisTemplate.boundValueOps("name").get();
System.out.println(name);
}
}13：Redis分布式集群
关联图：Redis分布式集群.bmp
分布式集群架构
sentinel弊端：内存的瓶颈
分布式集群搭建
说明:
1：伪集群，一台服务器，启动6个redis服务、通过端口区分（7001~7006）
2：真集群：6个节点或者3个节点
先强杀所有redis进程，把redis/data下的所有数据文件清空 rm -rf ./ *
redis下建 cluster-conf目录
第一步：从源码包复制redis.conf到指定目录
[root@zhuxm01 server]# cp redis-6.0.8/redis.conf/export/server/redis/cluster-conf/
创建6个文件redis7001-7006第二步：分别配置每个redis的配置文件，详细配置如下，注意区分端口
include /usr/local/redis/cluster-conf/redis.conf
port 7001
#redis的进程文件
pidfile /var/run/redis7001.pid
#rdb文件名
dbfilename redis7001.rdb
#aof文件名
appendfilename "appendonly7001.aof"
# 集群
cluster-enabled yes
# 生成的node文件
cluster-config-file nodes7001.conf
#守护进程
daemonize yes
#aof、rdb文件存储目录
dir /usr/local/redis/data/
bind 0.0.0.0#如果redis设置密码，加上如下配置
requirepass "123456"
masterauth "123456"
第三步：启动每个redis服务
[root@root bin]# redis-server /usr/local/redis/redis7001.conf
[root@root bin]# redis-server /usr/local/redis/redis7002.conf
[root@root bin]# redis-server /usr/local/redis/redis7003.conf
[root@root bin]# redis-server /usr/local/redis/redis7004.conf
[root@root bin]# redis-server /usr/local/redis/redis7005.conf
[root@root bin]# redis-server /usr/local/redis/redis7006.conf
[root@root bin]# ps -ef|grep redis
root 11186 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7001 [cluster]
root 11195 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7002 [cluster]
root 11203 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7003 [cluster]
root 11212 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7004 [cluster]
root 11220 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7005 [cluster]
root 11229 1 0 09:51 ? 00:00:00 redis-server 192.168.234.131:7006 [cluster]
root 11240 7691 0 09:52 pts/0 00:00:00 grep --color=auto redis
[root@zhuxm01 redis]#第四步：创建集群
在redis/bin下执行
./redis-cli --cluster create 192.168.88.100:7001 \
192.168.88.100:7002 \
192.168.88.100:7003 \
192.168.88.100:7004 \
192.168.88.100:7005 \
192.168.88.100:7006 \
--cluster-replicas 1
# (每个主节点有一个从节点)>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 192.168.234.131:7005 to 192.168.234.131:7001
Adding replica 192.168.234.131:7006 to 192.168.234.131:7002
Adding replica 192.168.234.131:7004 to 192.168.234.131:7003
>>> Trying to optimize slaves allocation for anti-affinity
[WARNING] Some slaves are in the same host as their master
M: 7e88abdfa256140ab11dc3c2173b00c5868a0479 192.168.234.131:7001
slots:[0-5460] (5461 slots) master
M: e5845e3494d58b5400fa21d4b3c34ccafce43024 192.168.234.131:7002
slots:[5461-10922] (5462 slots) master
M: 5dbec321866665aceb8ae0c6791e2ded39464368 192.168.234.131:7003
slots:[10923-16383] (5461 slots) master
S: 8ad824d12b9f1a16a75e227266e9940aa8610422 192.168.234.131:7004
replicates 5dbec321866665aceb8ae0c6791e2ded39464368
S: 8ca84b32509e178181585206eaa736c6323dbd3a 192.168.234.131:7005
replicates 7e88abdfa256140ab11dc3c2173b00c5868a0479
S: 7a518a28534593c44694215e3a83b3311704e4d4 192.168.234.131:7006
replicates e5845e3494d58b5400fa21d4b3c34ccafce43024
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster第五步：连接集群
./redis-cli -p 7002 -c
补充：观察节点详情 ，先通过客户端连接, info replication补充：经常使用 netstat -nltp，查看端口情况！！！
分布式集群(java客户端连接)
基于springboot
spring:
redis:
cluster:
nodes:
- 192.168.30.128:7001
- 192.168.30.128:7002
- 192.168.30.128:7003
- 192.168.30.128:7004
- 192.168.30.128:7005
- 192.168.30.128:700614：Redis缓存三类问题 !!!重点
14.1：缓存击穿
面试题： 热点key失效，持续的高并发访问击破redis缓存，直接访问数据库
解决方案：线程同步 单体项目用 synchronize或者redis 分布式锁 setIfAbsent()
某一个热点key，在失效的一瞬间，持续的高并发访问击破缓存直接访问数据库，导致数据库的周期性压力（极端情况下导致数据库宕机）
缓存击穿演示
jmeter :压力测试工具，可以演示高并发场景
创建测试计划
创建线程组
创建http请求
监听http请求的结果
开始压力测试
缓存击穿解决办法:
加锁(分布式锁)，两次判断
public List<Dict> getAllDicts() {
BoundValueOperations<String, String> redisCache = stringRedisTemplate.boundValueOps("dicts666");
if(StringUtils.isEmpty(redisCache.get())){//查数据
synchronized (this){ //this当前对象 spring的bean默认的声明单例singleton,prototype
if(StringUtils.isEmpty(redisCache.get())) {//查数据
System.out.println("query from db");
List<Dict> dicts1 = this.baseMapper.selectList(null);
redisCache.set(JSONUtil.toJsonStr(dicts1));
return dicts1;
}else{
System.out.println("query from redis");
String s = redisCache.get();
//hutool中的方法转化
List<Dict> lists = JSONUtil.toList(s, Dict.class);
return lists;
}
}
}else{//查redis
System.out.println("query from redis");
String s = redisCache.get();
//hutool中的方法转化
List<Dict> lists = JSONUtil.toList(s, Dict.class);
return lists;
}
}14.2：缓存穿透
缓存穿透：热点数据在缓存和数据库中不存在，缓存和数据库都无法命中，每次请求压力都会到数据
请求的某个热点数据、数据库并不存在，缓存也无法命中，请求都会到数据源，从而可能压垮数据源
数据库中没有，同时Redis中也没有
方案1：缓存空值
不能根本上解决缓存穿透的问题（key变化，还是要去查db，导致redis中会大量的无用数据）
方案2：布隆过滤器
（有没有的问题）
@Configuration
public class MyBloomFilter {
@Autowired
DictMapper dictMapper;
@Bean
public RBloomFilter getRedissonClient(){
Config config = new Config();
config.useSingleServer().setAddress("redis://192.168.88.100:6379");
RedissonClient redissonClient = Redisson.create(config);
RBloomFilter<Object> bloomdicts = redissonClient.getBloomFilter("dicts");
//向布隆过滤器中放值，放 数据库中的值
List<Dict> dicts1 = dictMapper.selectList(null);
bloomdicts.tryInit(100000000L,0.03);
dicts1.forEach(dict -> {
bloomdicts.add(dict.getDictcode());
});
return bloomdicts;
}
}@Override
public String getDictValueByCode(String code) {
BoundValueOperations<String, String> redisCache = stringRedisTemplate.boundValueOps(code);
if(StringUtils.isEmpty(redisCache.get())){//查数据
if(rBloomFilter.contains(code)){
System.out.println("query from db");
QueryWrapper<Dict> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("dictcode",code);
Dict dict = this.baseMapper.selectOne(queryWrapper);
if(dict!=null){
redisCache.set(dict.getDictvalue());
return dict.getDictvalue();
}
}
System.out.println("BloomFilter work");
return null;
}else{//查redis
System.out.println("query from redis");
String dictvalue = redisCache.get();
return dictvalue;
}
}14.3：缓存雪崩
当redis服务器重启或者大量缓存集中在某一个时间段失效,即使不是高并发、访问量大，导致数据库访问压力大
解决方案
让过期时间平均分布 过期时间=预设置的过期时间+随机数
15：面试题
15.1：Redis内存满了怎么办？
面试题: Redis内存满了，怎么处理？
加内存，修改maxmemory
1、通过配置文件配置
通过在Redis安装目录下面的redis.conf配置文件中添加以下配置设置内存大小，永久性生效
//设置Redis最大占用内存大小为100M
maxmemory 100mb2、通过命令修改
Redis支持运行时通过命令动态修改内存大小 ，临时性的，重启后失效
//设置Redis最大占用内存大小为100M
127.0.0.1:6379> config set maxmemory 100mb
//获取设置的Redis能使用的最大内存大小
127.0.0.1:6379> config get maxmemory如果不设置最大内存大小或者设置最大内存大小为0，在64位操作系统下不限制内存大小，在32位操作系统下最多使用3GB内存
Redis的内存淘汰
lRU:最近最少访问
既然可以设置Redis最大占用内存大小，那么配置的内存就有用完的时候。那在内存用完的时候，还继续往Redis里面添加数据不就没内存可用了吗？
实际上Redis定义了几种策略用来处理这种情况：
- noeviction(默认策略)：对于写请求不再提供服务，直接返回错误（DEL请求和部分特殊请求除外）!!!
- allkeys-lru：从所有key中使用LRU算法进行淘汰,LRU(Least Recently Used) !!!
- volatile-lru：从设置了过期时间的key中使用LRU算法进行淘汰,LRU(Least Recently Used) !!!
- allkeys-random：从所有key中随机淘汰数据
- volatile-random：从设置了过期时间的key中随机淘汰
- volatile-ttl：在设置了过期时间的key中，根据key的过期时间进行淘汰，越早过期的越优先被淘汰 !!!
当使用volatile-lru、volatile-random、volatile-ttl这三种策略时，如果没有key可以被淘汰，则和noeviction一样返回错误
如何获取及设置内存淘汰策略
获取当前内存淘汰策略：
127.0.0.1:6379> config get maxmemory-policy通过配置文件设置淘汰策略（修改redis.conf文件）：
maxmemory-policy allkeys-lru通过命令修改淘汰策略：
127.0.0.1:6379> config set maxmemory-policy allkeys-lru15.2：为什么删除数据后，Redis内存占用依然很高？
为什么会出现碎片，内存默认分配策略是jemalloc，固定大小
怎么查看内存碎片，info memory
清理内存碎片，activedefrag
1.什么是内存碎片？
内存碎片这个概念应该不是第一听说了，熟悉JVM或者操作系统的应该都熟悉，以火车卖票为例，一个车厢128个车位，由于高峰期，只剩余两个位置了，但是此时三个人想要坐在一起，能够吹吹牛批，喝喝酒的，那么这三个人肯定不会买这节车厢的两个位置了，此时这两个位置可以称之为座位碎片 。
2.为什么会出现内存碎片
Redis提供了多种的内存分配策略，比如libc、jemalloc、tcmalloc，默认使用jemalloc。
jemalloc这种分配策略并不是按需分配，而是固定大小分配，比如8字节、32字节....2KB、4KB等 !!!
3.如何判断存在内存碎片？
这个对于运维人员来说很重要，一旦出现Redis运行缓慢或者阻塞了，一定需要先判断内存的占用情况，而不是重启Redis。
INFO memory !!!
# Memory
used_memory:1073741736 #实际使用的内存大小
used_memory_human:1024.00M #人类有好的方式
used_memory_rss:1997159792 #操作系统实际内存分配
used_memory_rss_human:1.86G
…
mem_fragmentation_ratio:1.86 ##碎片率
mem_fragmentation_ratio这个指标很清楚的展示了当前内存的碎片率，比如Redis申请了1000字节，但是操作系统实际分配的内存1800个字节，则mem_fragmentation_ratio=1800/1000=1.84.如何清理内存碎片？
Redis提供了参数配置，可以控制清除内存碎片的时机，命令如下：
config set activedefrag yes以上命令启动自动清理，但是具体什么时候清理，还要受以下两个参数的影响：
active-defrag-ignore-bytes 400mb：如果内存碎片达到了400mb，开始清理（自定义）active-defrag-threshold-lower 20：内存碎片空间占操作系统分配给 Redis 的总空间比例达到20%时，开始清理（自定义）
15.3：Redis6的新特性
redis 主线程只有一个，不存在线程并发问题
清楚Redis6支持多线程 多线程并不是指的主线程，io线程数
Redis 6.0 新特性-多线程
1：严格来讲从Redis4.0之后并不是单线程，除了主线程外，它也有后台线程在处理一些较为缓慢的操作，例如清理脏数据、无用连接的释放、大 key 的删除等等
2：Redis多线程主要解决网络IO瓶颈，并不是解决CPU瓶颈
从上面的实现机制可以看出，Redis的多线程部分只是用来处理网络数据的读写和协议解析，执行命令仍然是单线程顺序执行。所以我们不需要去考虑控制并发及线程安全问题。3.Redis6.0默认是否开启了多线程？
Redis6.0的多线程默认是禁用的，只使用主线程。如需开启需要修改redis.conf配置文件：
io-threads-do-reads yes 
4.Redis6.0多线程开启时，线程数如何设置？
开启多线程后，还需要设置线程数，否则是不生效的。同样修改redis.conf配置文件 
关于线程数的设置，官方有一个建议：4核的机器建议设置为2或3个线程，8核的建议设置为6个线程，线程数一定要小于机器核数。还需要注意的是，线程数并不是越大越好，官方认为超过了8个基本就没什么意义了。
redis6新特性-acl
acl: 创建用户，设置用户权限
Redis6之前Redis就只有一个用户(default)权限最高，通过配置文件的requirepass配置
Redis6版本推出了ACL(Access Control List)访问控制权限的功能，基于此功能，我们可以设置多个用户，为了保证向下兼容，Redis6保留了default用户和使用requirepass的方式给default用户设置密码，默认情况下default用户拥有Redis最大权限，我们使用redis-cli连接时如果没有指定用户名，用户也是默认default
ACL常用命令
ACL whoami
ACL list
ACL setuser allen on >123456 ~* +@all
AUTH allen mypasswd
#只能创建以lakers为前缀的key
ACL setuser james on >123456 ~lakers* +@all
#不拥有set权限
ACL setuser james -SET
ACL DELUSER james15.4：面试题
Redis：基于内存的非关系型数据库
关系型数据库:Mysql Oracle DB2 SqlServer (标准的Sql )
非关系型数据库：Redis MQ ES
常用命令: flushdb/ flushall / keys * (查看当前库key)/exists key / expire key seconds
redis常用的数据类型： string list set zset hash
Redis事务在编译时有效，运行时无效
redis: multi / exec /discard
mysql: begin transaction/ commit/ rollback
Hutool发http请求（HttpUtil)
json串转bean toBean()
json串转List toList()
bean/list转json串 toJsonStr()
redis持久化方案: RDB 和 AOF
RDB：自动触发 多少秒后多少key变化，自动触发
手动触发 flushdb shutdown save bgsave
RDB方案无法保证数据的不丢失
AOF： 能保证数据的不丢失 ,默认是关闭的 （存储方式设置:always）
如何避免redis中key过量的问题?
1)用hash 、list 、set、zset数据类型
2)给key设置过期时间
3)分布式集群
redis哨兵模式监控主节点是否处于离线状态，如是则会从从节点中投票产生出新的主节点，从而保证集群的高可用性
redis缓存的三类问题：
缓存击穿：缓存中没有，数据库中有 ，解决方案加线程锁
缓存穿透： 缓存中没有，数据库中没有 ，解决方案布隆过滤器
缓存雪崩：大量key集中失效 ，解决方案让过期时间平均分布
如何设置, maxmemory-policy
内存占用过高:
1)调最大内存大小 maxmemory
**2）设置淘汰策略 maxmemory-policy **
常用淘汰策略:noeviction、allkeys-lru、volatile-lru、volatile-ttl
3)清理内存碎片
内存碎片：
为什么会出现碎片，内存默认分配策略是jemalloc，固定大小