全新Redis6全部知识点，零基础入门3

        <!--springCache依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <!--mybatis plus和springboot整合-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>

#配置plus打印sql⽇志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
spring: 
  #数据库连接配置
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/redis_test?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

CREATE TABLE `product` (
 `id` int(11) unsigned NOT NULL
AUTO_INCREMENT,
 `title` varchar(128) DEFAULT NULL COMMENT '标 题',
 `cover_img` varchar(128) DEFAULT NULL COMMENT
'封⾯图',
 `detail` varchar(256) DEFAULT '' COMMENT '详 情',
 `amount` int(10) DEFAULT NULL COMMENT '新价
格',
 `stock` int(11) DEFAULT NULL COMMENT '库存',
 `create_time` datetime DEFAULT NULL COMMENT
'创建时间',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT
CHARSET=utf8mb4;
====================================================
INSERT INTO `product` (`id`, `title`,
`cover_img`, `detail`, `amount`, `stock`,
`create_time`)
VALUES
 (1, 'AlibabaCloud',
'https://file.xdclass.net/video/2020/alibabaclo
ud/zt-alibabacloud.png',
'https://file.xdclass.net/video/2021/60-
MLS/summary.jpeg', 213, 100, '2021-09-12
00:00:00'),
 (2, 'Linux',
'https://file.xdclass.net/video/2020/alibabaclo
ud/zt-alibabacloud.png',
'https://file.xdclass.net/video/2021/59-
Postman/summary.jpeg', 42, 100, '2021-03-12
00:00:00'),
 (3, 'Docker',
'https://file.xdclass.net/video/2020/alibabaclo
ud/zt-alibabacloud.png',
'https://file.xdclass.net/video/2021/60-
MLS/summary.jpeg', 12, 20, '2022-09-22
00:00:00'),
 (4, 'Nginx',
'https://file.xdclass.net/video/2020/alibabaclo
ud/zt-alibabacloud.png',
'https://file.xdclass.net/video/2021/60-
MLS/summary.jpeg', 14, 20, '2022-11-12
00:00:00');

@Data
@TableName("product")
public class ProductDO {
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;
    /**
     * 标题
     */
    private String title;
    /**
     * 封⾯图
     */
    private String coverImg;
    /**
     * 详情
     */
    private String detail;
    /**
     * 新价格
     */
    private Integer amount;
    /**
     * 库存
     */
    private Integer stock;
    /**
     * 创建时间
     */
    private Date createTime;
}

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private ProductMapper productMapper;
    @Override
    public int save(ProductDO productDO) {
        int insert = productMapper.insert(productDO);
        return insert;
    }
    @Override
    public int del(int id) {
        int i = productMapper.deleteById(id);
        return i;
    }
    @Override
    public int update(ProductDO productDO) {
        int i = productMapper.updateById(productDO);
        return i;
    }
    @Override
    public ProductDO findById(int id) {
        return productMapper.selectById(id);
    }
    @Override
    public Map<String, Object> page(int page, int size) {
        Page pageInfo = new Page<>(page,size);
        IPage<ProductDO> iPage = productMapper.selectPage(pageInfo, null);
        Map<String,Object> pageMap = new HashMap<>(3);
        pageMap.put("total_record",iPage.getTotal());
        pageMap.put("total_page",iPage.getPages());
        pageMap.put("current_total",iPage.getRecords());
        return pageMap;
    }
}

@RestController
@RequestMapping("/api/v1/product")
public class ProductController {
    @Autowired
    private ProductService productService;
    @PostMapping("/add")
    public JsonData add(@RequestBody ProductDO productDO){
        int save = productService.save(productDO);
        return JsonData.buildSuccess(save);
    }
    @PostMapping("/update")
    public JsonData update(@RequestBody ProductDO productDO){
        int save = productService.update(productDO);
        return JsonData.buildSuccess(save);
    }
    @GetMapping("/findById")
        public JsonData findById(@RequestParam("product_id") int id){
        ProductDO productDO = productService.findById(id);
        return JsonData.buildSuccess(productDO);
    }
    @DeleteMapping("/del")
    public JsonData del(@RequestParam("product_id") int id){
        int i = productService.del(id);
        return JsonData.buildSuccess(i);
    }
    @GetMapping("/page")
    public JsonData page(@RequestParam("page") int page,@RequestParam("size") int size){
        Map<String, Object> map = productService.page(page, size);
        return JsonData.buildSuccess(map);
    }
}

//对象
@Cacheable(value = {"product"},key="#root.methodName")
//分⻚
@Cacheable(value ={"product_page"},key="#root.methodName +#page+'_'+#size")

/**
     * 修改Redis缓存序列化器和配置manager过期时间
     */
    @Primary
    @Bean
    public RedisCacheManager cacheManager1Hour(RedisConnectionFactory connectionFactory){
        RedisCacheConfiguration config = instanceConfig(3600L);
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).transactionAware().build();
    }
    @Bean
    public RedisCacheManager cacheManager1Day(RedisConnectionFactory connectionFactory){
        RedisCacheConfiguration config = instanceConfig(3600 * 24L);
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).transactionAware().build();
    }
    @Bean
    public RedisCacheManager cacheManager10Min(RedisConnectionFactory connectionFactory){
        RedisCacheConfiguration config = instanceConfig(600L);
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).transactionAware().build();
    }
    /**
     * 序列化机制
     * @param ttl
     * @return
     */
    private RedisCacheConfiguration instanceConfig(Long ttl) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.registerModule(new JavaTimeModule());
        // 去掉各种@JsonSerialize注解的解析
        objectMapper.configure(MapperFeature.USE_ANNOTATIONS, false);
        // 只针对⾮空的值进⾏序列化
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        // 将类型序列化到属性json字符串中
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return
                RedisCacheConfiguration.defaultCacheConfig()
                        .entryTtl(Duration.ofSeconds(ttl))
                        .disableCachingNullValues()
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
    }

    /**
     * keyGenerator自定义key的规则
     */
    @Bean
    public KeyGenerator springCacheDefaultKeyGenerator(){
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return o.getClass().getSimpleName()+":"+method.getName()+":"+ StringUtils.arrayToDelimitedString(objects,":");
            }
        };
    }

@Cacheable(value = {"product"},keyGenerator ="springCacheCustomKeyGenerator", cacheManager ="cacheManager1Minute")

@CachePut(value = {"product"},key = "#productDO.id")//常用于修改的方法上，修改数据库，然后修改对应的缓存

@CacheEvict(value = {"product"},key = "#root.args[0]")

@Caching(
  cacheable = {
        @Cacheable = (value = "product",key = "#id"),
    },
    put = {
        @CachePut(value ="product",key = "#id"),
    @CachePut(value ="product",key = "'stock:'+#id")
    }
)

#任何ip可以访问
bind 0.0.0.0
#守护进程
daemonize yes
#密码
requirepass 123456
#日志文件
logfile "/user/local/redis/log/redis.log"
#持久化文件名
dbfilename xdclass.rdb
#持久化文件路径
dir /usr/local/redis/data
#关闭rdb
#save ""
#持久化策略，10s内有1个key改动，执行快照
save 10 1
#导出rdb数据库文件压缩字符串和对象，默认时yes，会浪费CPU但是节省空间
rdbcompression yes
#导入时是否检查
rdbchecksum yes

#关闭RDB
save ""
#10秒2个key变动触发RDB
save 10 2
#100秒5个key变动触发RDB
save 100 5

0 表示内核将检查是否有足够的可用内存供应用进程使用，如果有足够的可用内存，内存申请允许，否则，内存申请失败，并把错误返回给前台
1 表示内核允许分配所有的物理内存，而不管当前内存状态如何
2 表示内核允许分配超过所有物理内存和交换空间总和的内存
解决方式
echo > /proc/sys/vm/overcommit_memory
持久化配置
vim /etc/sysctl.conf
改为
vm.overcommit_memory=1
修改sysctl.conf后，需要执⾏ sysctl -p 以使⽣效

# 是否开启aof
appendonly yes
# ⽂件名称
appendfilename "appendonly.aof"
# 同步⽅式
appendfsync everysec
# aof重写期间是否同步
no-appendfsync-on-rewrite no
# 重写触发配置
#AOF文件最小重写大小，只有AOF文件大小大于该值的时候才可以重写，默认64mb
auto-aof-rewrite-min-size 64mb
#当前AOF文件大小和最后一次重写后的大小之间的比率等于指定的增长率重写，100 表示当最后一次压缩为150 ，那么就300的时候进行压缩
auto-aof-rewrite-percentage 100
# 加载aof时如果有错如何处理
# yes表示如果aof尾部⽂件出问题，写log记录并继续执⾏。
#no表示提示写⼊等待修复后写⼊
aof-load-truncated yes

Server: #有关redis服务器的常规信息
redis_mode:standalone #运行模式，单机或者集群
multiplexing_api:epoll  #redis所使用的事件处理机制
run_id:3abd26c33dfd059e87a0279defc4c96c13962e #redis服务器的随机标识符（用于sentinel和集群）
config_file:/usr/local/redis/conf/redis/conf  #配置文件路径
Clinets: #客户端连接部分
connected_clients:10  #已连接客户端的数量（不包括slave连接的客户端）
Memory: #内存消耗相关信息
userd_memory:874152   #使用内存
used_memory_human:853.66K #以⼈类可读的格式返回 Redis 分配的内存总量 
user_memory_rss:2834432   #系统给redis分配的内存即常驻内存，和top 、 ps 等命令的输出⼀致
used_memory_rss_human:2.70M # 以⼈类可读的格式返回系统redis分配的常驻内存top、ps等命令的输出⼀致
used_memory_peak:934040   #系统使用的峰值大小
used_memory_peak_human:912.15K
total_system_memory:1039048704  #操作系统的总字节
total_system_memory_human:990.91M
used_memory_lua:37888   # lua引擎使⽤的内存
used_memory_lua_human:37.00K
maxmemory:0 #最大内存的配置值，0表示不限制
maxmemory_human:0B
maxmemory_policy:noeviction  #达到最⼤内存配置值后的策略
Persistence:  #rdb和aof相关信息
rdb_bgsave_in_progress:0  #标识rdb save是否进⾏中
rdb_last_bgsave_status:ok # 上次的save操作状态
rdb_last_bgsave_time_sec:-1 # 上次rdb save操作使⽤的时间(单位s)
rdb_current_bgsave_time_sec:-1  #如果rdbsave操作正在进⾏，则是所使⽤的时间
aof_enabled:1 #是否开启aof，默认没开启
aof_rewrite_in_progress:0 # 标识aof的rewrite操作是否在进⾏中
aof_last_rewrite_time_sec:-1  #上次rewrite操作使⽤的时间(单位s)
aof_current_rewrite_time_sec:-1 #如果rewrite操作正在进⾏，则记录所使⽤的时间
aof_last_bgrewrite_status:ok  #上次rewrite操作的状态
aof_current_size:0  # aof当前⼤⼩
Stats:  #一版统计
evicted_keys:0  #因为内存⼤⼩限制，⽽被驱逐出去的键的个数
Replication:  #主从同步信息
role:master   #角色
connected_slaves:1  #连接的从库数
master_sync_in_progress:0 #标识主redis正在同步到从redis
Cluster:  #集群部分
cluster_enabled:0 # 实例是否启⽤集群模式
Keyspace: #数据库相关统计
db0:keys=4,expires=0,avg_ttl=0 # db0的key的数量,带有⽣存期的key的数,平均存活时间

timeout   #客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接
databases   #设置数据库的个数，可以使⽤ SELECT 命令来切换数据库。默认使⽤的数据库是 0
save    #设置 Redis 进⾏rdb持久化数据库镜像的频率。
rdbcompression #在进⾏镜像备份时，是否进⾏压缩
slaveof   #设置该数据库为其他数据库的从数据库
masterauth  #当主数据库连接需要密码验证时，在这⾥配置
maxclients  #限制同时连接的客户数量,当连接数超过这个值时,redis 将不再接收其他连接请求,返回error
maxmemory   #设置 redis 能够使⽤的最⼤内存，

如果定期删除漏掉了很多过期key，然后你也没有及时去查，也就没有走惰性删除，这回大量的过期key就会堆积在内存中，导致redis内存消耗尽了，就需要走内存淘汰机制。
注意：设计缓存中间件，可以参考redis的key过期淘汰方式和内存不足淘汰方式

redis在占⽤的内存超过指定的maxmemory之后，通过maxmemory_policy确定redis是否释放内存以及如何释放内存

volatile-lru(least recently used)
最近最少使⽤算法，从设置了过期时间的键中选择空转时间最⻓的键值对清除掉；
volatile-lfu(least frequently used)
最近最不经常使⽤算法，从设置了过期时间的键中选择某段时间之内使⽤频次最⼩的键值对清除掉；
volatile-ttl
从设置了过期时间的键中选择过期时间最早的键值对清除 (删除即将过期的）
volatile-random
从设置了过期时间的键中，随机选择键进⾏清除；
allkeys-lru
最近最少使⽤算法，从所有的键中选择空转时间最⻓的键值对清除；
allkeys-lfu
最近最不经常使⽤算法，从所有的键中选择某段时间之内使⽤频次最少的键值对清除；
allkeys-random
所有的键中，随机选择键进⾏删除；
noeviction
不做任何的清理⼯作，在redis的内存超过限制之后，所有的写⼊操作都会返回错误；但是读操作都能正常的进⾏;

注意：config配置的时候 下划线_的key需要⽤中横线-
127.0.0.1:6379> config set maxmemory_policy volatile-lru
(error) ERR Unsupported CONFIG parameter:maxmemory_policy
127.0.0.1:6379> config set maxmemory-policy volatile-lru
OK

8种
（1）不做处理（默认的）
（2）从所有key中随机删除
（3）从所有key中找出访问次数少的，不怎么使用的
（4）从所有key中找出最近空转时间最长的
（5）从设置过期的key中随机删除
（6）从设置过期key中最近空转时间最长的
（7）从过期key中，快要到期的key中删除
（8）从过期key中删除最近不常用的

#创建三个存放redis.conf的配置文件
mkdir -p /data/redis/master/data
mkdir -p /data/redis/slave1/data
mkdir -p /data/redis/slave2/data
#从节点设置只读（默认）
replica-read-only yes
#从节点访问主节点的密码，和requirepass一样，注意主节点也要配下这个，因为主节点宕机后会重新选取主节点
masterauth 123456
#哪个主节点进行复制
replicaof 8.129.113.233 6379

bind 0.0.0.0
port 6379
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis_master.log"
dbfilename "xdclass_master.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly_master.aof"
masterauth "123456"

bind 0.0.0.0
port 6380
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis_slave1.log"
dbfilename "xdclass_slave1.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly_slave1.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

bind 0.0.0.0
port 6381
daemonize yes
requirepass "123456"
logfile "/usr/local/redis/log/redis_slave2.log"
dbfilename "xdclass_slave2.rdb"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly_slave2.aof"
replicaof 8.129.113.233 6379
masterauth "123456"

#启动主
./redis-server /data/redis/master/data/redis.conf
#启动从
./redis-server /data/redis/slave1/data/redis.conf
./redis-server /data/redis/slave2/data/redis.conf

#不限制ip
bind 0.0.0.0
# 让sentinel服务后台运⾏
daemonize yes
# 配置监听的主服务器，mymaster代表服务器的名称，⾃定义，172.18.172.109 代表监控的主服务器，6379代表端⼝，2代表只有两个或两个以上的哨兵认为主服务器不可⽤的时候，才会进⾏failover操作。
sentinel monitor mymaster 172.18.172.109 6379 2
# sentinel auth-pass定义服务的密码，mymaster是服务名称，123456是Redis服务器密码
sentinel auth-pass mymaster 123456
#超过5秒master还没有连接上，则认为master已经停⽌
sentinel down-after-milliseconds mymaster 5000
#如果该时间内没完成failover操作，则认为本次failover失败
sentinel failover-timeout mymaster 30000

port 26379
bind 0.0.0.0
daemonize yes
pidfile "/var/run/redis-sentinel-1.pid"
logfile "/var/log/redis/sentinel_26379.log"
dir "/tmp"
sentinel monitor mymaster 8.129.113.233 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel auth-pass mymaster 123456
sentinel failover-timeout mymaster 30000

port 26380
bind 0.0.0.0
daemonize yes
pidfile "/var/run/redis-sentinel-2.pid"
logfile "/var/log/redis/sentinel_26380.log"
dir "/tmp"
sentinel monitor mymaster 8.129.113.233 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel auth-pass mymaster 123456
sentinel failover-timeout mymaster 30000

port 26381
bind 0.0.0.0
daemonize yes
pidfile "/var/run/redis-sentinel-3.pid"
logfile "/var/log/redis/sentinel_26381.log"
dir "/tmp"
sentinel monitor mymaster 8.129.113.233 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel auth-pass mymaster 123456
sentinel failover-timeout mymaster 30000

./redis-server /usr/local/redis/conf/sentinel-1.conf --sentinel
./redis-server /usr/local/redis/conf/sentinel-2.conf --sentinel
./redis-server /usr/local/redis/conf/sentinel-3.conf --sentinel

redis:
    #host: 8.140.116.67
    #port: 6379
    sentinel:
      master: mymaster
      nodes: 8.140.116.67:26379,8.140.116.67:26380,8.140.116.67:26381
    password: 123456
    client-type: jedis

6381、6382
6383、6384
6385、6386

bind 0.0.0.0
port 6381
daemonize yes
requirepass "123456"
dbfilename "xdclass_6381.rdb"
logfile "/usr/local/redis/log/redis_6381.log"
dir "/usr/local/redis/data"
appendonly yes
appendfilename "appendonly_6381.aof"
masterauth "123456"
#是否开启集群
cluster-enabled yes
#生成node文件，记录集群节点信息，默认为nodes.conf，防止冲突，改为nodes-6381.conf
cluster-config-file nodes-6381.conf
#节点连接超时时间
cluster-node-timeout 20000
#集群节点的ip，当前节点ip
cluster-announce-ip 172.18.172.109
#集群节点映射端口
cluster-announce-bus-port 16381
#集群节点总线端口，节点之间互相通信，常规端口+1万
cluster-announce-bus-port 16381

./redis-server ../conf/cluster/redis_6381.conf
./redis-server ../conf/cluster/redis_6382.conf
./redis-server ../conf/cluster/redis_6383.conf![在这里插入图片描述](https://ucc.alicdn.com/images/user-upload-01/ccf4aa46ba0b451a933bd2be22c3fab8.jpeg#pic_center)
./redis-server ../conf/cluster/redis_6384.conf
./redis-server ../conf/cluster/redis_6385.conf
./redis-server ../conf/cluster/redis_6386.conf

--cluster #构建集群中全部节点信息
--cluster-replicas 1 #主从节点的比例，1表示1主1从的方式
./redis-cli -a 123456 --cluster create 8.140.116.67:6381 8.140.116.67:6382 8.140.116.67:6383 8.140.116.67:6384 8.140.116.67:6385 8.140.116.67:6386 --cluster-replicas 1

./redis-cli -c -a 123456 -p 6379
#集群信息
cluster info
#节点信息
cluster nodes

redis:
    #host: 8.140.116.67
    #port: 6379
#    sentinel:
#      master: mymaster
#      nodes: 8.140.116.67:26379,8.140.116.67:26380,8.140.116.67:26381
    cluster:
      #命名的最多转发次数
      max-redirects: 3
      nodes: 8.140.116.67:6381,8.140.116.67:6382,8.140.116.67:6383,8.140.116.67:6384,8.140.116.67:6385,8.140.116.67:6386

io-threads-do-reads yes
io-threads 线程数

不会有安全问题，Redis的多线程部分只是用来吃力网络数据的读写和协议解析，执行命令仍然是单线程顺序执行

之前的redis没有⽤户的概念，redis6引⼊了acl
可以给每个⽤户分配不同的权限来控制权限
通过限制对命令和密钥的访问来提⾼安全性，以使不受信任的客户端⽆法访问
提⾼操作安全性，以防⽌由于软件错误或⼈为错误⽽导致进程或⼈员访问 Redis，从⽽损坏数据或配置

acl list   #当前启用的ACL规则
acl cat    #支持的权限分类列表
acl cat hash #返回指定类别中的命令
acl setuser  #创建和修改用户命令
acl deluser  #删除用户命令

+<command>:将命令添加到⽤户可以调⽤的命令列表中，如+@hash
-<command>:将命令从⽤户可以调⽤的命令列表中移除
#切换默认用户
auth default 123456
#例⼦ 密码 123 ，全部key，全部权限
acl setuser jack on >123 ~* +@all
#例⼦ 密码 123 ，全部key，get权限
acl setuser jack on >123 ~* +get