4.5 SECURITY安全
4.5.1 设置密码
访问密码的查看、设置和取消
在命令中设置密码，只是临时的。重启redis服务器，密码就还原了。
永久设置，需要再配置文件中进行设置。
4.6 LIMITS限制
4.6.1 maxclients
- 设置redis同时可以与多少个客户端进行连接。
- 默认情况下为10000个客户端。
- 如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应。
4.6.2 maxmemory
建议必须设置，否则，将内存占满，造成服务器宕机
设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。
如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。
但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素。
4.6.3 maxmemory-policy
- volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）
- allkeys-lru：在所有集合key中，使用LRU算法移除key
- volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键
- allkeys-random：在所有集合key中，移除随机的key
- volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key
- noeviction：不进行移除。针对写操作，只是返回错误信息
五、Redis的发布和订阅
============================================================================
Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。
Redis 客户端可以订阅任意数量的频道。
客户端可以订阅频道如下图
当给这个频道发布消息后，消息就会发送给订阅的客户端
5.1 测试
打开一个客户端订阅channel1
SUBSCRIBE channel1
打开另一个客户端，给channel1发布消息hello
返回的1是订阅者数量
打开第一个客户端可以看到发送的消息
注：发布的消息没有持久化，如果在订阅的客户端收不到hello，只能收到订阅后发布的消息
六、Redis新数据类型
===========================================================================
6.1 Bitmaps
现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位， 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011，如下图
合理地使用操作位能够有效地提高内存使用率和开发效率。
Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：
（1） Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。
（2） Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。
6.1.1 命令
setbit
（1）格式
setbit设置Bitmaps中某个偏移量的值（0或1）
*offset:偏移量从0开始
（2）实例
每个独立用户是否访问过网站存放在Bitmaps中， 将访问的用户记做1， 没有访问的用户记做0， 用偏移量作为用户的id。
设置键的第offset个位的值（从0算起） ， 假设现在有20个用户，userid=1， 6， 11， 15， 19的用户对网站进行了访问， 那么当前Bitmaps初始化结果如图
unique:users:20201106代表2020-11-06这天的独立访问用户的Bitmaps
注：
很多应用的用户id以一个指定数字（例如10000） 开头， 直接将用户id和Bitmaps的偏移量对应势必会造成一定的浪费， 通常的做法是每次做setbit操作时将用户id减去这个指定数字。
在第一次初始化Bitmaps时， 假如偏移量非常大， 那么整个初始化过程执行会比较慢， 可能会造成Redis的阻塞。
2、getbit
（1）格式
getbit<key><offset>获取Bitmaps中某个偏移量的值
获取键的第offset位的值（从0开始算）
（2）实例
获取id=8的用户是否在2020-11-06这天访问过， 返回0说明没有访问过：
注：因为100根本不存在，所以也是返回0
3、bitcount
统计字符串被设置为1的bit数。一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。start 和 end 参数的设置，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，start、end 是指bit组的字节的下标数，二者皆包含。
（1）格式
bitcount<key>[start end] 统计字符串从start字节到end字节比特值为1的数量
（2）实例
计算2022-11-06这天的独立访问用户数量
start和end代表起始和结束字节数， 下面操作计算用户id在第1个字节到第3个字节之间的独立访问用户数， 对应的用户id是11， 15， 19。
6.2 HyperLogLog
在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。
但像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。
解决基数问题有很多种方案：
（1）数据存储在MySQL表中，使用distinct count计算不重复个数
（2）使用Redis提供的hash、set、bitmaps等数据结构来处理
以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。
什么是基数?
比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。
6.2.1 命令
1、pfadd
（1）格式
pfadd <key>< element> [element ...] 添加指定元素到 HyperLogLog 中
（2）实例
将所有元素添加到指定HyperLogLog数据结构中。如果执行命令后HLL估计的近似基数发生变化，则返回1，否则返回0。
2、pfcount
（1）格式
pfcount<key> [key ...] 计算HLL的近似基数，可以计算多个HLL，比如用HLL存储每天的UV，计算一周的UV可以使用7天的UV合并计算即可
（2）实例
3、pfmerge
（1）格式
pfmerge<destkey><sourcekey> [sourcekey ...] 将一个或多个HLL合并后的结果存储在另一个HLL中，比如每月活跃用户可以使用每天的活跃用户来合并计算可得
七、Jedis测试
========================================================================
7.1 导包
redis.clients
jedis
3.3.0
7.2 各种测试
package com.caq.jedis;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.Set;
public class JedisDemo1 {
public static void main(String[] args) {
//创建jedis对象
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
//测试
String ping = jedis.ping();
System.out.println(ping);
}
// 操作zset
@Test
public void demo05() {
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
jedis.zadd(“china”,100d,“shanghai”);
Set china = jedis.zrange(“china”, 0, -1);
System.out.println(china);
jedis.close();
}
// 操作hash
@Test
public void demo04() {
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
jedis.hset(“demo04”, “age”, “20”);
String hget = jedis.hget(“demo04”, “age”);
System.out.println(hget);
jedis.close();
}
// 操作set
@Test
public void demo03() {
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
jedis.sadd(“demo03”, “lucy”);
jedis.sadd(“demo03”, “monkey”);
Set name = jedis.smembers(“demo03”);
System.out.println(name);
jedis.close();
}
//操作list
@Test
public void demo02() {
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
jedis.lpush(“demo02”, “lucy”, “jack”, “tom”);
List key1 = jedis.lrange(“demo02”, 0, -1);
System.out.println(key1);
jedis.close();
}
//操作key
@Test
public void demo1() {
//创建redis对象
Jedis jedis = new Jedis(“172.20.10.9”, 6379);
// Set keys = jedis.keys(“*”);
// keys.forEach(x-> System.out.println(x));
// 添加
// jedis.set(“name”,“jack”);
// String name = jedis.get(“name”);
// 添加多个key
jedis.mset(“k1”, “v1”, “k2”, “v2”);
List mget = jedis.mget(“k1”, “k2”);
System.out.println(mget);
jedis.close();
}
}
7.3 连接Redis注意事项
禁用Linux的防火墙：Linux(CentOS7)里执行命令
systemctl stop/disable firewalld.service
redis.conf中注释掉bind 127.0.0.1 ,然后 protected-mode no
7.4 手机验证码实例
要求：
1、输入手机号，点击发送后随机生成6位数字码，2分钟有效
2、输入验证码，点击验证，返回成功或失败
3、每个手机号每天只能输入3次
package com.caq.jedis;
import redis.clients.jedis.Jedis;
import java.util.Random;
public class PhoneCode {
public static void main(String[] args) {
//模拟验证码发送
// verifyCode(“342352132”);
//校验
getRedisCode(“342352132”, “833731”);
}
//1 生成6位数字验证码
public static String getCode() {
Random random = new Random();
String code = “”;
for (int i = 0; i < 6; i++) {
int rand = random.nextInt(10);
code += rand;
}
return code;
}
//2 每个手机每天只能发送三次，验证码放到redis中，设置超时时间
public static void verifyCode(String phone) {
// 连接redis
Jedis jedis = new Jedis(“10.216.54.73”, 6379);
// 拼接key
// 手机发送次数key
String countKey = “VerityCode” + phone + “:count”;
// 验证码key
String codeKey = “VerityCode” + phone + “:code”;
// 每个手机每天只能发送三次
String count = jedis.get(countKey);
if (count == null) {
// 没有发送次数，第一次发送
// 设置发送次数是1
jedis.setex(countKey, 24 * 60 * 60, “1”);
} else if (Integer.parseInt(count) <= 2) {
// 发送次数+1
jedis.incr(countKey);
} else if (Integer.parseInt(count) > 2) {
// 发送三次，不能再发送
System.out.println(“今天发送次数已经超过三次”);
jedis.close();
return;
}
//发送验证码放到redis里面
String vcode = getCode();
jedis.setex(codeKey, 120, vcode);
jedis.close();
}
// 3 验证码校验
public static void getRedisCode(String phone, String code) {
//从redis获取验证码
Jedis jedis = new Jedis(“10.216.54.73”, 6379);
//验证码key
String codeKey = “VerityCode” + phone + “:code”;
String redisCode = jedis.get(codeKey);
//判断
if (redisCode.equals(code)) {
System.out.println(“success”);
} else {
System.out.println(“fail”);
}
jedis.close();
}
}
八、 Redis与Spring Boot整合
=====================================================================================
8.1 引入依赖
org.springframework.boot
spring-boot-starter-data-redis
org.apache.commons
commons-pool2
com.fasterxml.jackson.core
jackson-databind
2.13.1
8.2 配置文件
spring:
redis:
#Redis服务器地址
host: 10.216.54.73
#Redis服务器连接端口
port: 6379
#Redis数据库索引（默认为0）
database: 0
#连接超时时间（毫秒）
timeout: 1800000
lettuce:
pool:
#连接池最大连接数（使用负值表示没有限制）
max-active: 20
#最大阻塞等待时间(负数表示没限制)
max-wait: -1
#最大阻塞等待时间(负数表示没限制)
max-idle: 5
#连接池中的最小空闲连接
min-idle: 0
8.3 测试
package com.caq.boot.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 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 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;
}
}
RedisTestController中添加测试方法
package com.caq.boot.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;
}
}九、Redis事务
========================================================================
涉及到很多秒杀相关的实例，这里只做简单的介绍
Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
Redis事务的主要作用就是串联多个命令防止别的命令插队。
9.1 Multi、Exec、discard
从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
组队的过程中可以通过discard来放弃组队。
组队成功，提交成功
组队阶段报错，提交失败
组队成功，提交有成功有失败情况
9.2 事务的错误处理
组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。
如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。
9.3 乐观锁和悲观锁
乐观锁和悲观锁是两种思想，用于解决并发场景下的数据竞争问题。
- 乐观锁：乐观锁在操作数据时非常乐观，认为别人不会同时修改数据。因此乐观锁不会上锁，只是在执行更新的时候判断一下在此期间别人是否修改了数据：如果别人修改了数据则放弃操作，否则执行操作。
- 悲观锁：悲观锁在操作数据时比较悲观，认为别人会同时修改数据。因此操作数据时直接把数据锁住，直到操作完成后才会释放锁；上锁期间其他人不能修改数据。
十、Redis持久化
=========================================================================
Redis 提供了2个不同形式的持久化方式。
- RDB（Redis DataBase）
- AOF（Append Of File）
10.1 RDB
在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里
10.2 备份是如何执行的
Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。
10.3 AOF（Append Only File）
以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis 重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
十一、Redis主从
=========================================================================
主机数据更新后根据配置和策略， 自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主
优点：
- 读写分离，性能扩展
- 容灾快速恢复
11.1 部署流程
拷贝多个redis.conf文件include(写绝对路径)
开启daemonize yes
Pid文件名字pidfile
指定端口port
Log文件名字
dump.rdb名字dbfilename
Appendonly 关掉或者换名字
配从(库)不配主(库)
slaveof <ip><port>
成为某个实例的从服务器
1、在6380和6381上执行: slaveof 127.0.0.1 6379
2、在主机上写，在从机上可以读取数据
在从机上写数据报错
3、主机挂掉，重启就行，一切如初
4、从机重启需重设：slaveof 127.0.0.1 6379
可以将配置增加到文件中。永久生效。
11.2 复制原理
- Slave启动成功连接到master后会发送一个sync命令
- Master接到命令启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令， 在后台进程执行完毕之后，master将传送整个数据文件到slave,以完成一次完全同步
- 全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
- 增量复制：Master继续将新的所有收集到的修改命令依次传给slave,完成同步
- 但是只要是重新连接master,一次完全同步（全量复制)将被自动执行
11.3 哨兵模式(sentinel)
能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库
11.3.1 初始环境
11.3.2 部署
自定义的/myredis目录下新建sentinel.conf文件，名字绝不能错
sentinel monitor mymaster 127.0.0.1 6379 1
其中mymaster为监控对象起的服务器名称， 1 为至少有多少个哨兵同意迁移的数量。
11.3.3 启动哨兵
/usr/local/bin
redis做压测可以用自带的redis-benchmark工具
执行redis-sentinel /myredis/sentinel.conf
当主机挂掉，从机选举中产生新的主机
(大概10秒左右可以看到哨兵窗口日志，切换了新的主机)
哪个从机会被选举为主机呢？根据优先级别：slave-priority
原主机重启后会变为从机。
十二、Redis集群
=========================================================================
12.1 出现的问题
容量不够，redis如何进行扩容？
并发写操作， redis如何分摊？
之前通过代理主机来解决，但是redis3.0中提供了解决方案。就是无中心化集群配置。
12.2 初始化环境
我们在一台虚拟机上模拟多台redis服务器，通过模拟端口的形式来进行
制作6个实例，6379,6380,6381,6389,6390,6391
cluster-enabled yes 打开集群模式
cluster-config-file nodes-6379.conf 设定节点配置文件名
cluster-node-timeout 15000 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换。
include /home/bigdata/redis.conf
port 6379
pidfile “/var/run/redis_6379.pid”
dbfilename “dump6379.rdb”
dir “/home/bigdata/redis_cluster”
logfile “/home/bigdata/redis_cluster/redis_err_6379.log”
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000修改好redis6379.conf文件，拷贝多个redis.conf文件
修改好redis6379.conf文件，拷贝多个redis.conf文件
