脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Springboot整合Redis主从

Springboot整合Redis主从实践

 更新时间：2025年06月12日 14:23:47   作者：xiaomu_a  
这篇文章主要介绍了Springboot整合Redis主从的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

前言

SpringBoot版本：2.3.2.RELEASE

原配置

原yml配置内容：

spring:
  # Redis服务器配置
  redis:
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码
    password: redis@123
    #连接超时时间（毫秒）
    timeout: 30000ms
    jedis:
      # Redis服务器连接池
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        maxIdle: 400
        #连接池中的最小空闲连接
        minIdle: 100
        #连接池中的最大空闲连接
        maxActive: 400
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        maxWait: -1ms
    lettuce:
      pool:
        max-idle: 400
        min-idle: 100
        max-active: 400
        max-wait: -1ms

原RedisConfig配置类：

import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(value = StringRedisTemplate.class, name = "stringRedisTemplate")
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(factory);
        return template;
    }
}

现配置

现yml配置内容：

spring:
  redis:
    # 主节点
    master:
      host: 127.0.0.1
      port: 6379
      password: redis@123
    # 副本节点
    replicas:
      - host: 127.0.0.1
        port: 6380
    #连接超时时间（毫秒）
    timeout: 30000ms
    jedis:
      # Redis服务器连接池
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        maxIdle: 400
        #连接池中的最小空闲连接
        minIdle: 100
        #连接池中的最大空闲连接
        maxActive: 400
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        maxWait: -1ms
    lettuce:
      pool:
        max-idle: 400
        min-idle: 100
        max-active: 400
        max-wait: -1ms

现RedisConfig配置类：

import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
import com.juxiao.xchat.manager.cache.properties.RedisMasterReplicaProperties;
import io.lettuce.core.ClientOptions;
import io.lettuce.core.ReadFrom;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStaticMasterReplicaConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
@AutoConfigureAfter(RedisAutoConfiguration.class)
@EnableConfigurationProperties({RedisMasterReplicaProperties.class, RedisProperties.class})
public class RedisConfig {

    private final RedisMasterReplicaProperties properties;
    private final RedisProperties redisProperties;

    public RedisConfig(RedisMasterReplicaProperties redisMasterReplicaProperties, RedisProperties redisProperties) {
        this.properties = redisMasterReplicaProperties;
        this.redisProperties = redisProperties;
    }

    public LettuceConnectionFactory redisConnectionFactory(boolean readFromMaster) {
        RedisStaticMasterReplicaConfiguration config = new RedisStaticMasterReplicaConfiguration(
                properties.getMaster().getHost(), properties.getMaster().getPort()
        );
        String password = properties.getMaster().getPassword();
        if (StringUtils.isNotBlank(password)) {
            config.setPassword(RedisPassword.of(password));
        }
        for (RedisMasterReplicaProperties.Node replica : properties.getReplicas()) {
            config.addNode(replica.getHost(), replica.getPort());
        }

        // 连接池配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder =
                LettucePoolingClientConfiguration.builder().commandTimeout(redisProperties.getTimeout());
        // 使用 application.yml 中的 lettuce.pool 参数
        RedisProperties.Pool poolProps = redisProperties.getLettuce().getPool();
        if (poolProps != null) {
            builder.poolConfig(poolConfig(poolProps));
        }
        // 优先从副本读取
        builder.readFrom(readFromMaster ? ReadFrom.MASTER : ReadFrom.REPLICA_PREFERRED);
        // 断开连接时拒绝命令[而不是再等待连接超时时间后再报错]、启用自动重连
        builder.clientOptions(ClientOptions.builder()
                .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
                .autoReconnect(true)
                .build());
        LettucePoolingClientConfiguration lettucePoolingClientConfiguration = builder.build();
        // 构建连接工厂
        LettuceConnectionFactory factory = new LettuceConnectionFactory(config, lettucePoolingClientConfiguration);
        // 禁用共享连接 默认是true
        // factory.setShareNativeConnection(false);
        // 初始化工厂 否则调用StringRedisTemplate时会空指针 【因为redisConnectionFactory 方法没有使用@Bean注解将LettuceConnectionFactory交给Spring工厂管理 所以需要手动调用afterPropertiesSet方法初始化连接工厂】
        factory.afterPropertiesSet();
        return factory;
    }

    // 连接池参数绑定
    private GenericObjectPoolConfig<?> poolConfig(RedisProperties.Pool poolProps) {
        GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>();
        config.setMaxTotal(poolProps.getMaxActive());
        config.setMaxIdle(poolProps.getMaxIdle());
        config.setMinIdle(poolProps.getMinIdle());
        config.setMaxWaitMillis(poolProps.getMaxWait().toMillis());
        return config;
    }

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(LettuceConnectionFactory redisConnectionFactory) {
        redisConnectionFactory.setShareNativeConnection(false);
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        //使用fastjson序列化
        FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<>(Object.class);
        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean("masterStringRedisTemplate")
    @ConditionalOnMissingBean(name = "masterStringRedisTemplate")
    public StringRedisTemplate masterStringRedisTemplate() {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory(true));
        return template;
    }

    @Bean("replicaStringRedisTemplate")
    @ConditionalOnMissingBean(name = "replicaStringRedisTemplate")
    public StringRedisTemplate replicaStringRedisTemplate() {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory(false));
        return template;
    }
}

新增RedisMasterReplicaProperties配置类：

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

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

@Data
@ConfigurationProperties(prefix = "spring.redis")
public class RedisMasterReplicaProperties {

    /**
     * 主节点
     */
    private Node master;
    /**
     * 从节点
     */
    private List<Node> replicas = new ArrayList<>();

    @Data
    public static class Node {
        /**
         * 主机地址
         */
        private String host;
        /**
         * 端口
         */
        private int port;
        /**
         * 密码（主从模式master、slave密码必须设置一样的）
         */
        private String password;
    }
}

测试

    @Resource(name = "masterStringRedisTemplate")
    private StringRedisTemplate masterStringRedisTemplate;
    @Resource(name = "replicaStringRedisTemplate")
    private StringRedisTemplate replicaStringRedisTemplate;

    @GetMapping("/test")
    public String test() {
        
        masterStringRedisTemplate.opsForValue().set("imu:test", "Hello6");

        String value = replicaStringRedisTemplate.opsForValue().get("imu:test");
        return value;
    }

LettuceConnectionFactory.setShareNativeConnection 方法的作用

代码中这一行被注释，保持了原本的默认配置true

// 禁用共享连接 默认是true
// factory.setShareNativeConnection(false);

在 Spring Data Redis 中，LettuceConnectionFactory 是一个用于管理 Redis 连接的工厂类，而 setShareNativeConnection(boolean shareNativeConnection) 方法用于控制是否 共享底层的 Redis 连接。

true（默认）：

  • 适用于 大多数应用，多个 Redis 操作共享同一个底层连接，减少资源占用。
  • 适用于 Spring Boot + RedisTemplate 场景。

false：

  • 适用于 高并发、多线程环境，避免多个线程争抢同一个 Redis 连接。
  • 适用于 WebFlux、Reactive、Pipeline 等场景。

一般来说，除非你的 Redis 操作出现 多线程连接争用问题，否则 不用手动修改 setShareNativeConnection，保持默认值即可！🚀

而：

  • shareNativeConnection = true
  • （默认）时，Spring 只会创建 一个共享的 StatefulRedisConnection，那么 连接池的 max-active、max-idle、min-idle 这些配置不会生效。
  • shareNativeConnection = false 时，每次请求都会新建连接，这时连接池才会管理多个连接，此时 max-active 等参数才会起作用。
  • 也就是说我们在yml配置文件中配置的连接池信息都将不起作用
    jedis:
      # Redis服务器连接池
      pool:
        # 连接池最大连接数（使用负值表示没有限制）
        maxIdle: 400
        #连接池中的最小空闲连接
        minIdle: 100
        #连接池中的最大空闲连接
        maxActive: 400
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        maxWait: -1ms
    lettuce:
      pool:
        max-idle: 400
        min-idle: 100
        max-active: 400
        max-wait: -1ms

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • java实现计算地理坐标之间的距离

    java实现计算地理坐标之间的距离

    java实现计算地理坐标之间的距离，主要是通过计算两经纬度点之间的距离来实现，有需要的小伙伴参考下吧
    2015-03-03
  • java实现微信退款功能

    java实现微信退款功能

    这篇文章主要为大家详细介绍了java实现微信退款功能，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2018-09-09
  • java实现二维数组转置的方法示例

    java实现二维数组转置的方法示例

    这篇文章主要介绍了java实现二维数组转置的方法,结合实例形式详细分析了java二维数组转置的原理、实现步骤与相关操作技巧,需要的朋友可以参考下
    2017-10-10
  • Java 8 动态类型语言Lambda表达式实现原理解析

    Java 8 动态类型语言Lambda表达式实现原理解析

    Java 8支持动态语言，看到了很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。接下来通过本文给大家介绍Java 8 动态类型语言Lambda表达式实现原理分析,需要的朋友可以参考下
    2017-02-02
  • 使用IDEA如何导入SpringBoot项目

    使用IDEA如何导入SpringBoot项目

    这篇文章主要介绍了使用IDEA如何导入SpringBoot项目问题,具有很好的参考价值,希望对大家有所帮助,
    2023-12-12
  • spring XML配置文件标签详解

    spring XML配置文件标签详解

    这篇文章主要介绍了spring XML配置文件标签详解,本文给大家介绍的非常详细,感兴趣的朋友一起看看吧
    2024-12-12
  • java实现收藏功能

    java实现收藏功能

    这篇文章主要为大家详细介绍了java实现收藏功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-08-08
  • java如何根据提供word模板导出word文档详解

    java如何根据提供word模板导出word文档详解

    在日常的开发工作中,我们时常会遇到导出Word文档报表的需求,比如公司的财务报表、医院的患者统计报表、电商平台的销售报表等等,这篇文章主要给大家介绍了关于java如何根据提供word模板导出word文档的相关资料,需要的朋友可以参考下
    2023-09-09
  • Java实现数据库连接池简易教程

    Java实现数据库连接池简易教程

    这篇文章主要为大家介绍了Java实现数据库连接池简易教程，感兴趣的小伙伴们可以参考一下
    2016-01-01
  • springmvc拦截器登录验证示例

    springmvc拦截器登录验证示例

    本篇文章主要介绍了springmvc拦截器登录验证示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-03-03

最新评论