微服务架构-Redis实战原理剖析-073：Redis持久化与一致性解决方案

1 Redis持久化原理与一致性原理课程介绍

课程内容:
1.使用Redis二进制形式存放对象
2.全量同步与增量同步的区别
3.RDB与AOF实现持久化的区别
4.MySQL与Redis一致性解决同步问题

2 使用Redis二进制形式存储对象

SpringBoot整合Redis
方案2：直接使用redis自带序列化方式存储对象

@Component
public class RedisTemplateUtils {

    // @Autowired 注意，用@Autowired注入报错
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    public void setObject(String key, Object value) {
        setObject(key, value, null);
    }

    public void setObject(String key, Object value, Long timeOut) {
        redisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }

    public Object getObject(String key) {
        return redisTemplate.opsForValue().get(key);
    }

}

@Data
public class UserEntity implements Serializable {
    private Long userId;
    private String userName;
}

@RestController
public class RedisController {

    @Autowired
    private RedisTemplateUtils redisTemplateUtils;

    @GetMapping("/addUser")
    private String addUser(UserEntity userEntity) {
        redisTemplateUtils.setObject("userEntity", userEntity);
        return "存储成功";
    }

    @GetMapping("/getUser")
    public UserEntity getUser(String key) {
        return (UserEntity) redisTemplateUtils.getObject(key);
    }
}

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class);
    }
}

测试结果：

3 SpringBoot整合Redis注解版本

SpringBoot整合Redis的注解版本
引入maven依赖

<!--mysql数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<!--mybatis-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>

配置文件application.yml

spring:
  redis:
    host: 192.168.206.101
    password: 123456
    port: 6379
    database: 1
  #数据库连接配置
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&useSSL=false
    username: root
    password: root

相关代码

@Data
public class MemberEntity implements Serializable {
    private Long id;
    private String name;
    private Integer age;
}

@RestController
public class MemberController {

    @Autowired
    private UserMapper userMapper;

    @Cacheable(cacheNames = "members",key = "'getListMembers'")
    @RequestMapping("/getListMembers")
    public List<MemberEntity> getListMembers(){
        return userMapper.findMemberAll();
    }
}

@SpringBootApplication
@EnableCaching
@MapperScan("com.mayikt.mapper")
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class);
    }
}

注意：@Cacheable(cacheNames = “members”,key = “‘getListMembers’”)
members相当于目录，key中””内必须要加’’
启动类开启@EnableCaching
测试结果：

4 MySQL与Redis一致性解决方案

MySQL与Redis的数据同步的问题如何解决？
方式1：直接清理Redis的缓存，重新查询数据库即可；
方式2：直接采用mq订阅mysql binlog日志文件增量同步到Redis中，整个过程采用最终一致性方案；
方式3：使用alibaba的canal框架（底层就是采用mq订阅binlog）

5 全量同步与增量同步实现的区别

Redis因为某种原因的情况下宕机之后，数据是不会丢失的。
原理就是持久化
大部分的缓存框架都会基本功能：淘汰策略、持久化机制
Redis持久化的机制有两种：aof、rdb（默认）

全量同步与增量同步的区别
全量同步：就是每天定时（避开高峰期）或者采用一种周期的实现将数据拷贝到一个地方，也就是Rdb存储。
频率不是很大，但是可能会造成数据的丢失。

增量同步：比如采用对行为的操作实现数据同步，也就是AOF。
频率非常高、对服务器同步的压力也是非常大、保证数据不丢失。

6 RedisRDB持久化实现原理

RDB与AOF实现持久化的区别
Redis提供了两种持久化的机制，分别为RDB、AOF实现，RDB采用定时（全量）持久化机制，但是服务器因为某种原因宕机后可能数据会丢失，AOF是基于数据日志操作实现的持久化，所以AOF采用增量同步的方案。
Redis已经默认开启了rdb存储。

Redis以快照的形式将数据持久化到磁盘的是一个二进制的文件dump.rdb。此外，我们也可以通过配置文件来修改Redis服务器dump快照的频率，在打开redis.conf文件之后，搜索save，可以看到下面的配置信息：
save 900 1 #在900秒(15分钟)之后，如果至少有1个key发生变化，则dump内存快照。
save 300 10 #在300秒(5分钟)之后，如果至少有10个key发生变化，则dump内存快照。
save 60 10000 #在60秒(1分钟)之后，如果至少有10000个key发生变化，则dump内存快照。

Set(包含增加和覆盖)、del
Set name yushengjun
Set name mayikt
Del name
以上操作包含三次key变化

7 RedisAOF持久化实现原理

Aof在Redis的配置文件中存在三种同步方式，它们分别是：
appendfsync always #每次有数据修改发生时都会写入AOF文件，能够保证数据不丢失，但是效率非常低。
appendfsync everysec #每秒钟同步一次，可能会丢失1s内的数据，但是效率非常高。
appendfsync no #从不同步。高效但是数据不会被持久化。
开启aof直接修改redis.conf中 appendonly yes，默认采用appendfsync everysec，数据先放入缓存区，再每秒钟定时将缓存区数据同步到aof日志文件中。
建议最好还是使用everysec 既能够保证数据的同步、效率也还可以。

Aof是以执行命令的形式实现同步，只记录写的请求不记录读的请求。