12、Spring技术栈-Redis Sentinel实现高可用缓存集群方案实战

最新推荐文章于 2024-07-06 23:23:37 发布
最新推荐文章于 2024-07-06 23:23:37 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： Spring Web开发实战 Redis Spring Web开发实战专栏 文章标签： redis Sentinel Redis哨兵 redis高可用 spring整合redis集群
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyhlwzy/article/details/78541212
版权

Redis Sentinel的分布式特性介绍

Redis Sentinel是一个分布式系统，Sentinel运行在有许多Sentinel进程互相合作的环境下，它本身就是这样被设计的。有许多Sentinel进程互相合作的优点如下：

  1. 当多个Sentinel同意一个master不再可用的时候，就执行故障检测。这明显降低了错误概率。
  2. 即使并非全部的Sentinel都在工作，Sentinel也可以正常工作，这种特性，让系统非常的健康。

所有的Sentinels，Redis实例，连接到Sentinel和Redis的客户端，本身就是一个有着特殊性质的大型分布式系统。在这篇文章中，我将通过实例的形式从部署Redis Sentinel集群、使用Redis的Master Slave的模式部署Redis集群来介绍在Spring项目中如何使用Redis Sentinel实现缓存系统的高可用。

部署之前了解关于Sentinel的基本东西

  1. 一个健康的集群部署，至少需要三个Sentinel实例
  2. 三个Sentinel实例应该被放在失败独立的电脑上或虚拟机中，比如说不同的物理机或者在不同的可用区域上执行的虚拟机。
  3. Sentinel + Redis 分布式系统在失败期间并不确保写入请求被保存，因为Redis使用异步复制。可是有很多部署Sentinel的 方式来让窗口把丢失写入限制在特定的时刻，当然也有另外的不安全的方式来部署。
  4. 客户端必须支持Sentinel。大多数客户端库都支持Sentinel，但并不是全部。
  5. 没有高可用的设置是安全的，如果你在你的测试环境没有经常去测试，或者甚至在生产环境中你也没有经常去测试，如果Sentinel正常工作。 但是你或许有一个错误的配置而仅仅只是在很晚的时候才出现（凌晨3点你的主节点宕掉了）。
  6. Sentinel，Docker ，其他的网络地址转换表，端口映射应该很小心的使用：Docker执行端口重新映射，破坏Sentinel自动发现另外的Sentinel进程和一个主节点的从节点列表。在文章的稍后部分查看更过关于Sentinel和Docker的信息。

实例介绍

  1. 本实例通过部署3个Redis Sentinel实现Sentinel实例的高可用。
  2. 本实例通过部署1个Redis Master实例，3个Slave实例实现Redis缓存的高可用。

Redis Master实例和Slave实例部署

下载并安装Redis，此文不讲解，具体可参考http://blog.csdn.net/zyhlwzy/article/details/78366265。

可参考Redis主从（Master-Slave）复制（Replication）设置一文第8节Redis主从复制实战的部署方式部署Master-Slave，但是需要注意的是，本文需要的是一个Master实例，3个Slave实例。

Redis实例信息如下：

IPPort备注
192.168.199.1266379Master
192.168.199.2496382Slave
192.168.199.2496383Slave
192.168.199.2496384Slave

配置Master
下载并安装Redis，此文不讲解，具体可参考http://blog.csdn.net/zyhlwzy/article/details/78366265。

Master的配置很简单，我们开启守护进程即可（演示实例不设置验证信息，如有需要自行设置）。

进入redis配置文件目录（/data/redis/redis-4.0.1/redis.conf）编辑redis.conf进行如下配置。

daemonize yes

配置Slave

下载并安装Redis，此文不讲解，具体可参考http://blog.csdn.net/zyhlwzy/article/details/78366265。

创建Slave配置文件目录，拷贝redis.conf到对应目录并进行配置。

mkdir /data/redis/cluster
cd /data/redis/cluster
mkdir -p 6382
cp /data/redis/redis-4.0.1/redis.conf /data/redis/cluster/6382/redis-6382.conf
mkdir -p 6383
cp /data/redis/redis-4.0.1/redis.conf /data/redis/cluster/6383/redis-6383.conf
mkdir -p 6384
cp /data/redis/redis-4.0.1/redis.conf /data/redis/cluster/6384/redis-6384.conf

3个Slave实例的配置文件内容，注意修改下面加粗字体部分的内容即可（注意注释掉的要去掉注释），其他都相同：

配置选项选项值说明
daemonizeyes默认情况下 redis 不是作为守护进程运行的，如果你想让它在后台运行，你就把它改成 yes。
pidfile/data/redis/cluster/6382/redis-6382.pid当redis作为守护进程运行的时候，默认情况下它会写一个 pid 到 /var/run/redis.pid 文件里面
port6382监听端口号，默认为 6379，如果你设为 0 ，redis 将不在 socket 上监听任何客户端连接。
database1设置数据库的数目。
cluster-enabledno启用或停用集群
cluster-config-file/data/redis/cluster/6382/nodes-6382.conf集群配置文件，启动时自动生成
cluster-node-timeout15000节点互联超时时间，单位毫秒
cluster-migration-barrier1这个参数表示的是，一个主节点在拥有多少个好的从节点的时候就要割让一个从节点出来。
cluster-require-full-coverageyes如果集群中某些key space没有被集群中任何节点覆盖，集群将停止接受写入
appendonlyyes启用aof持久化方式
dir/data/redis/cluster/6382/节点数据持久化存放目录
slaveof192.168.199.126 6379Master节点配置

如果配置成功并启动，通过客户端工具连接到Master时，输入如下命令

info replication

将会得到如下结果

# Replication
role:master
connected_slaves:3
slave0:ip=192.168.199.249,port=6384,state=online,offset=1127147,lag=1
slave1:ip=192.168.199.249,port=6383,state=online,offset=1127292,lag=1
slave2:ip=192.168.199.249,port=6382,state=online,offset=1127292,lag=1
master_replid:beba8e13c44c5a4afcf8c82889b524b2f76faa22
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:1127292
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:78717
repl_backlog_histlen:1048576

Redis Sentinel部署

3个Redis Sentinel信息如下

IPPort备注
192.168.199.12626379Sentinel
192.168.199.12626479Sentinel
192.168.199.12626579Sentinel

Redis安装完成之后，在redis目录（本实例是redis-4.0.1）下会有一个sentinel.conf文件，创建sentinel目录并将该配置文件拷贝进去重命名为自定义的sentinel配置文件。

mkdir /data/redis/sentinel
cp /data/redis/redis-4.0.1/sentinel.conf  /data/redis/sentinel/sentinel_26379.conf
cp /data/redis/redis-4.0.1/sentinel.conf  /data/redis/sentinel/sentinel_26479.conf
cp /data/redis/redis-4.0.1/sentinel.conf  /data/redis/sentinel/sentinel_26579.conf

sentinel_26379.conf配置内容：

protected-mode no
port 26379
sentinel monitor mymaster 192.168.199.249 6384 2
sentinel failover-timeout mymaster 60000
sentinel config-epoch mymaster 1
sentinel leader-epoch mymaster 1
sentinel known-slave mymaster 192.168.199.126 6379

sentinel_26479.conf配置内容：

protected-mode no
port 26479
sentinel monitor mymaster 192.168.199.249 6384 2
sentinel failover-timeout mymaster 60000
sentinel config-epoch mymaster 1
sentinel leader-epoch mymaster 1
sentinel known-slave mymaster 192.168.199.126 6379

sentinel_26579.conf配置内容：

protected-mode no
port 26579
sentinel monitor mymaster 192.168.199.249 6384 2
sentinel failover-timeout mymaster 60000
sentinel config-epoch mymaster 1
sentinel leader-epoch mymaster 1
sentinel known-slave mymaster 192.168.199.126 6379

启动Redis Master实例

进入Redis Master服务器Redis bin目录，执行以下命令：

./redis-server /data/redis/redis-4.0.1/redis.conf

启动Redis Slave实例

进入Redis Slave服务器Redis bin目录，执行以下命令：

./redis-server /data/redis/cluster/6382/redis-6382.conf
./redis-server /data/redis/cluster/6383/redis-6383.conf
./redis-server /data/redis/cluster/6384/redis-6384.conf

启动Sentinel实例

进入Redis Slave服务器Redis bin目录，执行以下命令：

./redis-sentinel /data/redis/sentinel/sentinel_26379.conf 
./redis-sentinel /data/redis/sentinel/sentinel_26479.conf 
./redis-sentinel /data/redis/sentinel/sentinel_26579.conf

如果启动时出现如下信息，表示启动成功

这里写图片描述

Maven配置

<dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>       
    <dependency>
         <groupId>org.springframework.data</groupId>
         <artifactId>spring-data-redis</artifactId>
          <version>1.7.5.RELEASE</version>
</dependency>

在config.properties中增加如下配置

#Redis sentinel使用
redis.sentinel1.host=192.168.199.126
redis.sentinel1.port=26379
redis.sentinel2.host=192.168.199.126
redis.sentinel2.port=26479
redis.sentinel3.host=192.168.199.126
redis.sentinel3.port=26579
redis.sentinel.masterName=mymaster

新建spring-redis-sentinel.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"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:task="http://www.springframework.org/schema/task" xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:c='http://www.springframework.org/schema/c' xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd"
    default-lazy-init="true">

    <!-- 开启spring cache注解功能 -->
    <cache:annotation-driven cache-manager="redisCacheManager" />

    <context:annotation-config />

    <context:property-placeholder
        ignore-unresolvable="true" location="classpath:config.properties" />

    <!-- Redis -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.maxTotal}" />
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <bean id="sentinelConfiguration"
        class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
        <property name="master">
            <bean class="org.springframework.data.redis.connection.RedisNode">
                <property name="name" value="${redis.sentinel.masterName}"></property>
            </bean>
        </property>
        <property name="sentinels">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.sentinel1.host}"></constructor-arg>
                    <constructor-arg name="port" value="${redis.sentinel1.port}"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.sentinel2.host}"></constructor-arg>
                    <constructor-arg name="port" value="${redis.sentinel2.port}"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="${redis.sentinel3.host}"></constructor-arg>
                    <constructor-arg name="port" value="${redis.sentinel3.port}"></constructor-arg>
                </bean>
            </set>
        </property>
    </bean>

    <!-- redis服务器中心 -->
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="sentinelConfig" ref="sentinelConfiguration"></constructor-arg>
        <constructor-arg name="poolConfig" ref="poolConfig"></constructor-arg>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory" />
        <property name="keySerializer">
            <bean
                class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer">
            <bean
                class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
    </bean>

    <!-- redis缓存管理器 -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate" />
    </bean>

    <bean id="redisUtils" class="ron.blog.blog_service.utils.RedisUtils" />
</beans>

在spring-context.xml引入spring-redis-sentinel.xml

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

编写Redis帮助类RedisUtils

public class RedisUtils {
    /** 
     * RedisTemplate是一个简化Redis数据访问的一个帮助类， 
     * 此类对Redis命令进行高级封装，通过此类可以调用ValueOperations和ListOperations等等方法。 
     */  
    @Autowired  
    private RedisTemplate<Serializable, Object> redisTemplate;  

    /** 
     * 批量删除对应的value 
     *  
     * @param keys 
     */  
    public void remove(final String... keys) {  
        for (String key : keys) {  
            remove(key);  
        }
    }  

    /** 
     * 批量删除key 
     *  
     * @param pattern 
     */  
    public void removePattern(final String pattern) {  
        Set<Serializable> keys = redisTemplate.keys(pattern);  
        if (keys.size() > 0)  
            redisTemplate.delete(keys);  
    }  

    /** 
     * 删除对应的value 
     * @param key 
     */  
    public void remove(final String key) {  
        if (exists(key)) {  
            redisTemplate.delete(key);  
        }  
    }  

    /** 
     * 缓存是否存在
     * @param key 
     * @return 
     */  
    public boolean exists(final String key) {  
        return redisTemplate.hasKey(key);  
    }  

    /** 
     * 读取缓存 
     * @param key 
     * @return 
     */  
    public Object get(final String key) {  
        Object result = null;  
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();  
        result = operations.get(key);  
        return result;  
    }  

    /** 
     *  
     * @Author Ron
     * @param key 
     * @param hashKey 
     * @return 
     */  
    public Object get(final String key, final String hashKey){  
        Object result = null;  
        HashOperations<Serializable,Object,Object> operations = redisTemplate.opsForHash();  
        result = operations.get(key, hashKey);  
        return result;  
    }  

    /** 
     * 写入缓存 
     *  
     * @param key 
     * @param value 
     * @return 
     */  
    public boolean set(final String key, Object value) {  
        boolean result = false;  
        try {  
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();  
            operations.set(key, value);  
            result = true;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  

    /** 
     *  
     * @Author Ron 
     * @param key 
     * @param hashKey 
     * @param value 
     * @return 
     */  
    public boolean set(final String key, final String hashKey, Object value) {  
        boolean result = false;  
        try {  
            HashOperations<Serializable,Object,Object> operations = redisTemplate.opsForHash();  
            operations.put(key, hashKey, value);  
            result = true;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  

    /** 
     * 写入缓存 
     *  
     * @param key 
     * @param value 
     * @return 
     */  
    public boolean set(final String key, Object value, Long expireTime) {  
        boolean result = false;  
        try {  
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();  
            operations.set(key, value);  
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);  
            result = true;  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  
}

以上的所有配置，如果不出问题，那么基本上我们已经集成了Spring与Redis Sentinel，接下来就是在我们的例子中使用。

在我们的Blog服务（BlogService）中，我们自动装配RedisUtils实例，在进入博客详细页面时，我们首先到Redis中获取是否存在我们所要查看的博客，如果没有，则从MySQL获取并写入Redis。

    @Autowired 
    private BlogContentMapper blogContentMapper;//读者自行定义

    @Autowired  
    RedisUtils redisUtils;  
    /**
     * @Comment 获取博客内容
     * @Author Ron
     * @Date 2017年10月25日 下午3:05:27
     * @return
     */
    @Override
    public BlogContent getBlog(String bid) {
        if(redisUtils.exists(bid)){
            logger.info("缓存命中博客"+bid);
            return (BlogContent) redisUtils.get(bid);
        }else{
            logger.info("缓存尚未命中博客"+bid);
            BlogContent blogContent = blogContentMapper.selectByPrimaryKey(bid);
            redisUtils.set(bid, blogContent);
            return blogContent;
        }
    }

实例演示

我们第一次进入指定博客页面时会在控制台打出缓存尚未命中博客的信息，第二次进入则会打出缓存命中博客字样。

博客详细页面：

这里写图片描述

第一次控制台打出的信息：

这里写图片描述

第二次刷新页面是空值台打出的信息：

这里写图片描述

先查看一下Sentinel信息：
输入命令：./redis-cli -p 26379 info Sentinel

# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=mymaster,status=ok,address=192.168.199.126:6379,slaves=3,sentinels=4

我们可以看到Master的名称、ip地址、Slave的数量、Sentinel数量。

我们停掉一个Sentinel，在我们的控制台中就会监控到并出现连接丢失的错误日志，但是我们的系统仍然可用。

这里写图片描述

重新启动之后报错日志就停止。

我们停掉Master，在Sentinel中就会重新选举一个Slave为Master，同时在我们的Eclipse的控制台也可以看到重新选举的Master；

这里写图片描述

我们看到系统重新选举192.168.199.126 6382为Master。

注意：
启动服务时，可能会报连接Redis Sentinel超时，此时可能是防火墙未关闭造成，使用如下命令关闭防火墙即可：

在CentOS 7中默认使用firewall做为防火墙，下面是启动&关闭防火墙的命令：

// 启动firewall
systemctl start firewalld.service
// 关闭firewall
systemctl stop firewalld.service
RonTech
关注
专栏目录
【SpringBoot】整合Redis（使用spring-boot-starter-data-redis）
qq_27579471的博客
08-03 9952
前言 Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。 Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线
spring-data-redis实现分布式锁--乐字节Java
dirft_lez的博客
06-04 798
SpringDataRedis 创建项目 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mPYUnhG7-1591254057345)(https://s1.ax1x.com/2020/06/04/t0N0eA.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v7TLlT5L-1591254057347)(https://s1.ax1x.com/2020/06/04/t0NsFP.png)] 添加依赖 <dependenci
spring + redis + sentinel 配置
10-17
spring + redis + sentinel 配置文件，同学们可以下载使用，有问题请指教。
Spring整合redis，通过sentinel进行主从切换。
江宁山人的专栏
03-24 1万+
实现功能描述： redis服务器进行Master-slaver-slaver-....主从配置，通过2台sentinel进行failOver故障转移，自动切换，采用该代码完全可以直接用于实际生产环境。 题外话： 一般来说这样的部署足以支持数以百万级的用户，但如果数量实在是太高，此时redis的Master-Slaver主从不一...
Spring Boot整合Redis的哨兵模式
最新发布
牛肉胡辣汤
07-06 2658
通过本篇技术博客，我们学习了如何在Spring Boot应用中使用Redis的哨兵模式进行高可用性缓存服务的搭建。要注意的是，为了实现真正的高可用性，需要在实际生产环境中正确配置Redis的主节点和哨兵节点。
Redis 客户端整合：spring + redis + sentinel（注解方式配置）
03-20 7318
Redis 客户端整合：spring + redis + sentinel（注解方式配置）
Spring Data Redis：Sentinel的高可用性
最佳 Java 编程
06-12 242
1.概述 为了使Redis具有高可用性，我们可以使用Spring Data Redis对Redis Sentinel的支持。 借助Sentinel，我们可以创建自动抵御某些故障的Redis部署。 Redis Sentinel还提供其他附带任务，例如监视，通知，并充当客户端的配置提供程序。 在较高级别，Sentinel的功能是： 自动故障转移 。 当主服务器无法正常工作时，Sen...
使用Spring-data-redis操作Redis的Sentinel
热门推荐
王浩的技术博客
04-10 3万+
介绍 Spring-Data-Redis项目（简称SDR）是对Redis的Key-Value数据存储操作提供了更高层次的抽象，提供了一个对几种主要的redis的Java客户端（例如：jedis，jredis，jdbc-redis等）的抽象，使开发中可以几乎完全屏蔽具体使用客户端的影响，使业务代码保持较强的稳定性。 Spring-Data-Redis提供了一个基础的泛型RedisTemplate
spring-boot-redis(单机、集群、哨兵)
09-09
总结，Spring Boot 结合 Redis 可以轻松实现数据的快速存取，通过扩展到集群和哨兵模式，可以满足高可用性和可扩展性的需求。了解并熟练掌握这些整合方法对于开发高效、稳定的分布式应用程序至关重要。
Spring Boot 2.5 实战 Redis 分布式 缓存 6.0
天空鸟的博客
11-04 1893
跟之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。了抽象，本质上 Java 连 Redis 有基础 Redis 的驱动，使用基础的网络链接和 Redis 服。重要的 Java 驱动、工具驱动库，有 Redis 的链接池，使用的是比较有名的 Java 社群。Java 链接远程 Redis，Redis 服务器端要允许远程。
spring-data-redis-1.6.0.RELEASE.jar + jedis-2.7.2.jar包
05-09
10. **Sentinel和Cluster支持**：如果Redis部署在高可用环境中，如Sentinel集群或Cluster模式，Spring Data Redis也能很好地支持，通过配置相应的连接工厂即可。 综上所述，"spring-data-redis-1.6.0.RELEASE.jar +...
Spring+Redis+Sentinel
aijia131416的博客
02-16 195
master：192.168.25.129:6379 slave:192.168.25.129:6380,192.168.25.130:6379,192.168.25.130:6380 jar包：jedis-2.5.2,spring-data-redis-1.4.1.RELEASE spring配置文件： 1 <?xml version="1.0" enco...
spring redis Sentinel 哨兵 原理
aaaak_的博客
04-20 1479
sentinel 查询 Master 的地址，如果发现 Master 变更了，则删除旧的 masterEntry，重建一个新的 masterEntry；scheduleClusterChangeCheck定时检测集群节点状态。启一个 schedule 每一秒调度一次检查 是否发生过 故障转移。checkMasterNodesChange检测主节点状态。跟进去看哨兵模式下的 ConnectionManager。redis 常用的连接客户端 有三个。
Spring整合redis，通过sentinel进行主从切换
weixin_33752045的博客
03-14 436
实现功能描述：         redis服务器进行Master-slaver-slaver-....主从配置，通过2台sentinel进行failOver故障转移，自动切换，采用该代码完全可以直接用于实际生产环境。                题外话： 　　研究Redis也有一段时间了，在前面的Redis系列文章中，介绍了Redis的安装，集群配置，及节点的增加和删除，但是并未实际的使用到项目...
深入浅出缓存设计---4、Redis Sentinel
u014526891的博客
04-06 1万+
Redis Sentinel 哨兵是用来解决redis高可用性的，可以监控集群中主从的变化，然后进行故障转移。 哨兵讲解 一套合理的监控机制是Sentinel节点判定节点不可达的重要保证，Redis Sentinel通过三个定时监控任务完成对各个节点发现和监控。 周期10秒监控 每隔10秒，每个Sentinel节点会向主节点和从节点发送info命令获取最新的主从结构，该命令有3个作用： 通过向主节点执行info命令，获取从节点的信息，这也是为什么Sentinel节点不需要显式配置监控从节点 当有新的从节点
spring整合redis sentinel实现redis HA服务调用
牛奋lch
11-17 1462
一、redis-sentinel HA架构搭建 详细的搭建过程，请参考另一篇文章，地址如下： http://blog.csdn.net/liuchuanhong1/article/details/53206028 二、引入依赖的jar包 dependency> groupId>redis.clientsgroupId> artifactId>jedisartifactI
Spring整合Redis-sentinel集群实现03
Code-Create-World
01-02 635
一、Redis Sentinel集群解决方案简介Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案，当用Redis做Master-slave的高可用方案时，假如master宕机了，Redis本身(包括它的很多客户端)都没有实现自动进行主备切换，而Redis-sentinel本身也是一个独立运行的进程，它能监控多个master-slave集群，发现master宕机后能进行自懂
Springboot整合Redis-sentinel哨兵模式集群
weixin_38998414的博客
02-26 1万+
Springboot整合Redis-sentinel哨兵模式集群 近日在项目中整合redis缓存，查了好多SpringBoot整合Redis的博客。经过多日研究测试终于成功了。特留博客供查阅。 1. pom.xml 添加Redis依赖 &amp;amp;lt;!-- redis --&amp;amp;gt; &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp
SpringCloud：分布式缓存之Redis哨兵
时代各有不同，青春一脉相承。
06-03 1013
Redis提供了哨兵（Sentinel）机制来实现主从集群的自动故障恢复。哨兵的作用如下：监控：Sentinel会不断检查您的master和slave是否按预期工作。自动故障恢复：如果master故障，Sentinel会将一个slave提升为master。当故障实例恢复后也以新的master为主。通知：Sentinel充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端。
Spring Cache整合Redis主从及哨兵模式实现高可用
"本文主要介绍了如何配置Redis的主从模式，并结合Spring Cache实现高可用的缓存系统。我们将探讨配置流程、关键配置项以及哨兵模式的设置，以确保服务的稳定性和数据的一致性。" 在分布式系统中，Redis作为缓存服务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

RonTech

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值