对于大多数开发的同学来说，redis再熟悉不过了，基本上来说，在一个微服务项目中，redis几乎成了标配，经验来看，redis大多数作为缓存来使用，而且使用起来学习成本可以说很低了。通常来说，为了确保redis的高可用性，生产环境夏一般会使用集群模式，这个需要结合项目自身的情况选择，比如你的项目主要是为了应对高并发读，主从集群即可满足，而如果你的项目不仅读写频繁，而且需要存储的缓存数量也很大，可能cluster集群模式更适合你。本篇将以redis的哨兵集群为例，从搭建到与springboot的整合做详细的说明。

二、环境准备

基于centos7的虚拟机，或云服务器一台（至少一台）。

三、安装redis

3.1 前置准备

3.1.1 下载安装包

选择合适的版本进行下载，下载地址：Index of /releases/1604emgaMTkzMDcyNTg1NC4xNjY3ODkyODY2ga_8BKGRQKRPV*MTY4NzMxMzg1OC43LjEuMTY4NzMxMzg4NS4zMy4wLjA.

3.1.2 准备依赖环境

执行命令：yum install -y gcc tcl

3.1.3 上传并解压包

tar -zxvf redis-6.2.11

cd redis-6.2.11

3.2 执行安装

进入到解压后的主目录，执行下面的命令

make && make install

看到下面的效果，说明安装成功

四、搭建redis主从集群

4.1 环境准备

我们知道，哨兵集群的目的是为了监控主从集群中的master节点的状态，一旦master节点挂掉了，可以迅速选出一个新的主节点，从而坐到自动故障切换，所以需要先搭建一个主从集群，规划如下

机器地址	端口	角色
192.168.9.131	7001	master
192.168.9.131	7002	slave
192.168.9.131	7003	slave

4.2 搭建过程

4.2.1 创建实例文件目录

在主目录下创建3个文件夹，分别为7001，7002，7003，文件名称可以自定，这里是为了方便区分多个实例，通过端口号的形式命名；

mkdir 7001 7002 7003

4.2.2 修改redis.conf配置文件

备份一下原始的redis主目录中的redis.conf文件没然后编辑redis.conf文件，修改下面两行配置

bind 0.0.0.0

protected-mode no  #本地测试验证吗，暂时关掉包含模式

4.2.3 拷贝配置文件

从redis的主目录中拷贝redis.conf文件分别到7001，7002，7003中

cp redis.conf ./7001

cp redis.conf ./7002

cp redis.conf ./7003

4.2.4 修改配置文件端口信息

由于这里是单机，为了区分多个实例，以端口来区分，分别进入到3个目录下，将端口号修分别修改为 7001，7002，7003，主要修改里面的端口号，依次修改为7001，7002，7003，其他的配置暂时不做修改；

也可以通过下面的命令进行批量修改

sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \//usr/local/redis/7001\//g' slave1/redis.conf
sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \//usr/local/redis/7002\//g' slave2/redis.conf
sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \//usr/local/redis/7003\//g' slave3/redis.conf

4.2.5 修改声明的IP地址

虚拟机本身存在多个IP，为了避免将来混乱，需要在redis.conf文件中指定每一个实例的绑定ip信息，格式如下：

replica-announce-ip 当前IP

仍然可以使用批量修改的方式进行编辑

sed -i '1a replica-announce-ip 120.26.108.145' 7001/redis.conf
sed -i '1a replica-announce-ip 120.26.108.145' 7002/redis.conf
sed -i '1a replica-announce-ip 120.26.108.145' 7003/redis.conf

4.2.6 启动redis实例

上面的配置就完成了，在主目录下执行下面的命令依次启动3个redis实例，我这里使用的是后台启动，也可以直接前台启动，去掉nohup即可；

nohup redis-server /usr/local/redis/7001/redis.conf &
nohup redis-server /usr/local/redis/7002/redis.conf &
nohup redis-server /usr/local/redis/7003/redis.conf &

通过ps查看进程，可以看到3个实例都已经起来了

4.2.7 开启主从关系

上面启动了3个实例，但是他们之间还并没有形成主从关系，要配置主从可以使用replicaof 或者slaveof（5.0以前）命令。

有临时和永久两种模式：

修改配置文件（永久生效），在redis.conf中添加一行配置： slaveof <masterip> <masterport>；
使用redis-cli客户端连接到redis服务，执行slaveof命令（重启后失效）： slaveof <masterip> <masterport>；

这里为了演示看出效果，我们采用第二种方式进行说明，在任意的shelli窗口，执行redis-cli命令连接7002，执行下面的命令：

redis-cli -p 7002

然后通过命令：info repliaction可以检查当前实例的身份

在另一个窗口连接7003这个实例客户端，使用相同的方式操作即可，到这里，一主两从的主从集群就搭建好了，当然也可以验证下效果，比如在从节点的命令行中，set一个key，可以看到下面的效果；

五、搭建redis哨兵集群

基于上述已经搭建好的主从集群模式下，开始搭建哨兵集群，关于哨兵集群的原理相关的知识，有兴趣的同学可以参考相关的资料，网上比较丰富；

5.1 添加哨兵配置文件

5.1.1 在三个目录下添加配置文件

在7001，7002，7003三个目录下，分别添加一个 sentinel.conf的文件，以7001目录的该配置为例，将下面的配置拷贝进去

port 27001
bind 0.0.0.0 #云服务测试的时候建议这样配置
sentinel announce-ip #"你的IP"
sentinel monitor mymaster #你的IP 7001 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
dir "/usr/local/redis/7001"

关于上述配置算是极简版的，对各项内容简单说明一下：

port 27001：是当前sentinel实例的端口
sentinel monitor mymaster IP 7001 2：指定主节点信息
mymaster：主节点名称，自定义，任意写
IP 7001：主节点的ip和端口
2：选举master时的quorum值

5.1.2 拷贝配置文件

然后将7001目录下的该配置文件依次拷贝到其他3个目录下，拷贝过去之后，注意修改下面两个地方，即端口号和dir的位置，本次哨兵的三个端口为：27001，27002，27003；

5.2 启动哨兵集群

在当前主目录下依次执行下面的3行命令，启动3个哨兵

redis-sentinel 7001/sentinel.conf
redis-sentinel 7002/sentinel.conf
redis-sentinel 7003/sentinel.conf

3个哨兵启动后效果依次如下，可以看到各自监听的端口；

5.3 故障模拟

下面将主节点7001的redis实例对应的进程kill掉，然后看看哨兵控制台的日志信息变化如何

5.3.1 哨兵控制台日志

kill掉7001的实例之后，通过控制台日志，可以捕获到sentinel的关键日志信息，但是每个sentinel的日志信息稍有差异，从上到小，分别为监控的7001~7003的三个redis实例的sentinel日志信息；

关于里面的日志内容，有兴趣的同学可以参阅相关的资料进行深入的学习和解读，这些日志的输出其实也就是redis哨兵集群进行master节点选举的完整流程；

5.4 故障恢复

通过上述的命令再次开启7001的实例；

5.4.1 哨兵控制台日志

再次启动7001的实例后，不难发现，此时被sentinel集群监控到了，但是此时只能作为一个slave的角色加入到集群中，如下展示了三个sentinel实例监控时的日志信息，从上到下，分别为监控的7001~7003的三个redis实例的sentinel日志信息；

如果我们再次使用redis-cli命令登录到7002的客户端，使用info命令查看一下，可以看到此时的7002已经成为master节点，这个与sentinel中输出的日志信息也是吻合的；

六、springboot整合redis哨兵集群

搭建完成了哨兵集群后，接下来演示下如何在微服务中整合使用。

6.1 前置准备

6.1.1 搭建一个springboot工程

完整的工程目录如下

6.1.2 引入核心依赖

引入必须的jar，其他的可以根据自身情况引入

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>

    </dependencies>

6.2 核心代码

6.2.1 哨兵配置类

添加一个哨兵配置类，用于配置哨兵相关的信息

package com.congge.config;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Configuration
@EnableAutoConfiguration
public class RedisSentinelConfig {
    private static Logger logger = LoggerFactory.getLogger(RedisSentinelConfig.class);

    @Value("#{'${spring.redis.sentinel.nodes}'.split(',')}")
    private List<String> nodes;

    @Value("${spring.redis.sentinel.nodes}")
    private String redisNodes;

    @Value("${spring.redis.sentinel.master}")
    private String master;

    //redis的连接池
    @Bean(name = "poolConfig")
    @ConfigurationProperties(prefix = "spring.redis")
    public JedisPoolConfig poolConfig() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        return poolConfig;
    }

    
    @Bean
    public RedisSentinelConfiguration sentinelConfiguration() {
        RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
        //配置matser的名称
        redisSentinelConfiguration.master(master);
        //数据库是1库
        redisSentinelConfiguration.setDatabase(1);
        //配置redis的哨兵sentinel
        Set<RedisNode> redisNodeSet = new HashSet<>();
        nodes.forEach(x -> {
            redisNodeSet.add(new RedisNode(x.split(":")[0], Integer.parseInt(x.split(":")[1])));
        });
        logger.info("redisNodeSet -->" + redisNodeSet);
        redisSentinelConfiguration.setSentinels(redisNodeSet);
        return redisSentinelConfiguration;
    }

   
    @Bean("redisConnectionFactory")
    public JedisConnectionFactory redisConnectionFactory(
            JedisPoolConfig poolConfig,
            RedisSentinelConfiguration sentinelConfig) {
        return new JedisConnectionFactory(sentinelConfig, poolConfig);
    }
}

6.2.2 redistemplate配置类

在该配置类中针对ke/value进行序列化相关设置，非必须，如果不设置将会使用java默认的序列化；

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

@Configuration
public class RedisConfig {

    /**
     * 方法描述： 初始化redis连接
     * @param redisConnectionFactory redis连接工厂
     * @return {@link RedisTemplate}
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 新建redisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置工厂
        template.setConnectionFactory(redisConnectionFactory);
        //序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //1，用StringRedisSerializer进行序列化的值，在Java和Redis中保存的内容是一样的
        //2，用Jackson2JsonRedisSerializer进行序列化的值，在Redis中保存的内容，比Java中多了一对双引号。
        //3，用JdkSerializationRedisSerializer进行序列化的值，对于Key-Value的Value来说，是在Redis中是不可读的。对于Hash的Value来说，比Java的内容多了一些字符。
        //如果Key的Serializer也用和Value相同的Serializer的话，在Redis中保存的内容和上面Value的差异是一样的，所以我们保存时，只用StringRedisSerializer进行序列化
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(stringRedisSerializer);
        // 返回redisTemplate对象
        return template;
    }
}

6.2.3 添加测试接口

增加一个测试接口，测试在接口中操作哨兵集群

@RestController
@RequestMapping("/redis")
public class RedisController {


    @Autowired
    private RedisTemplate redisTemplate;

    //localhost:8083/redis/setValue?key=address&value=hangzhou
    @GetMapping("setValue")
    public String setValue(String key,String value) {
        redisTemplate.opsForValue().set(key, value);
        return "true";
    }

    //localhost:8083/redis/getValue?key=address
    @GetMapping("getValue")
    public String getValue(String key) {
        String value = (String) redisTemplate.opsForValue().get(key);
        System.out.println(value);
        return value;
    }

}