java jedis 连哨兵 java连接redis哨兵

楔子：某个时间，由于不清不楚的某些原因，导致了一次严重的线上事故。后来，开发不清不楚的配合把项目升级到了 Redis 高可用集群的哨兵模式（Redis-Sentinel），再后来，我们逐渐的又不清不楚的淡忘了这件事。节点化的工作很容易导致一定程度上只知其然而不知其所以然，这是项目开发中的一个众相。回想起来，我还是想记点什么。

该篇可以为 Redis 容灾+高可用 应用场景提供解决方案。

1. 前置任务

本文为 上一击 的代码验证部分，是以 Redis进击（三）搭建Redis高可用集群的哨兵模式（Redis-Sentinel）【Windows环境】为基础进行的测试和验证。所以在进行测试或验证前，请确保以下前置任务正常：

1. Redis 主节点（master ）的服务端正常开启；所有分节点（slave）的服务端正常开启
2. Redis 主节点的 Sentinel（哨兵）正常开启；所有分节点的 Sentinel 正常开启

注：如果主节点/从节点的服务端、Sentinel 没有全部正常开启的话，会出现异常：JedisConnectionException: All sentinels down, cannot determine where is 127.0.0.1 master is running...

 

2. Spring 项目测试

场景一：Spring 项目中配置和使用 Redis 高可用集群的哨兵模式（Redis-Sentinel） 

2.1. 配置

2.1.1. 添加POM依赖

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

2.1.2. 配置文件

（1）classpath:redis.properties

redis.host=127.0.0.1
redis.port=6380
redis.timeout=3000
redis.pool.maxIdle=50
redis.pool.testOnBorrow=true
redis.pool.maxWaitMillis=3000
redis.sentinel.master=mymaster
redis.sentinel.node1=127.0.0.1:26379
redis.sentinel.node2=127.0.0.1:26380
redis.sentinel.node3=127.0.0.1:26381

注意：redis.sentinel.master 配置项的值必须与主节点/主服务器 sentinel.conf 配置文件中的 sentinel monitor mymaster 127.0.0.1 6379 3 的 主节点/主服务器名称 mymaster 保持一致。

否则，会出现异常：JedisException: Can connect to sentinel, but 127.0.0.1:6380 seems to be not monitored...

 

（2）classpath:spring-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util.xsd">

    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!--向资源池借用连接时是否做连接有效性检测（ping）。检测到的无效连接将会被移除。如果为true，则得到的jedis实例均是可用的-->
        <property name="testOnBorrow" value="true"/>
        <!--资源池中的最大连接数，默认8个-->
        <property name="maxTotal" value="50" />
        <!--资源池允许的最大空闲连接数，默认8个-->
        <property name="maxIdle" value="50" />
        <!--当资源池连接用尽后，调用者的最大等待时间（单位为毫秒）。-->
        <property name="maxWaitMillis" value="3000" />
    </bean>

    <util:set id="sentinels">
        <value>${redis.sentinel.node1}</value>
        <value>${redis.sentinel.node2}</value>
        <value>${redis.sentinel.node3}</value>
    </util:set>

    <bean id="jedisPool" class="redis.clients.jedis.JedisSentinelPool" destroy-method="destroy"
          c:poolConfig-ref="jedisPoolConfig" c:sentinels-ref="sentinels"
          c:masterName="${redis.sentinel.master}"/>

    <!--这里没有配置密码，所以不需求使用此项配置-->
    <!--<bean id="jedisPool" class="redis.clients.jedis.JedisSentinelPool" destroy-method="destroy"-->
          <!--c:poolConfig-ref="jedisPoolConfig" c:sentinels-ref="sentinels"-->
          <!--c:masterName="${redis.sentinel.master}" c:password="${redis.password}"/>-->
</beans>

 

2.2 单元测试

2.2.1. JUnit 测试

配置 testApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.mwei.remote.redis"/>

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:redis/redis.properties</value>
            </list>
        </property>
    </bean>

    <import resource="classpath:redis/spring-redis.xml"/>

</beans>

测试类：

package com.mwei.remote.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:testApplicationContext.xml")
public class JedisPoolTest {

    @Autowired
    private JedisSentinelPool jedisPool;

    @Test
    public void testJedisPool4Get() {
        Jedis jedis = null;

        try {
            jedis = jedisPool.getResource();
            jedis.set("uid_010_name", "美味物语");
            System.out.println("uid_010_name : " + jedis.get("uid_010_name"));
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

输出结果，验证OK：

uid_010_name : 美味物语

 

2.2.2. 工具类测试

与 JUnit 测试方式不一样的是，下面的测试方法省去了诸多配置项，只需要进行测试类编写和运行：

package com.weix.service.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;

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

public class JedisUtil {

    private static JedisSentinelPool jedisPool = null;

    // 自带的哨兵模式 JedisSentinelPool, 并在一开始初始化连接池
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            // 资源池中的最大连接数
            // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted（耗尽）
            config.setMaxTotal(Integer.valueOf(50));
            // 控制一个pool最多有多少个状态为idle（空闲的）的jedis实例
            config.setMaxIdle(Integer.valueOf(50));
            // 表示当borrow（引入）一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException
            config.setMinEvictableIdleTimeMillis(Integer.valueOf(-1));
            // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的
            config.setTestOnBorrow(Boolean.valueOf(true));

            // Setinel哨兵群
            // Setinel客户端提供了master自动发现功能
            Set<String> sentinels = new HashSet<>();
            sentinels.add("127.0.0.1:26379");
            sentinels.add("127.0.0.1:26380");
            sentinels.add("127.0.0.1:26381");

            // master名称必须要和配置文件sentinel.conf中配置保持一致
            jedisPool = new JedisSentinelPool("mymaster", sentinels, config);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 构建redis连接池
     *
     * @return JedisPool
     */
    public static JedisSentinelPool getJedisPool() {
        return jedisPool;
    }

    /**
     * 测试redis线程池是否正常
     *
     * @param args
     */
    public static void main(String[] args) {
        JedisSentinelPool jedisSentinelPool = JedisUtil.getJedisPool();
        Jedis jedis = jedisSentinelPool.getResource();
        System.out.println("jedis = " + jedis);

        jedis.set("uid_020_name", "美味进击");
        System.out.println("uid_020_name : " + jedis.get("uid_020_name"));

        // Jedis 2.9.0 版本及以上的 JedisPool 的 returnBrokenResource() 和 returnResource() 方法被标注废弃了，取而代之的是 Jedis 的 close()
        if (jedis != null) {
            jedis.close();
        }
    }
}

输出结果，验证OK：

jedis = redis.clients.jedis.Jedis@379619aa
uid_020_name : 美味进击

 

---

3. SpringBoot 项目测试

场景二：Spring 项目中配置和使用 Redis 高可用集群的哨兵模式（Redis-Sentinel） 

3.1 配置

3.1.1. 添加POM依赖

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

 

3.1.2. 配置文件

（1）classpath:application.yml

spring:
  redis:
    jedis:
      pool:
        max-idle: 8
        max-wait: 3000
    sentinel:
      master: mymaster
      nodes:
        - 127.0.0.1:26379
        - 127.0.0.1:26380
        - 127.0.0.1:26381

启动类：

package com.mwei;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 注解@SpringBootApplication是Sprnig Boot项目的核心注解，主要目的是开启自动配置
 */
@SpringBootApplication
//@PropertySource("file:/etc/dbprivatekey.properties") // Redis配置。因为没有配置也没有用到密码，所以这里先注释掉
public class MWeiSpringBootApplication {

    /**
     * 标准的Java应用的main的方法，主要作用是作为项目启动的入口
     * @param args
     */
    public static void main(String[] args) {
        SpringApplication.run(MWeiSpringBootApplication.class, args);
    }
}

测试类：

package com.mwei.utils;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class JedisUtilTest extends SpringBootServletInitializer {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testRedisTemplate4Get() {
        this.redisTemplate.opsForValue().set("uid_030_name", "美味书签");
        System.out.println("uid_030_name : " + this.redisTemplate.opsForValue().get("uid_030_name"));
    }
}

输出结果，验证OK：

uid_030_name : 美味书签

 

好了，到此，Sping 和 SpringBoot 两种项目下的 Redis 高可用集群的哨兵模式（Redis-Sentinel） 已经验证完成，且结果完美。

---