redis初始化问题汇总

本是古典何须时尚 2023-06-30 02:24 57阅读 0赞

1. *all* *sentinels down*, cannot determine where is redis-sentinel master is running

本地连接的测试环境，本地跟测试环境打不通。被防火墙拦住了。

2.JedisDataException: NOAUTH Authentication required.

给jedisConnectionFactory.setPassword("xxxx")

3.org.springframework.data.redis.RedisConnectionFailureException: Cannot get Jedis connection; nested exception is redis.clients.jedis.exceptions.JedisException: Could not get a resource from the pool

给如下两个属性分别赋值

jedisPoolConfig.setMaxIdle(50);

jedisPoolConfig.setMaxTotal(100);

@Bean
    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
        jedisPoolConfig.setMaxIdle(50);
        jedisPoolConfig.setMaxTotal(100);
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig, jedisPoolConfig);
        jedisConnectionFactory.setPassword("xxxx");
       // jedisConnectionFactory.setHostName("127.0.0.1");
        return jedisConnectionFactory;
    }

4.附上初始化全部代码。

@Configuration
    public class RedisClusterConfig {
        @Autowired
        private RedisClusterSettings redisClusterSettings;
    
        @Bean
        public JedisPoolConfig getJedisPoolConfig() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            // 最大空闲数
            jedisPoolConfig.setMaxIdle(redisClusterSettings.getMaxIdle());
            // 连接池的最大数据库连接数
            jedisPoolConfig.setMaxTotal(redisClusterSettings.getMaxTotal());
            // 最大建立连接等待时间
            jedisPoolConfig.setMaxWaitMillis(redisClusterSettings.getMaxWaitMillis());
            // 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
            jedisPoolConfig.setMinEvictableIdleTimeMillis(redisClusterSettings.getMinEvictableIdleTimeMillis());
            // 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
            jedisPoolConfig.setNumTestsPerEvictionRun(redisClusterSettings.getNumTestsPerEvictionRun());
            // 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
            jedisPoolConfig.setTimeBetweenEvictionRunsMillis(redisClusterSettings.getTimeBetweenEvictionRunsMillis());
            // 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
            jedisPoolConfig.setTestOnBorrow(redisClusterSettings.isTestOnBorrow());
            // 在空闲时检查有效性, 默认false
            jedisPoolConfig.setTestWhileIdle(redisClusterSettings.isTestWhileIdle());
            return jedisPoolConfig;
        }
    
        /**
         * Redis集群的配置
         * @return RedisClusterConfiguration
         * @throws
         */
    //    @Bean
    //    public RedisClusterConfiguration redisClusterConfiguration(){
    //        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
    //        //Set<RedisNode> clusterNodes
    //        String[] serverArray = redisClusterSettings.getClusterNodes().split(",");
    //        Set<RedisNode> nodes = new HashSet<RedisNode>();
    //        for(String ipPort:serverArray){
    //            String[] ipAndPort = ipPort.split(":");
    //            nodes.add(new RedisNode(ipAndPort[0].trim(),Integer.valueOf(ipAndPort[1])));
    //        }
    //        redisClusterConfiguration.setClusterNodes(nodes);
    //        redisClusterConfiguration.setMaxRedirects(redisClusterSettings.getMaxRedirects());
    //        redisClusterConfiguration.setPassword(RedisPassword.of(redisClusterSettings.getPassword()));
    //        return redisClusterConfiguration;
    //    }
    
        /**
         * 配置redis的哨兵
         *
         */
        @Bean
        public RedisSentinelConfiguration sentinelConfiguration() {
            RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
    //        配置redis的哨兵sentinel
    
         //   String[] serverArray = redisClusterSettings.getClusterNodes().split(",");
            String[] serverArray = "xxx:8001,yyy:8001,zzz:8001".split(",");
            Set<RedisNode> nodes = new HashSet<RedisNode>();
            for(String ipPort:serverArray){
                String[] ipAndPort = ipPort.split(":");
                nodes.add(new RedisNode(ipAndPort[0].trim(),Integer.valueOf(ipAndPort[1])));
            }
            redisSentinelConfiguration.setSentinels(nodes);
           // redisSentinelConfiguration.setMaster(redisClusterSettings.getMasterName());
             //mymaster为redis集群名字
            redisSentinelConfiguration.setMaster("mymaster");
            return redisSentinelConfiguration;
        }
    
    
        /**
         * @param
         * @return
         * @Description:redis连接工厂类
         * @date 2018/10/25 19:45
         */
    //    @Bean
    //    public JedisConnectionFactory jedisConnectionFactory() {
    //        //集群模式
    //        JedisConnectionFactory  factory = new JedisConnectionFactory(redisClusterConfiguration(),getJedisPoolConfig());
    //        factory.setDatabase(0);
    //        factory.setTimeout(redisClusterSettings.getTimeout());
    //        factory.setUsePool(true);
    //        return factory;
    //    }
    
        /**
         * 配置工厂
         *
         * @param jedisPoolConfig
         * @return
         */
        @Bean
        public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
            jedisPoolConfig.setMaxIdle(50);
            jedisPoolConfig.setMaxTotal(100);
            JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig, jedisPoolConfig);
          //  jedisConnectionFactory.setPassword(redisClusterSettings.getPassword());
            jedisConnectionFactory.setPassword("xxxxxx");
           // jedisConnectionFactory.setHostName("127.0.0.1");
            return jedisConnectionFactory;
        }
        /**
         * 实例化 RedisTemplate 对象
         *
         * @return
         */
        @Bean
        public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
            return redisTemplate;
        }
        /**
         * 设置数据存入 redis 的序列化方式,并开启事务
         *
         * @param redisTemplate
         * @param factory
         */
        private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
            //如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
            redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            // 开启事务
            redisTemplate.setEnableTransactionSupport(true);
            redisTemplate.setConnectionFactory(factory);
        }
    
        /**
         * 封装RedisTemplate
         *
         */
        @Bean(name = "redisUtils")
        public RedisUtils redisUtil(RedisTemplate<String, Object> redisTemplate) {
            RedisUtils redisUtil = new RedisUtils();
            redisUtil.setRedisTemplate(redisTemplate);
            return redisUtil;
        }
    
    }

5.其实本人也是对着xml配置，看看自己初始化的时候少了啥。才把如上三个问题解决。

**主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。**这不是一种推荐的方式，更多时候，我们优先考虑**哨兵模式**。

## 一、哨兵模式概述 ##

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是**哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。**

![format_png][]

Redis哨兵

这里的哨兵有两个作用

*  通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
 *  当哨兵监测到master宕机，会自动将slave切换成master，然后通过**发布订阅模式**通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

用文字描述一下**故障切换（failover）**的过程。假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为**主观下线**。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为**客观下线**。这样对于客户端而言，一切都是透明的。

## 二、Redis配置哨兵模式 ##

配置3个哨兵和1主2从的Redis服务器来演示这个过程。

<table> 
 <thead> 
  <tr> 
   <th>服务类型</th> 
   <th>是否是主服务器</th> 
   <th>IP地址</th> 
   <th>端口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Redis</td> 
   <td>是</td> 
   <td>192.168.11.128</td> 
   <td>6379</td> 
  </tr> 
  <tr> 
   <td>Redis</td> 
   <td>否</td> 
   <td>192.168.11.129</td> 
   <td>6379</td> 
  </tr> 
  <tr> 
   <td>Redis</td> 
   <td>否</td> 
   <td>192.168.11.130</td> 
   <td>6379</td> 
  </tr> 
  <tr> 
   <td>Sentinel</td> 
   <td>-</td> 
   <td>192.168.11.128</td> 
   <td>26379</td> 
  </tr> 
  <tr> 
   <td>Sentinel</td> 
   <td>-</td> 
   <td>192.168.11.129</td> 
   <td>26379</td> 
  </tr> 
  <tr> 
   <td>Sentinel</td> 
   <td>-</td> 
   <td>192.168.11.130</td> 
   <td>26379</td> 
  </tr> 
 </tbody> 
</table>

![format_png 1][]

多哨兵监控Redis

首先配置Redis的主从服务器，修改redis.conf文件如下

# 使得Redis服务器可以跨网络访问
    bind 0.0.0.0
    # 设置密码
    requirepass "123456"
    # 指定主服务器，注意：有关slaveof的配置只是配置从服务器，主服务器不需要配置
    slaveof 192.168.11.128 6379
    # 主服务器密码，注意：有关slaveof的配置只是配置从服务器，主服务器不需要配置
    masterauth 123456

上述内容主要是配置Redis服务器，从服务器比主服务器多一个slaveof的配置和密码。

配置3个哨兵，每个哨兵的配置都是一样的。在Redis安装目录下有一个sentinel.conf文件，copy一份进行修改

# 禁止保护模式
    protected-mode no
    # 配置监听的主服务器，这里sentinel monitor代表监控，mymaster代表服务器的名称，可以自定义，192.168.11.128代表监控的主服务器，6379代表端口，2代表只有两个或两个以上的哨兵认为主服务器不可用的时候，才会进行failover操作。
    sentinel monitor mymaster 192.168.11.128 6379 2
    # sentinel author-pass定义服务的密码，mymaster是服务名称，123456是Redis服务器密码
    # sentinel auth-pass <master-name> <password>
    sentinel auth-pass mymaster 123456

上述关闭了保护模式，便于测试。

有了上述的修改，我们可以进入Redis的安装目录的src目录，通过下面的命令启动服务器和哨兵

# 启动Redis服务器进程
    ./redis-server ../redis.conf
    # 启动哨兵进程
    ./redis-sentinel ../sentinel.conf

注意启动的顺序。**首先是主机（192.168.11.128）的Redis服务进程，然后启动从机的服务进程，最后启动3个哨兵的服务进程。**

## 三、Java中使用哨兵模式 ##

/**
     * 测试Redis哨兵模式
     * @author liu
     */
    public class TestSentinels {
        @SuppressWarnings("resource")
        @Test
        public void testSentinel() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(10);
            jedisPoolConfig.setMaxIdle(5);
            jedisPoolConfig.setMinIdle(5);
            // 哨兵信息
            Set<String> sentinels = new HashSet<>(Arrays.asList("192.168.11.128:26379",
                    "192.168.11.129:26379","192.168.11.130:26379"));
            // 创建连接池
            JedisSentinelPool pool = new JedisSentinelPool("mymaster", sentinels,jedisPoolConfig,"123456");
            // 获取客户端
            Jedis jedis = pool.getResource();
            // 执行两个命令
            jedis.set("mykey", "myvalue");
            String value = jedis.get("mykey");
            System.out.println(value);
        }
    }

上面是通过Jedis进行使用的，同样也可以使用Spring进行配置RedisTemplate使用。

## 四、哨兵模式的其他配置项 ##

<table> 
 <thead> 
  <tr> 
   <th>配置项</th> 
   <th>参数类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>port</td> 
   <td>整数</td> 
   <td>启动哨兵进程端口</td> 
  </tr> 
  <tr> 
   <td>dir</td> 
   <td>文件夹目录</td> 
   <td>哨兵进程服务临时文件夹，默认为/tmp，要保证有可写入的权限</td> 
  </tr> 
  <tr> 
   <td>sentinel down-after-milliseconds</td> 
   <td>&lt;服务名称&gt;&lt;毫秒数（整数）&gt;</td> 
   <td>指定哨兵在监控Redis服务时，当Redis服务在一个默认毫秒数内都无法回答时，单个哨兵认为的主观下线时间，默认为30000（30秒）</td> 
  </tr> 
  <tr> 
   <td>sentinel parallel-syncs</td> 
   <td>&lt;服务名称&gt;&lt;服务器数（整数）&gt;</td> 
   <td>指定可以有多少个Redis服务同步新的主机，一般而言，这个数字越小同步时间越长，而越大，则对网络资源要求越高</td> 
  </tr> 
  <tr> 
   <td>sentinel failover-timeout</td> 
   <td>&lt;服务名称&gt;&lt;毫秒数（整数）&gt;</td> 
   <td>指定故障切换允许的毫秒数，超过这个时间，就认为故障切换失败，默认为3分钟</td> 
  </tr> 
  <tr> 
   <td>sentinel notification-script</td> 
   <td>&lt;服务名称&gt;&lt;脚本路径&gt;</td> 
   <td>指定sentinel检测到该监控的redis实例指向的实例异常时，调用的报警脚本。该配置项可选，比较常用</td> 
  </tr> 
 </tbody> 
</table>

sentinel down-after-milliseconds配置项只是一个哨兵在超过规定时间依旧没有得到响应后，会自己认为主机不可用。对于其他哨兵而言，并不是这样认为。哨兵会记录这个消息，当拥有认为主观下线的哨兵达到sentinel monitor所配置的数量时，就会发起一次投票，进行failover，此时哨兵会重写Redis的哨兵配置文件，以适应新场景的需要。

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMTMyMDAzOS01N2E3N2NhMjc1N2QwOTI0LnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwfGltYWdlVmlldzIvMi93LzUwNy9mb3JtYXQvd2VicA?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMTMyMDAzOS0zZjQwYjE3YzA0MTIxMTZjLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwfGltYWdlVmlldzIvMi93Lzc0Ny9mb3JtYXQvd2VicA?x-oss-process=image/format,png