搜索
您的当前位置：首页正文

【redis】02-redis持久化存储以及对象存储

来源：独旅网

1. redis存储对象

redis存储对象主要有两种方式：
（1）采用json序列化成字符串的方式进行存储
（2）采用二进制的方式进行存储

接下来我们详细看下这两种方式

redis采用JSON序列化存储对象

实现原理：

主要是将对象进行JSON序列化成JSON字符串进行存储。取出来再将字符串还原成对象

JSON案例：

创建RedisUtils
StringRedisTemplate 主要为String类型的api

package com.mayikt.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    public void setString(String key, String value) {
        setString(key, value, null);
    }
    public void setString(String key, String value, Long timeOut) {
        stringRedisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            stringRedisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }

    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

再看看MemberController进行调用

package com.mayikt.controller;

import com.alibaba.fastjson.JSONObject;
import com.mayikt.entity.User;
import com.mayikt.utils.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MemberController {
    @Autowired
    private RedisUtils redisUtils;

    @GetMapping("/addUser")
    public String addUser(long id, String name) {
        User user = new User(id, name);
        String userStr = JSONObject.toJSONString(user);
        redisUtils.setString("userEntity",  userStr);
        return "存储成功";
    }

    @GetMapping("/getUser")
    public String getUser(String key) {
        String userStr = redisUtils.getString(key);
        return userStr;
    }

}
将对象转化为二进制格式存储

redis其实已经支持了对象的存储，只不过需要把对象转化为二进制。所以我们看下另外一个案例

案例：
RedisUtils

这里注入RedisTemplate的时候不能使用@Autowired，会找不到该类，从而使用@Resource注解

package com.mayikt.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils {
    @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);
    }
}

MemberController

package com.mayikt.controller;

import com.alibaba.fastjson.JSONObject;
import com.mayikt.entity.User;
import com.mayikt.utils.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MemberController {


    @Autowired
    private RedisUtils redisUtils;
    
    @GetMapping("/addUserSer")
    public String addUserSer(long id, String name) {
        User user = new User(id, name);
        redisUtils.setObject("userEntitySer",  user);
        return "存储成功";
    }

    @GetMapping("/getUserSer")
    public Object getUserSer(String key) {
        Object user = redisUtils.getObject(key);
        return user;
    }

}

当我们启动项目调用接口的时候可能会报这个错误

java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of type [com.mayikt.entity.User]

从报错信息上看是我们的类没有进行序列化，所以我们将User类序列化即可

package com.mayikt.entity;
import lombok.Data;
import java.io.Serializable;

@Data
public class User implements Serializable {

    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public User() {
    }
}

2. 全量同步与增量同步

全量同步：

就是每天定时（避开高峰期）或者采用一个周期实现将数据拷贝到一个地方也就是Rdb存储。

增量同步：

客户端做的增删改的操作进行存储下来，保证数据的不丢失

全量与增量的区别：

增量同步比全量同步更加消耗服务器的内存，但是能够更加的保证数据的同步。

3. RDB和AOF实现持久化的区别

RDB持久化

Redis默认采用的RDB方式进行数据的持久化操作。
我们先看下rdb的执行流程图

从上述的示例我们可以看出：rdb持久化采用的全量同步的方式，即在规定时间之内，如果修改了redis的key达到多少次以后，我们会在规定时间以后进行数据保存。

优点：
每隔一段时间或者达到条件进行数据保存，不太耗服务器的内存

缺点：
因为是每隔一段时间或达到条件保存，但是在未达到条件前服务器宕机了，会造成上一次保存时间到宕机之间的数据丢失

AOF持久化

AOF持久化采用的是增量同步，比rdb更能保证数据的一致，但是更加占用服务器内存

在Redis的配置文件中存在三种同步方式，它们分别是：
appendfsync always #每次有数据修改发生时都会写入AOF文件，能够保证数据不丢失，但是效率非常低。

使用AOF持久话机制：

直接修改redis.conf中 appendonly yes
appendfsync always 与appendfsync everysec 比较：

建议最好还是使用everysec 既能够保证数据的同步、效率也还可以。

appendfsync always 效率太低，但是能保证数据的一致性

4. Mysql与Redis一致性解决同步问题

采用Redis注解版来添加redis数据缓存
添加pom依赖

<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>

添加数据库连接

spring:
  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

添加mapper

@Repository
public interface UserMapper {
    @Select("select * from users")
    List<User> findMemberAll();
}

Controller添加查询方法

@RestController
public class MemberController {

    @GetMapping("/findMemberAll")
    @Cacheable(cacheNames = "members", key = "'findMemberAll'")
    public Object findMemberAll(){
        List<User> memberAll = userMapper.findMemberAll();
        return memberAll;
    }
}

除此之外还需要在启动类添加mapperScan注解和Caching注解

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

Mysql与Redis一致性解决同步问题主要有三种方案：

方式1：直接清除Redis的缓存，重新读取数据库即可

缺点：

方式2：使用mq异步订阅mysql binlog实现增量同步
我们先来看看流程图

  1. mysql进行dml操作会生成binlog日志文件
  2. 将消息推送给mq
  3. redis再消费传递过来的信息即可

大多数公司采用的都是这种模式

方式3：使用alibaba的canal

此种方式是阿里巴巴基于方式二写的开源框架

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- 版权所有

Top