前言
有了主从模式，主库如果发生故障，从库可以转为主库，这时候我们需要对redis进行监控，此时就需要用到redis中的哨兵机制。
哨兵是建立在主从模式基础之上
哨兵模式是redis 2.x 版本提供的，3.x 版本的时候一般我们使用 redis集群 cluster
redis 哨兵模式
哨兵模式
这里我们使用一个主节点（主）和一个子节点（从）
从节点使用哨兵模式进行监控主节点，如果主挂了，从库自动升级为主节点，等待主库恢复了，主库会自动变为从库。
但此时，如果升级为主库的从节点挂了，此时变为从库的主节点不会变为主库，出现这种问题，我们一般采用的是主从都进行哨兵模式配置，互相监控对方，从而达到高可用。
配置哨兵
redis 主 port 6380 Sentinel （哨兵端口）26380
redis 从 port 6381 Sentinel （哨兵端口）26381
由于windows版本的redis没有 Sentinel.conf文件 所以在redis的文件中创建一个
主服务6380 哨兵监听 从节点6381
# 当前Sentinel服务运行的端口
port 26380
#master
sentinel monitor master 127.0.0.1 6381 1
sentinel down-after-milliseconds master 5000
sentinel failover-timeout master 180000
sentinel parallel-syncs master 1从节点6381 哨兵监听 主服务6380
# 当前Sentinel服务运行的端口
port 26381
# Sentinel去监视一个名为mymaster的主redis实例，
# 这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，
# 而将这个主实例判断为失效至少需要2个 Sentinel进程的同意，
# 只要同意Sentinel的数量不达标，自动failover就不会执行
# 这个一定设置为 no 或者这里不设置 需要在哨兵中关闭保护模式。
# protected-mode no
# 指定了Sentinel认为Redis实例已经失效所需的毫秒数。
# 当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
# 只有一个 Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel monitor mymaster 127.0.0.1 6380 1
# 指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel down-after-milliseconds mymaster 5000
# 如果在该时间（ms）内未能完成failover操作，则认为该failover失败
sentinel failover-timeout mymaster 10000启动redis
redis-server.exe redis.windows.conf
启动哨兵
redis-server.exe sentinel.conf --sentinel
停止6380 主节点，查看从节点6381 可以看到升为主节点了
可以从6381哨兵中看到
在启动6380 主节点 ，可以看到 6380主节点转为6380的从节点
可以在6380的哨兵中看到
一主一从两哨兵的目的是
主库挂了从升级为主库，原来主库恢复了之后成为从库
升级为主库的从库挂了之后，降为从库的主库再升级为主句
两者进行切换
可以在redis中用命令info replication查看，这里是切换之后的
主
从
至于如何在代码中使用？
这里演示Spring Boot 项目中，配置文件直接配置即可。
# redis 主从哨兵配置
spring:
redis:
database: 0
host: 127.0.0.1 #主节点的地址
port: 6379
password:
pool:
max-active: 8
max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
max-idle: 8
min-idle: 0
timeout: 0
# 主节点哨兵名
sentinel:
master: mymaster #这个需要和主节点哨兵配置文件中的保持一致
# comma-separated list of host:port pairs 哨兵节点配置列表
nodes: 127.0.0.1:26380,127.0.0.1:26381需要注意的是，这里默认从主库读写。
如果要配置，需要配置一下。
这里我用 springboot 2.0.8.RELEASE 这个版本
redis 版本
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.1.4.RELEASE</version>
<!-- <version>2.6.3</version>-->
</dependency>package com.xxxxxx.component.redis;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import io.lettuce.core.ReadFrom;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericToStringSerializer;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.HashSet;
@Configuration
public class RedisConfig {
// @Value("${spring.redis.sentinel.master}")
// private String sentinelMaster;
//
// @Value("${spring.redis.sentinel.nodes}")
// private String sentinelNodes;
/**
* 改用fastjson redis序列化，请删除redis数据后使用此序列化
*
* @param redisConnectionFactory
* @return
*/
@SuppressWarnings({"unchecked", "rawtypes"})
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
GenericToStringSerializer<String> stringRedisSerializer = new GenericToStringSerializer<>(String.class);
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setHashKeySerializer(stringRedisSerializer);
FastJsonRedisSerializer fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
FastJsonConfig fastJsonConfig = fastJsonRedisSerializer.getFastJsonConfig();
SerializeConfig serializeConfig = fastJsonConfig.getSerializeConfig();
//加入的locadatetime序列化，也可以不加（但是要用@JSONField(format = "yyyy-MM-dd HH:mm:ss")）格式化
serializeConfig.put(LocalDateTime.class, (serializer, object, fieldName, fieldType, features) -> {
SerializeWriter out = serializer.out;
if (object == null) {
out.writeNull();
return;
}
out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format((LocalDateTime) object));
});
serializeConfig.put(LocalDate.class, (serializer, object, fieldName, fieldType, features) -> {
SerializeWriter out = serializer.out;
if (object == null) {
out.writeNull();
return;
}
out.writeString(DateTimeFormatter.ofPattern("yyyy-MM-dd").format((LocalDate) object));
});
serializeConfig.put(LocalTime.class, (serializer, object, fieldName, fieldType, features) -> {
SerializeWriter out = serializer.out;
if (object == null) {
out.writeNull();
return;
}
out.writeString(DateTimeFormatter.ofPattern("HH:mm:ss").format((LocalTime) object));
});
fastJsonConfig.setSerializeConfig(serializeConfig);
fastJsonConfig.setFeatures(Feature.SupportAutoType);
fastJsonConfig.setSerializerFeatures(SerializerFeature.WriteClassName);
redisTemplate.setValueSerializer(fastJsonRedisSerializer);
redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Bean
public RedisConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties) {
// RedisURI node1 = RedisURI.create("127.0.0.1", 7000);
// RedisURI node2 = RedisURI.create("127.0.0.1", 7001);
// RedisURI node3 = RedisURI.create("127.0.0.1", 7002);
// RedisClusterClient client = RedisClusterClient.create(Arrays.asList(node1, node2, node3));
// StatefulRedisClusterConnection con = client.connect();
// con.setReadFrom(ReadFrom.SLAVE_PREFERRED);
//
RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(
redisProperties.getSentinel().getMaster(), new HashSet<>(redisProperties.getSentinel().getNodes())
);
LettucePoolingClientConfiguration lettuceClientConfiguration = (LettucePoolingClientConfiguration) LettucePoolingClientConfiguration.builder()
//优先读取主节点，如果主节点不可用，则读取从节点
.readFrom(ReadFrom.MASTER_PREFERRED)
//优先读取从节点，如果从节点不可用，则读取主节点
// .readFrom(ReadFrom.UPSTREAM_PREFERRED)
//从任意一个从节点读取
// .readFrom(ReadFrom.ANY_REPLICA)
.build();
return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration);
}
}根据
ReadFrom中 策略进行读取
这个版本中只有如下这些读写策略
设置可以这样设置一下
@Bean
public RedisConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties) {
RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(
redisProperties.getSentinel().getMaster(), new HashSet<>(redisProperties.getSentinel().getNodes())
);
//这里强转一下
LettucePoolingClientConfiguration lettuceClientConfiguration = (LettucePoolingClientConfiguration) LettucePoolingClientConfiguration.builder()
//优先读取主节点，如果主节点不可用，则读取从节点
.readFrom(ReadFrom.MASTER_PREFERRED)
//优先读取从节点，如果从节点不可用，则读取主节点
// .readFrom(ReadFrom.UPSTREAM_PREFERRED)
//从任意一个从节点读取
// .readFrom(ReadFrom.ANY_REPLICA)
.build();
return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration);
}而在 spring-boot-starter-data-redis 2.6.3版本中， 策略枚举值相对较多，可以根据自己需求设置。
设置和上面设置一样，但不需要强转，直接设置即可。当然springboot版本也需要提供，尽可能和redis版本相差不大。
如何查看自己redis是从哪个库读取数据的，可以debug打印日志看一下redis的地址。
这里在我们测试服务测的日志，可以看到读和写的链接地址是不同的。
服务器测试程序中，131是写库，121 是读库，策略我是使用 ReadFrom.SLAVE_PREFERRED 优先从从库读
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
