首页 > 数据库> 文章详细

Redis的持久化集成AOF,BOD

2021-06-29 20:34:41 阅读：158 来源： 互联网

标签：AOF ## Redis redis value k1 key new BOD

1. redis 一种非关系数据库。
2. redis常用的命令
   （1）对key操作的命令。
       （1）keys *
        (2)del key
        (3)expire key seconds
        (4)ttl key
    (2) 操作数据库的命令
        select index
        flushdb
        flushall
3. redis支持的数据类型
    （1）字符串
       1. set key value
       2. get key
       3. mset key value key value ...
       4. mget key key
       5. setnx key value
       6. incr key
       7. decr key
    (2) 队列【列表】
       1. lpop
       2. lrange
       3. lpush
    (3) hash哈希
       1.hset key field value
       2.hget key field
       3.hgetall key
    (4) set集合
       sadd key value value value
       smembers key
       spop key
    (5)sort set 集合
       zadd key scope value scope value ...

3.1 什么是持久化？

```
1. 把内存中的数据持久化到磁盘。这个过程就是持久化。当redis启动时会从磁盘上读取数据并加载到内存。

## 3.3 redis持久化的方式

```
1. RDB: 以快照的方式进行持久化。在一定时间间隔内进行快照。把数据进行保存到磁盘。
2. AOF: 会把每次对redis的写操作命令追加到一个日志尾，当redis启动时则把该日志中的命令执行一遍.

## 4.2 save和bgsave的区别

该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令，直到RDB过程完成为止。具体流程如下：

![image-20210628091507831](assets/image-20210628091507831.png)

执行完成时候如果存在老的RDB文件，就把新的替代掉旧的。我们的客户端可能都是几万或者是几十万，这种方式显然不可取。

bgsave执行该命令时，Redis会在后台异步进行快照操作，快照同时还可以响应客户端请求。具体流程如下：

![image-20210628091715910](assets/image-20210628091715910.png)

## 4.3 通过配置文件来触发RDB ----- bgsave命令

![image-20210628092515419](assets/image-20210628092515419.png)

## 4.4 恢复数据

可以把dump.rdb放入到redis启动目录下。当redis再次被启动时则会加载该数据。

## 4.5 rdb持久化方式的优缺点

有点:

```
（1）RDB文件紧凑，全量备份，非常适合用于进行备份和灾难恢复。
（2）bgsave生成RDB文件的时候，redis主进程会fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘IO操作。
（3）RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

## 5.3 aof的优缺点

1. 优点：

   ```
   （1）AOF可以更好的保护数据不丢失，一般AOF会每隔1秒，通过一个后台线程执行一次fsync操作，最多丢失1秒钟的数据。
   （2）AOF日志文件没有任何磁盘寻址的开销，写入性能非常高，文件不容易破损。
   （3）AOF日志文件即使过大的时候，出现后台重写操作，也不会影响客户端的读写。
   ```

2.缺点

   ```
   （1）对于同一份数据来说，AOF日志文件通常比RDB数据快照文件更大.
    (2) 恢复数据时时间要比快照模式慢很多。
   ```

# 6. redis的集群

## 6.1 redis主从关系

![image-20210628100645163](assets/image-20210628100645163.png)

## 6.2 如何搭建主从关系

```
1. 准备三台机器（1 主节点 2 从节点）为了节省资源在一个虚拟机上启动三台redis 只是他们的端口号不同，

```

## 6.3 搭建主从的关系

```
1.配从不配主
（1）配置redis配置文件 6380(主) 6381（从） 6382（从）
（2）修改rdb持久化文件的路径以及端口
```

分别其他80 81 82

![image-20210628104632400](assets/image-20210628104632400.png)

分别连接不同的redis服务

![image-20210628104805927](assets/image-20210628104805927.png)

检验上面上个redis服务之间的关系

![image-20210628104915778](assets/image-20210628104915778.png)

上面三个redis服务之间是没有任何主从关系。

可以通过以下命令设置 81 82 跟随80混

Java连接redis数据库

# 3.java连接redis。

## 3.1 引入redis的依赖------>jedis

```xml
<dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.6.0</version>
        </dependency>
    </dependencies>

## 3.2 java代码操作redis

```java
package com.test;

import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TestRedis {
    public static void main(String[] args) {
        //1.获取连接对象
        Jedis jedis=new Jedis("192.168.223.128",6379); //默认连接的为localhost 端口号为6379
        //2.操作redis数据库 -----String类型
        jedis.set("k1","v1");
        jedis.set("k2","2");
        jedis.setnx("k1","v3");
        jedis.mset("k3","v3","k4","v4");
        List<String> mget = jedis.mget("k1", "k2");
        System.out.println(mget);
        jedis.flushAll();

//3.操作hash类型
        Map<String,String> map=new HashMap<>();
        map.put("name","闫克起");
        map.put("age","17");
        map.put("sex","男");
        jedis.hset("k1",map);

Map<String, String> k1 = jedis.hgetAll("k1");
System.out.println(k1);

        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
    }
}

```

# 4.springboot整合redis。

## 4.1 依赖---->启动依赖---->自动装配---->自动读取配置

```xml
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
```

## 4.2 代码测试--------StringRedistemplate

```java
@Autowired
    private StringRedisTemplate stringRedisTemplate;//存放的数据格式为string类型
    @Test
    void contextLoads() {
//        //使用ValueOperations -----操作的为字符串类型
//        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
//        ops.set("k1","springboot-v1");
//        System.out.println(ops.get("k1"));
//        Boolean aBoolean = ops.setIfAbsent("k2", "王沛他很听话");//setnx
//        System.out.println(aBoolean);
//        Map<String,String> map=new HashMap<>();
//        map.put("name","张三");
//        map.put("age","18");
//        map.put("name","李四");
//        ops.multiSet(map);
//        System.out.println(stringRedisTemplate.keys("*"));
//        //操作hash类型 HashOperations<String, Object, Object>
        HashOperations<String, Object, Object> hash = stringRedisTemplate.opsForHash();
        hash.put("k1","name","赵露露");
        hash.put("k1","age","18");
        Object o = hash.get("k1", "name");
        System.out.println(hash.keys("k1"));
        System.out.println(hash.values("k1"));
        System.out.println(o);
        System.out.println(hash.entries("k1"));
    }

```

利用SpringBoot整合redis

## 4.3 代码测试----------RedisTemplate

它的key和value可以存放Object类型,那么它的key和value默认采用的序列化方式为JDK序列化方式。一般我们需要为key和value指定序列化方式。

```
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
```

```java
@Autowired
private RedisTemplate redisTemplate;

    @Test
    void contextLoadsHash() {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        HashOperations hash = redisTemplate.opsForHash();
        hash.put("u","n","崔梦");
        hash.put("u","a","25");
    }

    @Test
    void contextLoads() {
        //因为RedisTemplate默认会为key和value进行序列按照JDK的序列化方式进行的，
        //再实际开发过程中不用默认的序列化方式。空间少而且不用为实体类实现序列化接口
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //可以指定key的序列化方式
        valueOperations.set("k4",new User("王五",25,"郑州"));
        Object k4 = valueOperations.get("k4");
        System.out.println(k4);
//        Object k = valueOperations.get("k");
//        System.out.println(k);

}
```

关于哨兵

标签：AOF,##,Redis,redis,value,k1,key,new,BOD
来源： https://blog.csdn.net/xiongyuhui520/article/details/118335955

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Redis的持久化集成AOF,BOD