Redis6快速入门，Java程序员面试必备的知识点

Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。

3.4 Redis集合(Set)

---

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。

一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

3.4.1 常用命令

sadd <key><value1><value2> .....

将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略

smembers <key>取出该集合的所有值。

sismember <key><value>判断集合<key>是否为含有该<value>值，有1，没有0

scard<key>返回该集合的元素个数。

srem <key><value1><value2> .... 删除集合中的某个元素。

spop <key>**随机从该集合中吐出一个值。**

srandmember <key><n>随机从该集合中取出n个值。不会从集合中删除 。

smove <source><destination>value把集合中一个值从一个集合移动到另一个集合

sinter <key1><key2>返回两个集合的交集元素。

sunion <key1><key2>返回两个集合的并集元素。

sdiff <key1><key2>返回两个集合的**差集**元素(key1中的，不包含key2中的)

Set数据结构是dict字典，字典是用哈希表实现的。

Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

3.5 Redis哈希(Hash)

---

Redis hash 是一个键值对集合。

Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

类似Java里面的Map<String,Object>

用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储

主要有以下2种存储方式：

3.5.1 常用命令

hset <key><field><value>给<key>集合中的 <field>键赋值<value>

hget <key1><field>从<key1>集合<field>取出 value

hmset <key1><field1><value1><field2><value2>... 批量设置hash的值

hexists<key1><field>查看哈希表 key 中，给定域 field 是否存在。

hkeys <key>列出该hash集合的所有field

hvals <key>列出该hash集合的所有value

hincrby <key><field><increment>为哈希表 key 中的域 field 的值加上增量 1 -1

hsetnx <key><field><value>将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 .

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。

3.6 Redis有序集合Zset

---

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

不同之处是有序集合的每个成员都关联了一个**评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。**集合的成员是唯一的，但是评分可以是重复了 。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。

访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

3.6.1 常用命令

zadd <key><score1><value1><score2><value2>…

将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

**zrange <key><start><stop> [WITHSCORES]**

返回有序集 key 中，下标在<start><stop>之间的元素

带WITHSCORES，可以让分数一起和值返回到结果集。

zrangebyscore key minmax [withscores] [limit offset count]

返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

zrevrangebyscore key maxmin [withscores] [limit offset count]

同上，改为从大到小排列。

zincrby <key><increment><value> 为元素的score加上增量

zrem <key><value>删除该集合下，指定值的元素

zcount <key><min><max>统计该集合，分数区间内的元素个数

zrank <key><value>返回该值在集合中的排名，从0开始。

案例：如何利用zset实现一个文章访问量的排行榜？

SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

zset底层使用了两个数据结构

（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。

（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

四、配置文件介绍

=======================================================================

4.1 Units单位

---

配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit

大小写不敏感

4.2 INCLUDES包含

类似jsp中的include，多实例的情况可以把公用的配置文件提取出来

4.3 网络相关配置

---

4.3.1 bind

默认情况bind=127.0.0.1只能接受本机的访问请求

不写的情况下，无限制接受任何ip地址的访问

生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉

如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应

保存配置，停止服务，重启启动查看进程，不再是本机访问了。

4.3.2 protected-mode

将本机访问保护模式设置 no

4.3.3 port

端口号，默认 6379

4.3.4 timeout

一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭

4.3.5 tcp-keepalive

对访问客户端的一种心跳检测，每个n秒检测一次。

单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60

4.4 GENERAL通用

---

4.4.1 daemonize

是否为后台进程，设置为yes

守护进程，后台启动

4.4.2 pidfile

存放pid文件的位置，每个实例会产生一个不同的pid文件

4.4.3 loglevel

指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为notice

四个级别根据使用阶段来选择，生产环境选择notice 或者warning

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 复制原理

---

1. Slave启动成功连接到master后会发送一个sync命令

2. Master接到命令启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令， 在后台进程执行完毕之后，master将传送整个数据文件到slave,以完成一次完全同步

3. 全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

4. 增量复制：Master继续将新的所有收集到的修改命令依次传给slave,完成同步

5. 但是只要是重新连接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

原主机重启后会变为从机。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习

已经将知识体系整理好（源码，笔记，PPT，学习视频）

次传给slave,完成同步

5. 但是只要是重新连接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

原主机重启后会变为从机。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-KCWTSzkM-1711986205735)]
[外链图片转存中…(img-H5lLgaUk-1711986205736)]
[外链图片转存中…(img-WUPLaYtu-1711986205736)]
[外链图片转存中…(img-HHJeMvs7-1711986205737)]
[外链图片转存中…(img-XU8vcRph-1711986205737)]
[外链图片转存中…(img-WJxYcAIa-1711986205738)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-RicQk4p6-1711986205739)]

最后

我还为大家准备了一套体系化的架构师学习资料包以及BAT面试资料，供大家参考及学习

已经将知识体系整理好（源码，笔记，PPT，学习视频）

[外链图片转存中…(img-2GWGkFqB-1711986205739)]

[外链图片转存中…(img-7lNMRMeR-1711986205740)]

[外链图片转存中…(img-biULwAfr-1711986205740)]