数据库-Redis

1 Redis-高性能

Redis 是完全开源免费的，遵守 BSD 协议，是一个高性能的 key-value 数据库。
6.0之前都是单线程，6.0之后网络io操作引入了多线程，内存读写是单线程。
为什么使用redis连接池?因为创建连接比较耗时，最好连接能够重复使用
连接池设计时候都会用到享元模式

1.1背景

背景：在外部增加分布式缓存，缓存热门数据。也就是通过缓存能把绝大多数请求在读写数据库前拦截掉，大大降低数据库压力，同时提高数据的响应数据

网络请求到后端首先去Tomcat本地缓存(以及缓存)查找数据，如果没有查找到就到分布式缓存(二级缓存)中查找。

1.2 Redis 操作

启动redis
sudo docker run -p 6379:6379 --name redis01
-v /usr/local/docker/redis01/data:/data
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf
-d redis redis-server /etc/redis/redis.conf

1. [root@hadoop105 ~]# docker exec -it redis01 redis-cli --利用docker启动redis服务
2. redis-server -v 查看服务版本
3. redis-cli -v 查看客户端版本
4. redis-cli -p 6379 -a password #-a后面为password,此操作需要开启redis.conf文件中的 requirepass选项
5. redis-cli -h ip -p 6379 -a password --登录远端redis服务器
6. keys * —查看所有的key
7. set key value --基于key/value形式存储数据
8. select (0-15) --切换数据库
9. flushdb --清除当前数据库
10. flushall – 清除全部数据库数据
11. Expire key (设置生效时长-单位秒)
12. pexpire （单位毫秒）
13. Persist (取消时长设置)

1.3 Redis 数据类型

1.3.1String类型操作实践

字符串类型是redis中最简单的数据类型，它存储的值可以是字符串，其最大字符串长度支持到512M。基于此类型，可以实现博客的字数统计，将日志不断追加到指定key，实现一个分布式自增iid，实现一个博客的的点赞操作等
字符串类型是redis中最简单的数据类型，它存储的值可以是字符串，其最大字符串长度支持到512M。基于此类型，可以实现博客的字数统计，将日志不断追加到指定key，实现一个分布式自增iid，实现一个博客的的点赞操作等
博客的字数统计如何实现？（strlen）

1. incr --自增/incrby按步长自增 可用使用incr做分布式id
2. decr --自减/decrby按步长自减
3. append --追加
4. strlen–长度
5. mset/mget–赋值/获取多个。
   如何将审计日志不断追加到指定key?(append)
   你如何实现一个分布式自增id？(incr-雪花算法)
   如何实现一个博客的的点赞操作？(incr,decr)

1.3.2 Hash类型

Redis散列类型相当于Java中的HashMap，实现原理跟HashMap一致,一般用于存储对象信息，存储了字段（field）和字段值的映射，一个散列类型可以包含最多232-1个字段。
1、hset user username xiaoming age 13 赋值
2、hget user 取值
3、hmset 设置对象多个属性
4、hmget 获取对象多个属性
5、hexists 判断属性是否存在
6、hdel 删除属性
7、hkeys 只获取字段名
8、hvals 只获取val值
发布一篇博客需要写内存吗？（需要,hmset）
浏览博客内容会怎么做？（hmget）
如何判定一篇博客是否存在？(hexists)
删除一篇博客如何实现？(hdel)
分布式系统中你登录成功以后是如何存储用户信息的？(hmset)

1.3.3 List数据类型

Redis的list类型相当于java中的LinkedList，其原理就就是一个双向链表。支持正向、反向查找和遍历等操作，插入删除速度比较快。经常用于实现热销榜，最新评论等的设计。
1、lpush–在可以对应list头部添加
2、rpush–在key对应list的尾部添加
3、lpop–从list的头部删除元素，并返回删除元素
4、rpop --从list的尾部删除元素，并返回删除元素
3、del --删除列表
5、linsert --在key对应list的特定位置之前或之后添加字符串元素
6、lset --在指定下标处插入元素
7、lrem --从key对应list中删除count个和value相同的元素，count>0时，按从头到尾的顺序删除
8、ltrim --保留指定key 的值范围内的数据
9、llen --返回key对应list的长度
10、lindex --返回指定下标的元素
11、rpoplpush—从第一个list的尾部移除元素并添加到第二个list的头部,最后返回被移除的元素值，整个操作是原子的.如果第一个list是空或者不存在返回nil：
如何基于redis实现一个队列结构？（lpush/rpop）
如何基于redis实现一个栈结构？(lpush/lpop)
如何基于redis实现一个阻塞式队列？(lpush/brpop)
如何实现秒杀活动的公平性？(先进先出-FIFO)
通过list结构实现一个消息队列(顺序)吗？（可以，FIFO->lpush,rpop）
用户注册时的邮件发送功能如何提高其效率？(邮件发送是要调用三方服务，底层通过队列优化其效率，队列一般是list结构)
如何动态更新商品的销量列表？(卖的好的排名靠前一些，linsert)
商家的粉丝列表使用什么结构实现呢？(list结构)

1.3.4 set数据类型

Redis的Set类似Java中的HashSet，是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。Redis中Set集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
1、sadd --添加元素，重复元素添加失败，返回0
2、smembers --获取内容
3、spop --移除并返回集合中
4、scard --获取成员个数
5、smove --移动一个元素到另外一个集合
6、sunion --求两个集合的并集
7、serm --删除元素
朋友圈的点赞功能你如何实现？（sadd,srem,smembers,scard）
如何实现一个网站投票统计程序?
你知道微博中的关注如何实现吗？

2 Jedis方式连接redis

2.1 Redis连接池

享元模式：设计思想，通过池减少对象的创建次数，实现对象的可重用性，所有
池都有这个设计模式的应用(例如整数池，字符串池，线程池，连接池)。

1. Slf4f门面模式
2. RestTemplate模板模式
3. Riboon策略设计模式
4. 双重校验（单例模式）
5. xxxxAdapter适配器模式
6. Singleton单例模式
7. AOP代理模式
8. Interceptor责任链模式

volatile关键字保证了可见性但不保证原子性。
Volatile关键字描述属性的时候有什么作用？多线程下保证了共享变量的可见性，禁止指令
重排序，不保证原子性。

2.2 分布式id

背景：在分布式系统中，数据量将越来越大时(行数500W)单表容量超过2G，就需要对数据进行分表操作,但是,分表后，每个表中的数据都会按自己的节奏进行自增，很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID，生成出来的ID也可以叫做 分布式ID
分表规则：时间戳，id

execute(runnable)会把我们的线程放在一个阻塞队列中。

2.3 分布式锁

2.4 Redis单点登录实现

1）用户登录成功后将登录状态存储到redis中，把token返回给用户
2）用户携带token去访问资源，资源服务器要基于token从redis中查询用户信息
用户信息使用hash存储。token作为key

3 Redis在SpringBoot工程中应用

3.1 RedisTemplate应用(序列化与反序列化)

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

RedisTimplate 是StringRedisTemplate的父类类型，
默认采用JDK的序列化与反序列化的存取方式。
定制序列化与反序列化
对于系统默认的RedisTemplate默认采用的是JDK的序列化机制，假如我们不希望实用JDK的序列化，可以采用的定制RedisTemplate，并采用自己指定的的序列化方式，

3.2 Redis购物车实现

购物车利用hsh数据结构实现

4 Redis与AOP整合

热点数据需要双写数据库（redis数据库，mysql数据库）查询的时候先去缓存中查询，如果缓存没有的话就去mysql中查找。
注意：当一个接口有两个实现类的时候，注入属性的时候要报错，
1、需要指定在实现类上指定名字，
第一步：添加访问Mysql数据库的依赖
第二步：修改配置文件，添加数据库连接

4.1 Pojo对象设计与实现

定义一个Menu对象，用于实现与数据库表中的字段映射

4.2 Mapper逻辑设计与实现

功能：提供数据访问服务-访问mysql

4.3 Server逻辑设计与实现

功能：实现在操作mysql数据时候，同时对redis缓存数据做数据同步操作。
由此注解描述的方法为切入点方法,此方法执行时,底层会通过AOP机制
先从缓存取数据,缓存有则直接返回,缓存没有则查数据,最后将查询的数据
还会向redis存储一份
写缓存：@Cacheable(value = “menuCache”,key="#id")
查对象：@CachePut(value = “hello”,key = “#menu.id”)

4.5 redis对象序列化定制

在配置类里：继承CachingConfigurerSupport重写cacheManager方法
改变AOP方式中redis中redis数据存储是的序列化方式，其实现上要借助CatcheManager对象

@Configuration
public class CachingConfig /*extends CachingConfigurerSupport*/ {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public CacheManager redisCacheManager() {
        RedisCacheConfiguration cacheConfig=
                RedisCacheConfiguration.defaultCacheConfig()
        //定义key的序列化方式
        .serializeKeysWith(
                RedisSerializationContext.
                   SerializationPair.fromSerializer(RedisSerializer.string()))
        //定义value的序列化方式
        .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                .fromSerializer(RedisSerializer.json()));

        return  RedisCacheManager.builder(redisConnectionFactory)
               .cacheDefaults(cacheConfig)
               .transactionAware()
               .build();
    }

缓存穿透：redis数据库中没有数据数据库中有数据
服务器端对参数范围校验，设置多级缓存。
缓存雪崩：Key集体失效，前端的QPS全部打在mysql数据库
多级缓存,设置key失效的时间不能相同，设置一个随机的时间。
缓存击穿：redis没有数据库也没有

4 Redis持久化-高可靠

4.1 背景

Redis是一种内存数据库，在断电时数据可能会丢失。比如你redis整个挂了，然后redis不可用了，如果没有持久化的话，redis就会丢失所有的数据，如果通过持久化将数据备份一份儿到磁盘上去，然后再定期同步到一些云存储服务上去，那么就可以保证一些数据不丢失，保证数据的可靠性

4.2 Rdb方式持久化

Rdb方式是通过手动(save-阻塞式，bgsave-异步)或周期性方式保存redis中key/value的一种机制,Rdb方式一般为redis的默认数据持久化方式.系统启动时会自动开启这种方式的持久化机制。
周期性：比如多少时间内有多少个key发生变化就进行持久化。

4.2.1Rdb配置文件

RDB方式的持久化是默认开启的，也可按规则自己配置，例如，打开redis.conf文件，例如

# 这里表示每隔60s，如果有超过1000个key发生了变更，那么就生成一个新的dump.rdb文件，就是当前redis内存中完整的数据快照，这个操作也被称之为snapshotting(快照)。
save 60 1000
# 持久化 rdb文件遇到问题时，主进程是否接受写入，yes 表示停止写入，如果是no 表示redis继续提供服务。
stop-writes-on-bgsave-error yes
# 在进行快照镜像时,是否进行压缩。yes:压缩，但是需要一些cpu的消耗。no:不压缩，需要更多的磁盘空间。
rdbcompression yes
# 一个CRC64的校验就被放在了文件末尾，当存储或者加载rbd文件的时候会有一个10%左右的性能下降，为了达到性能的最大化，你可以关掉这个配置项。
rdbchecksum yes
# 快照的文件名
dbfilename dump.rdb
# 存放快照的目录
dir /var/lib/redis

4.2.2Rdb配置文件

1、shutdown redis时候是一种安全模式的退出
2、kill -9 杀死进程之后，数据可能会丢失
3、手动调用save(同步保存)或者bgsave(异步保存)执行rdb快照生成.然后杀掉redis进程，数据会交给后台进程保存。

3.2.2小结面试

Redis中的save和bgsave有什么不同？
RDB持久化机制有哪些优点？
第一：RDB会生成多个数据文件，每个数据文件都代表了某一个时刻中redis的数据，这种多个数据文件的方式，非常适合做冷备，可以将这种完整的数据文件发送到一些远程云服务上去，在国内可以是阿里云的ODPS分布式存储上，以预定好的备份策略来定期备份redis中的数据.
第二：RDB对redis对外提供的读写服务，影响非常小，可以让redis保持高性能，因为redis主进程只需要fork一个子进程，让子进程执行磁盘IO操作来进行RDB持久化即可。
第三：相对于AOF持久化机制来说，直接基于RDB数据文件来重启和恢复redis进程，更加快速。
RDB存储的是快照。

4.3 aof方式持久化

性能有影响：aof每一秒需要写一次磁盘，比rdb性能影响较大。但恢复数据的时候aof数据丢失最少。
Aof方式是通过记录写操作日志的方式,记录redis数据的一种持久化机制,这个机制默认是关闭的。

4.3.1aof配置文件

# 是否开启AOF，默认关闭
appendonly yes
# 指定 AOF 文件名
appendfilename appendonly.aof
# Redis支持三种刷写模式：
# appendfsync always #每次收到写命令就立即强制写入磁盘，类似MySQL的sync_binlog=1,是最安全的。但该模式下速度也是最慢的，一般不推荐使用。
appendfsync everysec #每秒钟强制写入磁盘一次，在性能和持久化方面做平衡，推荐该方式。
# appendfsync no     #完全依赖OS的写入，一般为30秒左右一次，性能最好但是持久化最没有保证，不推荐。
#在日志重写时，不进行命令追加操作，而只是将其放在缓冲区里，避免与命令的追加造成DISK IO上的冲突。
#设置为yes表示rewrite期间对新写操作不fsync,暂时存在内存中,等rewrite完成后再写入，默认为no，建议yes
no-appendfsync-on-rewrite yes
#当前AOF文件大小是上次日志重写得到AOF文件大小的二倍时，自动启动新的日志重写过程。
auto-aof-rewrite-percentage 100
#当前AOF文件启动新的日志重写过程的最小值，避免刚刚启动Reids时由于文件尺寸较小导致频繁的重写。
auto-aof-rewrite-min-size 64mb

4.3.2aof持久化面试

如何理解AOF方式中的rewrite操作？
redis中的可以存储的数据是有限的，很多数据可能会自动过期，也可能会被用户删除或被redis用缓存清除的算法清理掉。也就是说redis中的数据会不断淘汰掉旧的，只有一部分常用的数据会被自动保留在redis内存中，所以可能很多之前的已经被清理掉的数据，对应的写日志还停留在AOF中，AOF日志文件就一个，会不断的膨胀，最好导致文件很大。
所以,AOF会自动在后台每隔一定时间做rewrite操作，比如日志里已经存放了针对100w数据的写日志了，但redis内存现在10万数据; 于是，基于内存中当前的10万数据构建一套最新的日志，然后到AOF文件中; 覆盖之前的老日志，从而，确保AOF日志文件不会过大，保持跟redis内存数据量一致.

5 Redis事务

事务是一个不可分割的逻辑单元，这个单元由许多操作，这些操作要么都成功，要么都失败。
什么是事务？事务是一个逻辑操作单元，由一组sql
脏读：a读取了B还未提交的数据，最后B回滚了
不可重复读：针对记录 --行锁
幻读：针对字段，—表锁

6 Redis集群-搭建

集群主从架构：为了支持更大的QPS大多数业务都是读多写少。
单个Redis支持的读写能力还是有限的,此时我们可以使用多个redis来提高redis的并发处理能力,这些redis如何协同,就需要有一定的架构设计,这里我们首先从主从(Master/Slave)架构进行分析和实现.

其中,master负责读写,并将数据同步到salve,从节点负责读操作.

6.1 Redis集群搭建-主从复制

1、配置文件中，AOF持久化方式打开。date目录复制三份
2、开启容器

#第一台
docker run -p 6379:6379 --name redis6379 \
-v /usr/local/docker/redis01/data:/data \
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes
#第二台
docker run -p 6380:6379 --name redis6380 \
-v /usr/local/docker/redis02/data:/data \
-v /usr/local/docker/redis02/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes
#第三台
docker run -p 6381:6379 --name redis6381 \
-v /usr/local/docker/redis03/data:/data \
-v /usr/local/docker/redis03/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf \
--appendonly yes

3、 检测redis服务角色
启动三个客户端,分别登陆三台redis容器服务，通过info指令进行角色查看，默认新启动的三个redis服务角色都为master.
info replication
4、检测redis6379的ip设置
docker inspect redis6379
5、设置Master/Slave架构
分别登陆redis6380/redis6381，然后执行如下语句
==slaveof 172.17.0.2(6379的容器) 6379 ==
6、再次登陆redis6379，然后检测info
info replication
测试：mastar读写都可以，slaver：只能读

6.2 主从复制原理

为什么需要主从：一个redis理论最多支持10万但是由于机器限制可能就5到8万并发量。为了处理更高的并发量，需要多个redis提供服务。
主从同步原理分析
Redis的主从结构可以采用一主多从结构，Redis主从复制可以根据是否是全量分为全量同步和增量同步。
数据同步：全量 rdb 增量 aof

• Redis全量同步：
  Redis全量复制一般发生在Slave初始化阶段，这时Slave需要将Master上的所有数据都复制一份。具体步骤如下：
  1）从服务器连接主服务器，发送SYNC命令；
  2）主服务器接收到SYNC命名后，开始执行BGSAVE命令生成RDB文件并使用缓冲区记录此后执行的所有写命令；
  3）主服务器BGSAVE执行完后，向所有从服务器发送快照文件，并在发送期间继续记录被执行的写命令；
  4）从服务器收到快照文件后丢弃所有旧数据，载入收到的快照；
  5）主服务器快照发送完毕后开始向从服务器发送缓冲区中的写命令；
  6）从服务器完成对快照的载入，开始接收命令请求，并执行来自主服务器缓冲区的写命令；
• Redis增量同步
  Redis增量复制是指Slave初始化后，开始正常工作时主服务器发生的写操作同步到从服务器的过程。 增量复制的过程主要是主服务器每执行一个写命令就会向从服务器发送相同的写命令，从服务器接收并执行收到的写命令。

6.3 Redis哨兵模式

• 哨兵模式：监控redis的工作状态，监控主节点是否有宕机，主节点宕机之后选slave节点为主节点。
• master/slaver一旦有节点重启了需要重新配置主从。开启redis默认master所以需要配置主从。
• 为什么需要哨兵？因为当主节点宕机了，需要一个mast节点支持写操作
  哨兵（Sentinel）是Redis的主从架构模式下，实现高可用性（high availability）的一种机制。
  由一个或多个Sentinel实例（instance）组成的Sentinel系统（system）可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器，然后由新的主服务器代替已下线的主服务器继续处理命令请求
  启动哨兵服务：redis-centinel sentinel.conf

6.2.1基本架构

6.2.2 哨兵模式实现

第一步：分别进入3台redis容器内部进行配置，在容器指定目录/etc/redis创建sentinel.conf文件,文件内容为：
sentinel monitor redis6379 172.17.0.2 6379 1
其中, 如上指令表示要的监控的master, redis6379为服务名, 172.17.0.2和6379为master的ip和端口,1表示多少个sentinel认为一个master失效时，master才算真正失效.
第二步：在每个redis容器内部的/etc/redis目录下执行如下指令（最好是在多个客户端窗口执行），启动哨兵服务
redis-sentinel sentinel.conf
第三步：打开一个新的客户端连接窗口，关闭redis6379服务（这个服务是master服务）
docker stop redis6379
其它客户端窗口，检测日志输出，例如
410:X 11 Jul 2021 09:54:27.383 # +switch-master redis6379 172.17.0.2 6379 172.17.0.4 6379
410:X 11 Jul 2021 09:54:27.383 * +slave slave 172.17.0.3:6379 172.17.0.3 6379 @ redis6379 172.17.0.4 6379
410:X 11 Jul 2021 09:54:27.383 * +slave slave 172.17.0.2:6379 172.17.0.2 6379 @ redis6379 172.17.0.4 6379

7 Redis集群-高可用

7.1 背景

Redis单机模式可靠性保证不是很好，容易出现单点故障，同时其性能也受限于CPU的处理能力，实际开发中Redis必然是高可用的，所以单机模式并不是我们的终点，我们需要对目前redis的架构模式进行升级。
Sentinel模式做到了高可用，但是实质还是只有一个master在提供服务(读写分离的情况本质也是master在提供服务)，当master节点所在的机器内存不足以支撑系统的数据时，就需要考虑集群了。
Redis集群架构实现了对redis的水平扩容，即启动N个redis节点，将整个数据分布存储在这N个redis节点中，每个节点存储总数据的1/N。redis集群通过分区提供一定程度的可用性，即使集群中有一部分节点失效或无法进行通讯，集群也可以继续处理命令请求。

7.2 架构

对于redis集群(Cluster),一般最少设置为6个节点,3个master,3个slave,其简易架构如下:

7.3 集群环境搭建

• 第一步：准备网络环境
  创建虚拟网卡，主要是用于redis-cluster能于外界进行网络通信，一般常用桥接模式。
  docker network create redis-net
• 第二步：准备redis配置模板
  mkdir -p /usr/local/docker/redis-cluster
  进入该目录：
  vim redis-cluster.tmpl
  编辑以下内容
  port ${PORT}
  cluster-enabled yes
  cluster-config-file nodes.conf
  cluster-node-timeout 5000
  cluster-announce-ip 192.168.126.129
  cluster-announce-port $PORTcluster-announce-bus-port1${PORT}
  appendonly yes
  其中：
  各节点解释如下所示：
  port：节点端口，即对外提供通信的端口
  cluster-enabled：是否启用集群
  cluster-config-file：集群配置文件
  cluster-node-timeout：连接超时时间
  cluster-announce-ip：宿主机ip
  cluster-announce-port：集群节点映射端口
  cluster-announce-bus-port：集群总线端口
  appendonly：持久化模式
• 第三步：创建节点配置文件
  在redis-cluser中执行以下命令

for port in $(seq 8010 8015); \
do \
  mkdir -p ./${port}/conf  \
  && PORT=${port} envsubst < ./redis-cluster.tmpl > ./${port}/conf/redis.conf \
  && mkdir -p ./${port}/data; \
done

• 第四步：创建集群中的redis节点容器

for port in $(seq 8010 8015); \
do \
   docker run -it -d -p ${port}:${port} -p 1${port}:1${port} \
  --privileged=true -v /usr/local/docker/redis-cluster/${port}/conf/redis.conf:/usr/local/etc/redis/redis.conf \
  --privileged=true -v /usr/local/docker/redis-cluster/${port}/data:/data \
  --restart always --name redis-${port} --net redis-net \
  --sysctl net.core.somaxconn=1024 redis redis-server /usr/local/etc/redis/redis.conf; \
done

第五步：创建集群中的redis节点容器
进入redis :docker exec -it reids bash
redis-cli --cluster create 192.168.10.100:8010 192.168.10.100:8011 192.168.10.100:8012 192.168.10.100:8013 192.168.10.100:8014 192.168.10.100:8015 --cluster-replicas 1
其中, --privileged=true表示让启动的容器用户具备真正root权限, --sysctl net.core.somaxconn=1024 这是一个linux的内核参数,用于设置请求队列大小,默认为128,后续启动redis的启动指令需要先放到这个请求队列中,然后依次启动.
创建成功以后，通过docker ps指令查看节点内容。
只有master上有分配了槽位，可以用来存数据，slaver上没有

cluster nodes #查看集群节点数
cluster info #查看集群基本信息

• 第六步：连接redis-cluster，并添加数据到redis
  redis-cli -c -h 192.168.126.129 -p 8010
  进入redis
  
  

批量停止docker 容器,例如:
docker ps -a | grep -i “redis-801*” | awk ‘{print $1}’ | xargs docker stop

批量删除docker 容器,例如
docker ps -a | grep -i “redis-801*” | awk ‘{print $1}’ | xargs docker rm -f

批量删除文件,目录等,例如:
rm -rf 801{0…5}/conf/redis.conf
rm -rf 801{0…5}

8 Redis面试