1. 環(huán)境準(zhǔn)備

192.168.3.26: Master 實例, Sentinel 1
192.168.3.27: Slave1 實例, Sentinel 2
192.168.3.28:Slave2 實例, Sentinel 3

1.1 Redis Sentinel 集群(一主二從三個 Sentinel)

Redis Sentinel 集群的搭建過程可以參考帥帥之前的文章 Redis 高可用專題-- Sentinel 哨兵模式

注意: 目前的 master 是 192.168.3.27, 即經(jīng)過故障轉(zhuǎn)移后 slave1 目前是 Master

1.2 SpringBoot 環(huán)境

SpringBoot 版本: 2.3.2.RELEASE

2. 引入依賴

         
         
            org.springframework.boot
            spring-boot-starter-data-redis
        

        
        
            org.apache.commons
            commons-pool2
        

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine

SpringBoot 2.x 的 Redis 客戶端已經(jīng)從 Jedis 切換到了 Lettuce

3. 配置

在 application.yml 配置文件中編輯 Sentinel 信息


spring:
   application:
      name: sb-redis-sentinel

   # redis 配置
   redis:
      database: 1
      # 數(shù)據(jù)節(jié)點密碼
      password: javaFamily123!!

      sentinel:
         master: mymaster
         # Sentinel 連接密碼, 如果沒配置就不寫
         # password:
         nodes:
            - 192.168.3.26:26379
            - 192.168.3.27:26379
            - 192.168.3.28:26379

      # 配置 lettuce 客戶端連接池信息
      lettuce:
         pool:
            # 連接池中的最小空閑連接
            min-idle: 5
            # 連接池中的最大空閑連接
            max-idle: 10
            # 連接池的最大數(shù)據(jù)庫連接數(shù)
            max-active: 100
            # 連接池最大阻塞等待時間（使用負值表示沒有限制）
            max-wait: -1

這里只需要配置 Sentinel 節(jié)點.?客戶端會自動從 sentinel 獲取數(shù)據(jù)節(jié)點信息.

配置 Redis 連接池、RedisTemplate

package club.javafamily.sbredissentinel.conf;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
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.RedisNode;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.*;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Jack Li
 * @date 2022/5/8 下午6:42
 * @description Redis 哨兵配置
 */
@Configuration
public class RedisConfig {

   private final RedisProperties redisProperties;

   public RedisConfig(RedisProperties redisProperties) {
      this.redisProperties = redisProperties;
   }

   /**
    * 創(chuàng)建 Redis 連接池配置
    */
   @Bean
   public GenericObjectPoolConfig poolConfig() {
      GenericObjectPoolConfig config = new GenericObjectPoolConfig();
      config.setMinIdle(redisProperties.getLettuce().getPool().getMinIdle());
      config.setMaxIdle(redisProperties.getLettuce().getPool().getMaxIdle());
      config.setMaxTotal(redisProperties.getLettuce().getPool().getMaxActive());
      config.setMaxWaitMillis(redisProperties.getLettuce().getPool().getMaxWait().toMillis());

      return config;
   }

   /**
    * 聲明哨兵配置, 將哨兵信息放到配置中
    */
   @Bean
   public RedisSentinelConfiguration sentinelConfig() {
      RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();
      redisConfig.setMaster(redisProperties.getSentinel().getMaster());
      redisConfig.setPassword(redisProperties.getPassword());

      if(redisProperties.getSentinel().getNodes()!=null) {
         List sentinelNode = new ArrayList();

         for(String sen : redisProperties.getSentinel().getNodes()) {
            String[] arr = sen.split(":");
            sentinelNode.add(new RedisNode(arr[0],Integer.parseInt(arr[1])));
         }

         redisConfig.setSentinels(sentinelNode);
      }

      return redisConfig;
   }

   /**
    * 創(chuàng)建連接工廠 LettuceConnectionFactory
    */
   @Bean("lettuceConnectionFactory")
   public LettuceConnectionFactory lettuceConnectionFactory(
      @Qualifier("poolConfig") GenericObjectPoolConfig config,
      @Qualifier("sentinelConfig") RedisSentinelConfiguration sentinelConfig)
   {
      LettuceClientConfiguration clientConfiguration
         = LettucePoolingClientConfiguration.builder()
         .poolConfig(config)
         .build();

      return new LettuceConnectionFactory(sentinelConfig, clientConfiguration);
   }

   /**
    * 創(chuàng)建 RedisTemplate
    */
   @Bean("stringObjectRedisTemplate")
   public RedisTemplate stringObjectRedisTemplate(
      @Qualifier("lettuceConnectionFactory") LettuceConnectionFactory connectionFactory)
   {
      RedisTemplate redisTemplate = new RedisTemplate<>();
      redisTemplate.setConnectionFactory(connectionFactory);

      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
      GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer
         = new GenericJackson2JsonRedisSerializer();

      //設(shè)置序列化器
      redisTemplate.setKeySerializer(stringRedisSerializer);
      redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
      redisTemplate.setHashKeySerializer(stringRedisSerializer);
      redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
      redisTemplate.afterPropertiesSet();

      return redisTemplate;
   }
}

4. 正常測試

讀寫測試

package club.javafamily.sbredissentinel;

import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

@SpringBootTest
class SbRedisSentinelApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    ValueOperations opsForValue;

    @BeforeEach
    public void init() {
        opsForValue = redisTemplate.opsForValue();
    }

    @Test
    void contextLoads() {
        Assertions.assertNotNull(redisTemplate);
    }

    @Test
    void writeTest() {
        opsForValue.set("tsb1", "springboot");
    }

    @Test
    void readTest() {
        final String value = (String) opsForValue.get("tsb1");

        System.out.println(value);
    }

}

在 slave 節(jié)點讀取

可以看到主從復(fù)制及讀寫都沒問題.

5. 主節(jié)點 Master 宕機測試

哨兵的一大作用即就是自動故障轉(zhuǎn)移, 因此, 我們測試一下主節(jié)點宕機后在?SpringBoot 應(yīng)用不重啟的情況下, SpringBoot 應(yīng)用是否還可以繼續(xù)正常工作.

寫一個 Controller 接收讀寫請求, 啟動并讓 SpringBoot 處于運行狀態(tài)

package club.javafamily.sbredissentinel.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;

/**
 * @author Jack Li
 * @date 2022/5/8 下午11:43
 * @description
 */
@RestController
public class RedisTestController {

   private final RedisTemplate redisTemplate;

   public RedisTestController(RedisTemplate redisTemplate) {
      this.redisTemplate = redisTemplate;
   }

   @GetMapping("/write")
   public String write(@RequestParam("key") String key,
                       @RequestParam("value") String val)
   {
        // 寫入
      redisTemplate.opsForValue().set(key, val);

      // 讀取并返回
      return (String) redisTemplate.opsForValue().get(key);
   }
}