redis主从+哨兵，整合SpringBoot。拿来直接用

原创 已于 2024-12-26 11:53:10 修改
· 590 阅读 · 11 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #spring boot

于 2024-12-26 11:27:09 首次发布

文章目录

上一章：redis主从+哨兵搭建

目的：搭建完主从后，整合到SpringBoot中，在实际项目中使用。

框架：ruoyi-vue-plus，基于该框架增加redis的主从+哨兵功能。

鸣谢：感谢狮佬的开源框架

一、yaml文件配置

里面用的节点以及哨兵都是 上一章：主从+哨兵搭建 的内容

spring.data:
    redis:
      sentinel:
        master: mymaster
        nodes:
          - 10.8.8.177:8010
          - 10.8.8.177:8011
          - 10.8.8.177:8012

redisson:
  # 线程池数量
  threads: 16
  # Netty线程池数量
  nettyThreads: 32
  # 哨兵配置
  sentinelServerConfig:
    idleConnectionTimeout: 10000
    connectTimeout: 10000
    timeout: 5000
    retryAttempts: 3
    retryInterval: 1000
#    password: 1234
    subscriptionsPerConnection: 200
    clientName: ${ruoyi.name}
    slaveConnectionMinimumIdleSize: 10
    slaveConnectionPoolSize: 250
    masterConnectionMinimumIdleSize: 5
    masterConnectionPoolSize: 250
    readMode: SLAVE
    subscriptionMode: SLAVE
    sentinelAddresses:
      - redis://10.8.8.177:28010
      - redis://10.8.8.177:28011
      - redis://10.8.8.177:28012
    masterName: "mymaster"
    database: 0
    # 发布和订阅连接池大小
    subscriptionConnectionPoolSize: 50

二、RedissonProperties.class新增以下内容

2.1 增加哨兵内部类，在最下面加即可


    @Data
    @NoArgsConstructor
    public static class SentinelServerConfig {
        /**
         * 客户端名称
         */
        private String clientName;

        /**
         * 自定义的主节点名称，和哨兵配置文件一致
         */
        private String masterName;

        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;

        /**
         * 命令等待超时，单位：毫秒。默认3000
         */
        private int timeout;

        /**
         * 连接超时时间，默认10000毫秒
         */
        private int connectTimeout;

        /**
         * 发送命令到redis，重试次数。默认：3次
         */
        private int retryAttempts;
        /**
         * 重试命令间隔。默认1500毫秒
         */
        private int retryInterval;

        /**
         * 密码.默认空
         */
        private String password;

        /**
         * redis订阅限制。默认5
         */
        private int subscriptionsPerConnection;

        /**
         * 哨兵地址
         */
        private String[] sentinelAddresses;

        /**
         * 订阅通道最小连接池大小。默认24
         */
        private int slaveConnectionMinimumIdleSize;

        /**
         * 从服务器连接池大小。默认64
         */
        private int slaveConnectionPoolSize;

        /**
         * 主节点最小连接数大小，默认24
         */
        private int masterConnectionMinimumIdleSize;

        /**
         * 主服务器连接池大小，默认64
         */
        private int masterConnectionPoolSize;

        /**
         * 读操作节点类型。默认SLAVE（从）
         */
        private ReadMode readMode;

        /**
         * 设置订阅操作的节点类型，默认MASTER（主）
         */
        private SubscriptionMode subscriptionMode;

        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;
    }

2.2 哨兵内部类作为属性

    /**
     * 主从+哨兵服务配置
     */
    private SentinelServerConfig sentinelServerConfig;

2.3 整个文件

package org.dromara.common.redis.config.properties;

import lombok.Data;
import lombok.NoArgsConstructor;
import org.redisson.config.ReadMode;
import org.redisson.config.SubscriptionMode;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * Redisson 配置属性
 *
 * @author Lion Li
 */
@Data
@ConfigurationProperties(prefix = "redisson")
public class RedissonProperties {

    /**
     * redis缓存key前缀
     */
    private String keyPrefix;

    /**
     * 线程池数量,默认值 = 当前处理核数量 * 2
     */
    private int threads;

    /**
     * Netty线程池数量,默认值 = 当前处理核数量 * 2
     */
    private int nettyThreads;

    /**
     * 单机服务配置
     */
    private SingleServerConfig singleServerConfig;

    /**
     * 主从+哨兵服务配置
     */
    private SentinelServerConfig sentinelServerConfig;

    /**
     * 集群服务配置
     */
    private ClusterServersConfig clusterServersConfig;

    @Data
    @NoArgsConstructor
    public static class SingleServerConfig {

        /**
         * 客户端名称
         */
        private String clientName;

        /**
         * 最小空闲连接数
         */
        private int connectionMinimumIdleSize;

        /**
         * 连接池大小
         */
        private int connectionPoolSize;

        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;

        /**
         * 命令等待超时，单位：毫秒
         */
        private int timeout;

        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;

    }

    @Data
    @NoArgsConstructor
    public static class ClusterServersConfig {

        /**
         * 客户端名称
         */
        private String clientName;

        /**
         * master最小空闲连接数
         */
        private int masterConnectionMinimumIdleSize;

        /**
         * master连接池大小
         */
        private int masterConnectionPoolSize;

        /**
         * slave最小空闲连接数
         */
        private int slaveConnectionMinimumIdleSize;

        /**
         * slave连接池大小
         */
        private int slaveConnectionPoolSize;

        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;

        /**
         * 命令等待超时，单位：毫秒
         */
        private int timeout;

        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;

        /**
         * 读取模式
         */
        private ReadMode readMode;

        /**
         * 订阅模式
         */
        private SubscriptionMode subscriptionMode;

    }

    @Data
    @NoArgsConstructor
    public static class SentinelServerConfig {
        /**
         * 客户端名称
         */
        private String clientName;

        /**
         * 自定义的主节点名称，和哨兵配置文件一致
         */
        private String masterName;

        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;

        /**
         * 命令等待超时，单位：毫秒。默认3000
         */
        private int timeout;

        /**
         * 连接超时时间，默认10000毫秒
         */
        private int connectTimeout;

        /**
         * 发送命令到redis，重试次数。默认：3次
         */
        private int retryAttempts;
        /**
         * 重试命令间隔。默认1500毫秒
         */
        private int retryInterval;

        /**
         * 密码.默认空
         */
        private String password;

        /**
         * redis订阅限制。默认5
         */
        private int subscriptionsPerConnection;

        /**
         * 哨兵地址
         */
        private String[] sentinelAddresses;

        /**
         * 订阅通道最小连接池大小。默认24
         */
        private int slaveConnectionMinimumIdleSize;

        /**
         * 从服务器连接池大小。默认64
         */
        private int slaveConnectionPoolSize;

        /**
         * 主节点最小连接数大小，默认24
         */
        private int masterConnectionMinimumIdleSize;

        /**
         * 主服务器连接池大小，默认64
         */
        private int masterConnectionPoolSize;

        /**
         * 读操作节点类型。默认SLAVE（从）
         */
        private ReadMode readMode;

        /**
         * 设置订阅操作的节点类型，默认MASTER（主）
         */
        private SubscriptionMode subscriptionMode;

        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;
    }

}

三、redisConfig.class配置

3.1 添加哨兵模式

在方法redissonCustomizer后添加代码块

    // 哨兵模式
            RedissonProperties.SentinelServerConfig sentinelServerConfig = redissonProperties.getSentinelServerConfig();
            if (ObjectUtil.isNotNull(sentinelServerConfig)) {
                config.useSentinelServers()
                        .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                        .setTimeout(sentinelServerConfig.getTimeout())
                        .setClientName(sentinelServerConfig.getClientName())
                        .setConnectTimeout(sentinelServerConfig.getConnectTimeout())
                        .setRetryAttempts(sentinelServerConfig.getRetryAttempts())
                        .setRetryInterval(sentinelServerConfig.getRetryInterval())
                        .setIdleConnectionTimeout(sentinelServerConfig.getIdleConnectionTimeout())
                        .setSubscriptionsPerConnection(sentinelServerConfig.getSubscriptionsPerConnection())
                        .setSubscriptionConnectionPoolSize(sentinelServerConfig.getSubscriptionConnectionPoolSize())
                        .setMasterName(sentinelServerConfig.getMasterName())
                        .setSlaveConnectionMinimumIdleSize(sentinelServerConfig.getSlaveConnectionMinimumIdleSize())
                        .setSlaveConnectionPoolSize(sentinelServerConfig.getSlaveConnectionPoolSize())
                        .setMasterConnectionMinimumIdleSize(sentinelServerConfig.getMasterConnectionMinimumIdleSize())
                        .setMasterConnectionPoolSize(sentinelServerConfig.getMasterConnectionPoolSize())
                        .setReadMode(sentinelServerConfig.getReadMode())
                        .setSubscriptionMode(sentinelServerConfig.getSubscriptionMode())
                        .addSentinelAddress(sentinelServerConfig.getSentinelAddresses());
                log.info(String.valueOf(config));
            }

3.3 整个文件

package org.dromara.common.redis.config;

import cn.hutool.core.util.ObjectUtil;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.utils.SpringUtils;
import org.dromara.common.redis.config.properties.RedissonProperties;
import org.dromara.common.redis.handler.KeyPrefixHandler;
import org.dromara.common.redis.handler.RedisExceptionHandler;
import org.redisson.client.codec.StringCodec;
import org.redisson.codec.CompositeCodec;
import org.redisson.codec.TypedJsonJacksonCodec;
import org.redisson.spring.starter.RedissonAutoConfigurationCustomizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.core.task.VirtualThreadTaskExecutor;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.TimeZone;

/**
 * redis配置
 *
 * @author Lion Li
 */
@Slf4j
@AutoConfiguration
@EnableConfigurationProperties(RedissonProperties.class)
public class RedisConfig {

    @Autowired
    private RedissonProperties redissonProperties;

    @Bean
    public RedissonAutoConfigurationCustomizer redissonCustomizer() {
        return config -> {
            JavaTimeModule javaTimeModule = new JavaTimeModule();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(formatter));
            javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(formatter));
            ObjectMapper om = new ObjectMapper();
            om.registerModule(javaTimeModule);
            om.setTimeZone(TimeZone.getDefault());
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 指定序列化输入的类型，类必须是非final修饰的。序列化时将对象全类名一起保存下来
            om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            TypedJsonJacksonCodec jsonCodec = new TypedJsonJacksonCodec(Object.class, om);
            // 组合序列化 key 使用 String 内容使用通用 json 格式
            CompositeCodec codec = new CompositeCodec(StringCodec.INSTANCE, jsonCodec, jsonCodec);
            config.setThreads(redissonProperties.getThreads())
                .setNettyThreads(redissonProperties.getNettyThreads())
                // 缓存 Lua 脚本 减少网络传输(redisson 大部分的功能都是基于 Lua 脚本实现)
                .setUseScriptCache(true)
                .setCodec(codec);
            if (SpringUtils.isVirtual()) {
                config.setNettyExecutor(new VirtualThreadTaskExecutor("redisson-"));
            }
            RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
            if (ObjectUtil.isNotNull(singleServerConfig)) {
                // 使用单机模式
                config.useSingleServer()
                    //设置redis key前缀
                    .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                    .setTimeout(singleServerConfig.getTimeout())
                    .setClientName(singleServerConfig.getClientName())
                    .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
                    .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
                    .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize());
            }
            // 集群配置方式 参考下方注释
            RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
            if (ObjectUtil.isNotNull(clusterServersConfig)) {
                config.useClusterServers()
                    //设置redis key前缀
                    .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                    .setTimeout(clusterServersConfig.getTimeout())
                    .setClientName(clusterServersConfig.getClientName())
                    .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
                    .setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
                    .setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
                    .setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
                    .setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
                    .setReadMode(clusterServersConfig.getReadMode())
                    .setSubscriptionMode(clusterServersConfig.getSubscriptionMode());
            }
            // 哨兵模式
            RedissonProperties.SentinelServerConfig sentinelServerConfig = redissonProperties.getSentinelServerConfig();
            if (ObjectUtil.isNotNull(sentinelServerConfig)) {
                config.useSentinelServers()
                        .setNameMapper(new KeyPrefixHandler(redissonProperties.getKeyPrefix()))
                        .setTimeout(sentinelServerConfig.getTimeout())
                        .setClientName(sentinelServerConfig.getClientName())
                        .setConnectTimeout(sentinelServerConfig.getConnectTimeout())
                        .setRetryAttempts(sentinelServerConfig.getRetryAttempts())
                        .setRetryInterval(sentinelServerConfig.getRetryInterval())
                        .setIdleConnectionTimeout(sentinelServerConfig.getIdleConnectionTimeout())
                        .setSubscriptionsPerConnection(sentinelServerConfig.getSubscriptionsPerConnection())
                        .setSubscriptionConnectionPoolSize(sentinelServerConfig.getSubscriptionConnectionPoolSize())
                        .setMasterName(sentinelServerConfig.getMasterName())
                        .setSlaveConnectionMinimumIdleSize(sentinelServerConfig.getSlaveConnectionMinimumIdleSize())
                        .setSlaveConnectionPoolSize(sentinelServerConfig.getSlaveConnectionPoolSize())
                        .setMasterConnectionMinimumIdleSize(sentinelServerConfig.getMasterConnectionMinimumIdleSize())
                        .setMasterConnectionPoolSize(sentinelServerConfig.getMasterConnectionPoolSize())
                        .setReadMode(sentinelServerConfig.getReadMode())
                        .setSubscriptionMode(sentinelServerConfig.getSubscriptionMode())
                        .addSentinelAddress(sentinelServerConfig.getSentinelAddresses());
                log.info(String.valueOf(config));
            }

            log.info("初始化 redis 配置");
        };
    }

    /**
     * 异常处理器
     */
    @Bean
    public RedisExceptionHandler redisExceptionHandler() {
        return new RedisExceptionHandler();
    }

    /**
     * redis集群配置 yml
     *
     * --- # redis 集群配置(单机与集群只能开启一个另一个需要注释掉)
     * spring.data:
     *   redis:
     *     cluster:
     *       nodes:
     *         - 192.168.0.100:6379
     *         - 192.168.0.101:6379
     *         - 192.168.0.102:6379
     *     # 密码
     *     password:
     *     # 连接超时时间
     *     timeout: 10s
     *     # 是否开启ssl
     *     ssl.enabled: false
     *
     * redisson:
     *   # 线程池数量
     *   threads: 16
     *   # Netty线程池数量
     *   nettyThreads: 32
     *   # 集群配置
     *   clusterServersConfig:
     *     # 客户端名称
     *     clientName: ${ruoyi.name}
     *     # master最小空闲连接数
     *     masterConnectionMinimumIdleSize: 32
     *     # master连接池大小
     *     masterConnectionPoolSize: 64
     *     # slave最小空闲连接数
     *     slaveConnectionMinimumIdleSize: 32
     *     # slave连接池大小
     *     slaveConnectionPoolSize: 64
     *     # 连接空闲超时，单位：毫秒
     *     idleConnectionTimeout: 10000
     *     # 命令等待超时，单位：毫秒
     *     timeout: 3000
     *     # 发布和订阅连接池大小
     *     subscriptionConnectionPoolSize: 50
     *     # 读取模式
     *     readMode: "SLAVE"
     *     # 订阅模式
     *     subscriptionMode: "MASTER"
     */

}

四、租户配置类修改：TenantConfig

4.1 在方法tenantRedissonCustomizer添加代码块

 SentinelServersConfig sentinelServersConfig = ReflectUtils.invokeGetter(config, "sentinelServersConfig");
            // 哨兵模式配置方式
            if (ObjectUtil.isNotNull(sentinelServersConfig)) {
                // 设置多租户 redis key前缀
                sentinelServersConfig.setNameMapper(nameMapper);
                ReflectUtils.invokeSetter(config, "sentinelServersConfig", sentinelServersConfig);
            }

4.2 整个方法tenantRedissonCustomizer

 @Bean
    public RedissonAutoConfigurationCustomizer tenantRedissonCustomizer(RedissonProperties redissonProperties) {
        return config -> {
            TenantKeyPrefixHandler nameMapper = new TenantKeyPrefixHandler(redissonProperties.getKeyPrefix());
            SingleServerConfig singleServerConfig = ReflectUtils.invokeGetter(config, "singleServerConfig");
            if (ObjectUtil.isNotNull(singleServerConfig)) {
                // 使用单机模式
                // 设置多租户 redis key前缀
                singleServerConfig.setNameMapper(nameMapper);
                ReflectUtils.invokeSetter(config, "singleServerConfig", singleServerConfig);
            }
            ClusterServersConfig clusterServersConfig = ReflectUtils.invokeGetter(config, "clusterServersConfig");
            // 集群配置方式 参考下方注释
            if (ObjectUtil.isNotNull(clusterServersConfig)) {
                // 设置多租户 redis key前缀
                clusterServersConfig.setNameMapper(nameMapper);
                ReflectUtils.invokeSetter(config, "clusterServersConfig", clusterServersConfig);
            }

            SentinelServersConfig sentinelServersConfig = ReflectUtils.invokeGetter(config, "sentinelServersConfig");
            // 哨兵模式配置方式
            if (ObjectUtil.isNotNull(sentinelServersConfig)) {
                // 设置多租户 redis key前缀
                sentinelServersConfig.setNameMapper(nameMapper);
                ReflectUtils.invokeSetter(config, "sentinelServersConfig", sentinelServersConfig);
            }
        };
    }

五、启动效果

可以看到，redis以及哨兵都已加载完成。
在这里插入图片描述

SpringBoot 集成Redis哨兵、Redis-Cluster 集群、搭建Redis的三主三从集群模式
qq_39750835的博客
08-04 1094
一、SpringBoot 集成Redis哨兵 启动程序后，设置key,value 拿到结果： 查看redis库： 二、Redis-Cluster 集群 三、搭建Redis的三主三从集群模式 需要搭建6台服务器集群，如下： 192.168.1.201、192.168.1.202、192.168.1.203、192.168.1.204、192.168.1.205、192.168.1.206 1.开启集群模式 2.每个节点处于集群中的配置文件，与其他节点的关系...
SpringBoot（二十四）SpringBoot集成redis哨兵集群
camellia的博客
11-15 3240
这里算是一篇总结笔记叭，先从linux服务器redis主从复制，哨兵集群搭建开始。首先我们来准备三个redis.conf配置文件：redis79.conf/redis80.conf/redis81.conf。至此，redis搭建哨兵模式集群，以及springboot集成redis哨兵模式到此完成。我没有多台服务器，因此我在一台服务器上边搭建redis集群，一主二从。哨兵要保证高可用，也要配置集群，需要多个配置文件，监听不同端口，启动多个哨兵。如果redis中和代码中的名称都是mymaster。
Spring Boot 集成 redis 哨兵模式
最新发布
qq_38516976的博客
03-21 403
【代码】Spring Boot 集成 redis 哨兵模式。
Spring Boot整合Redis的哨兵模式
牛肉胡辣汤
07-06 6105
通过本篇技术博客，我们学习了如何在Spring Boot应用中使用Redis的哨兵模式进行高可用性缓存服务的搭建。要注意的是，为了实现真正的高可用性，需要在实际生产环境中正确配置Redis的主节点和哨兵节点。
SpringBoot Redis 哨兵配置（一主两从三哨兵配置）
热门推荐
qq_34125349的博客
04-10 19万+
SpringBoot Redis 哨兵配置(一主两从三哨兵 )配置 背景 Redis 哨兵模式作为Redis 的一种高可用方案，实现了主从复制、监控，故障转移等工作，在一定程度上保证了Redis的高可用，避免了因Redis服务宕机导致缓存服务不可用情况；本博文主要是基于Spring Boot进行搭建的Redis Sentinel(哨兵模式)，采用的是 一主两从三哨兵 Redis Sentinel...
springboot配置Redis哨兵主从服务 以及 Redis 集群
LoveSummer
02-25 1万+
redis哨兵集群配置 Sentinel（哨兵）是Redis 的高可用性解决方案：由一个或多个Sentinel 实例 组成的Sentinel 系统可以监视任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监视的主服务器进入下线状态时，自动将下线主服务器属下的某个从服务器升级为新的主服务器。具体原理和配置参考《【带你重拾Redis】Redis 哨兵集群实现高可用》 springboot配置Redis主从服务 接下来学了一下springboot配置redis的主从服务器。根据一主二从三哨兵的原则来搭建
[转](3条消息) spring boot集成redis哨兵模式（一主二从）
jiaoqi6132的博客
12-28 1671
没有权限，无法连接redis sentinel，错误日志如下：解决如下错误的方法有两种：1种：排查sentinel配置文件中的【requirepass password】属性是否配置了密码，如果配置了可能是第二种情况。如果没有配置，由于application.yml文件配置了米面，需要自己配置。2种：application.yml文件的配置种没有配置密码，需要在sentinel.password=password配置sentinel中配置的密码（参考1种）
Redis
m0_67496588的博客
07-20 1001
主从复制，哨兵模式，Redis Cluster集群模式， 分布式锁（缓存击穿，缓存雪崩，缓存穿透，Redis分布式锁原理，手写Redis分布式锁）
Redis-Redis持久化，主从哨兵架构详解
weixin_43874650的博客
11-21 1006
Redis持久化。
java-springboot、mybatis、redis相关面试题
q66562636的博客
04-06 1604
SpringBoot部分 相比Spring,Spring Boot有哪些优点 Springboot是一个基于spring的框架，对spring做了大量简化，使开发流程更快，更高效 它大量简化maven依赖，管理了大量的基础依赖 基于注解配置（JavaConfig），无需xml配置 内嵌Tomcat，部署流程简单 打包和部署更加灵活，允许独立运行 SpringBoot如何做全局异常处理 可以使用@ControllerAdvice注解，编写一个全局异常处理类，再自定义一个方法使用@Excepti
Springboot整合Redisson实现分布式锁
桐花思雨
03-30 4927
分布式锁简述 在传统的，老旧单机项目中要想实现锁机制，我们可以使用下面的方式 基于 Java API 层面的 Lock ：代表实现类 ReentrantLock 基于 Java API 层面的 ReadWriteLock ：代表实现类 ReentrantReadWriteLock 基于 JVM 的 synchronized 关键字 但随着业务场景越来越复杂，伴随着技术的不断发展，在分布式的环境中，想要实现锁机制，使用上述的方式已无法实现业务功能。所以提出了分布式锁的概念及技术 分布式锁的实现，常见的有使
SpringBoot结合Redis哨兵模式的实现示例
08-19
主要介绍了SpringBoot结合Redis哨兵模式的实现示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Springboot（四十六）SpringBoot3整合redis并配置哨兵模式
camellia的博客
11-29 1910
但是呢，Springboot3中部署redis的配置和Springboot2中的配置完全不同。上次我的redis是在centos服务器上直接安装的，这次在Springboot3的配置中，我的redis使用docker来部署。安装redis就不需要使用dockerfile了，太麻烦了。我这里的配置比较简单，能用的上的就是这些。其余的配置如果需要请自行添加。我这里再来记录一下Springboot3中配置redis的全部代码。到这里，你的redis其实就可以使用了。有好的建议，请在下方输入你的评论。
Redis主从搭建（哨兵模式），springboot整合redis主从
Ye_GuoLin的博客
04-26 2791
通过一系列验证，你或许会发现Redis哨兵重新选举主节点后会将这个被选中的节点的redis.conf修改掉，具体的为删掉replicaof 配置项，而原来的主节点则添加replicaof 配置项，并指向新的主节点。虽然redis主从已经搭建完毕，但是当主节点宕机时，从节点并不会接手主节点的工作，只会傻傻得在那里不停地尝试连接主节点。然而这并不是我们想要的，我们希望主节点挂了后，从节点可以顶上去，让服务继续使用。还可以通过sentinel.log日志文件的日志信息查看哨兵的相关配置情况！
搭建redis主从，哨兵配置，集成到springboot中配置读写分离
qq_50867577的博客
06-07 3259
文章介绍Ubuntu系统搭建redis，并完成主从的读写分离配置，为主节点搭建三台哨兵服务，并集成到springboot中。
springboot 集成redis哨兵主从
lhp3000的博客
03-22 2065
springboot 集成redis哨兵主从 一、环境 spring boot 2.3.12.RELEASE JDK 1.8 IntelliJ IDEA开发工具 Redis哨兵主从搭建 二、POM文件 pom文件其他忽略，只展示和redis有关系统的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter<
Redis（十二）SpringBoot集群搭建redis【主从复制&哨兵模式】
Vinjcent
07-10 7012
使用springboot框架搭建redis集群，并实现哨兵模式以及主从复制
Redis主从哨兵，SpringBoot整合应用
weixin_43483246的博客
06-28 990
目录主从一、概念二、配置三、主从复制的机制哨兵一、概念二、哨兵模式文件三、多个哨兵四、哨兵的配置文件<1>编辑配置文件<2>启动哨兵SpringBoot2.X整合哨兵主从服务<1>pom依赖<2>application.properties配置文件<3>Redis配置类<4>单元测试Redis缓存穿透(查不到)1）概念：2）解决方案：Redis缓存击穿(访问量太大，缓存过期)和雪崩(缓存集中过期)一、缓存击穿：1）概念：2）解决方案二、
【开发篇】六、SpringBoot整合Redis哨兵模式
llg___的博客
06-30 8484
监控：不断检查master和slave是否正常运行通知：当被监控的主从服务器发生问题时，向其他哨兵和客户端发送通知自动故障转移：断开master和slave的连接，选取一个slave做为master，将其他slave连接到新的maser，并导致客户端新的maser地址关于Redis哨兵模式的搭建和详解，看这篇【优快云-Redis哨兵模式】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值