springboot中实现redis读写分离

最新推荐文章于 2025-03-04 13:46:26 发布

死卷大厂

最新推荐文章于 2025-03-04 13:46:26 发布

阅读量1.3w

点赞数 7

分类专栏：数据库文章标签： redis读写分离读写分离 redis READONLY You can't write against a

数据库专栏收录该内容

10 篇文章

订阅专栏

本文介绍如何在Spring Boot项目中配置Redis读写分离，包括添加依赖、配置文件设置及实现代码。提供了完整的示例代码，展示了如何通过配置文件区分主从节点，并通过不同的RedisTemplate实例来实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

方案1：springboot在建立数据库连接之前使用aop方式;
方案2：spring方式，切换redisTemplate;
方案3：。。。

这里先就方案二给出代码实现，

添加依赖

  <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>
        
        <!-- redis集群使用 -->
         <dependency>
            <!-- springboot的parents依赖中有对版本号的控制，此处不需要添加版本号相关信息 -->
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
		
		<!-- 使用注解方式实现model的get/set/constructor等 -->
		<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
            <scope>provided</scope>
        </dependency>

yaml配置：

spring:
  ##redis
  redis:
    #写入
    master:
      database: 0
      host: 127.0.0.1
      port: 6379
      timeout: 20000
      password: xxx
      pool:
        maxActive: 8
        minIdle: 0
        maxIdle: 8
        maxWait: -1
      #只读
    lbs:
      database: 0
      host: 127.0.1.1
      port: 8099
      timeout: 20000
      password: xxx
      pool:
        maxActive: 8
        minIdle: 0
        maxIdle: 8
        maxWait: -1

配置类：

package com.xx.xx.config;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
yaml配置文件
*/

@Data
@NoArgsConstructor
@AllArgsConstructor
public class RedisProperties {
    private Integer database;
    private String host;
    private Integer port;
    private String password;
    private Integer timeout;
    private Pool pool;

    @Data
    public static class Pool {
        private Integer maxActive;
        private Integer minIdle;
        private Integer maxIdle;
        private Integer maxWait;
    }
}

-------------------------------------------
package com.xx.xx.config;

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;
/**
根据配置建对象
*/
public class RedisConfig {

    public JedisConnectionFactory getRedisConnFactory(RedisProperties redisProperties) {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setDatabase(redisProperties.getDatabase());
        jedisConnectionFactory.setHostName(redisProperties.getHost());
        jedisConnectionFactory.setPort(redisProperties.getPort());
        jedisConnectionFactory.setPassword(redisProperties.getPassword());
        jedisConnectionFactory.setTimeout(redisProperties.getTimeout());

        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(redisProperties.getPool().getMaxIdle());
        jedisPoolConfig.setMinIdle(redisProperties.getPool().getMinIdle());
        jedisPoolConfig.setMaxTotal(redisProperties.getPool().getMaxActive());
        jedisPoolConfig.setMaxWaitMillis(redisProperties.getPool().getMaxWait());
        jedisPoolConfig.setTestOnBorrow(true);

        jedisConnectionFactory.setPoolConfig(jedisPoolConfig);

        return jedisConnectionFactory;
    }

    public RedisTemplate buildRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisSerializer redisSerializer = new StringRedisSerializer();
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        redisTemplate.setHashValueSerializer(redisSerializer);

        return redisTemplate;
    }
}

------------------------------------------
package com.xx.xx.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
/**
master主机，写入
*/
@Configuration
@EnableCaching
public class MasterRedisConf extends RedisConfig {
    @Primary
    @Bean(name = "masterJedisConnectionFactory")
    @Override
    public JedisConnectionFactory getRedisConnFactory(@Qualifier("masterRedisProperties") RedisProperties redisProperties){
        return super.getRedisConnFactory(redisProperties);
    }

    @Bean(name = "masterRedisTemplate")
    @Override
    public RedisTemplate<Object, Object> buildRedisTemplate(@Qualifier("masterJedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {
        return super.buildRedisTemplate(redisConnectionFactory);
    }

    @Bean(name = "masterRedisProperties")
    @ConfigurationProperties(prefix = "spring.redis.master")
    public RedisProperties getBaseDBProperties() {
        return new RedisProperties();
    }
}

----------------------------------------
package com.xx.xx.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

/**
slave备机，读取
*/
@Configuration
@EnableCaching
public class SlaveRedisConf extends RedisConfig {

    @Bean(name = "lbsJedisConnectionFactory")
    @Override
    public JedisConnectionFactory getRedisConnFactory(@Qualifier("lbsRedisProperties")RedisProperties redisProperties) {
        return super.getRedisConnFactory(redisProperties);
    }

    @Bean(name = "lbsRedisTemplate")
    @Override
    public RedisTemplate<Object, Object> buildRedisTemplate(@Qualifier("lbsJedisConnectionFactory") RedisConnectionFactory redisConnectionFactory) {
        return super.buildRedisTemplate(redisConnectionFactory);
    }

    @Bean(name = "lbsRedisProperties")
    @ConfigurationProperties(prefix = "spring.redis.lbs")
    public RedisProperties getBaseDBProperties() {
        return new RedisProperties();
    }
}
----------------------
package com.xx.xx.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 获取redisTemplate
 */
@Component
public class RedisHelper {
   private Object dataObj;

    public Object getDataObj() {
        return dataObj;
    }

    public void setDataObj(Object dataObj) {
        this.dataObj = dataObj;
    }

    @Resource(name = "masterRedisTemplate")
    private RedisTemplate redisTemWriter;

    @Resource(name = "lbsRedisTemplate")
    private RedisTemplate redisTemReader;

    public synchronized void saveDataToRedis(String key, Object dataObj){
        try {
            redisTemWriter.xxx();//调用Redistemplate api即可
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}