【分享之路001】springboot整合双redis配置

最新推荐文章于 2024-10-05 15:01:31 发布
最新推荐文章于 2024-10-05 15:01:31 发布
阅读量3.1k 收藏 12
点赞数 1
分类专栏： 分享总览 文章标签： redis spring boot 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34586455/article/details/126709115
版权
本文介绍了如何在SpringBoot项目中实现双Redis配置，详细讲述了配置文件和代码的修改步骤，包括设置两个不同的RedisConnectionFactory和RedisTemplate，以实现数据的双写。注意在使用第二个RedisTemplate时，需通过@Resource注解并指定Bean名称，以避免冲突。
摘要由CSDN通过智能技术生成

springboot双redis配置

1. 背景

springboot项目中本来用到了redis，由于业务要求，需要将数据也写到另一个redis中

2. 配置文件改动

2.1 之前redis配置*

spring.redis.database=xx
spring.redis.host=xxxx
spring.redis.port=xxx
spring.redis.password=xxx

2.2 改动后的redis配置

#原有redis配置
spring.redis.database=XX
spring.redis.host=XXX
spring.redis.port=XXX
spring.redis.password=XXXX
#双写redis配置-单点
#spring.redis2.database=XXX
#spring.redis2.host=XXXX
#spring.redis2.port=XXXX
#spring.redis2.password=XXXXX

3.代码改动

3.1 之前代码

RedisCacheConfig.java

@Configuration
public class RedisCacheConfig extends CachingConfigurerSupport {

    private static final Logger logger = LoggerFactory.getLogger(RedisCacheConfig.class);

    private static final String HOST = "spring.redis.host";
    private static final String PORT = "spring.redis.port";
    private static final String DB_INDEX = "spring.redis.database";
    private static final String PASSWORD = "spring.redis.password";

    private static final String SENTINEL_NODES = "spring.redis.sentinel.nodes";
    private static final String SENTINEL_MASTER = "spring.redis.sentinel.master";

    @Value("${spring.redis.lettuce.pool.max-active}")
    private int pollMaxActive;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int pollMaxIdle;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private int pollMaxWait;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int pollMinIdle;

    @Value("${spring.redis.timeout}")
    private int timeout;

    /**
     * key产生器，可以不用
     *
     * @return
     */
    @Bean
    public KeyGenerator wiselyKeyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };

    }

    @Bean
    public GenericObjectPoolConfig genericObjectPoolConfig() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxIdle(pollMaxIdle);
        poolConfig.setMaxTotal(pollMaxActive);
        poolConfig.setMaxWaitMillis(pollMaxWait);
        poolConfig.setMinIdle(pollMinIdle);
        return poolConfig;
    }

    @Bean
    public LettuceClientConfiguration lettuceClientConfiguration(GenericObjectPoolConfig genericObjectPoolConfig) {
        return LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig)
                .build();
    }

    @Bean
    public RedisConnectionFactory redisOneConnectionFactory() {
        int dbIndex = ConfigUtil.getInt(DB_INDEX, -1);
        String host = ConfigUtil.getValue(HOST);
        int port = ConfigUtil.getInt(PORT, -1);
        String password = ConfigUtil.getValue(PASSWORD);
        String sentinelNodes = ConfigUtil.getValue(SENTINEL_NODES);
        String sentinelMaster = ConfigUtil.getValue(SENTINEL_MASTER);
        return createLettuceConnectionFactory(dbIndex, host, port, password, sentinelNodes, sentinelMaster);
    }

    public LettuceConnectionFactory createLettuceConnectionFactory(int dbIndex, String host, int port, String password, String sentinelNodes, String sentinelMaster) {
        if (!StringUtils.isEmpty(sentinelNodes)) {
            RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(sentinelMaster, getSentinelNodes(sentinelNodes));
            redisSentinelConfiguration.setDatabase(dbIndex);
            redisSentinelConfiguration.setPassword(password);
            return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration(genericObjectPoolConfig()));
        } else if (!StringUtils.isEmpty(host)) {
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setDatabase(dbIndex);
            redisStandaloneConfiguration.setHostName(host);
            redisStandaloneConfiguration.setPort(port);
            redisStandaloneConfiguration.setPassword(password);
            return new LettuceConnectionFactory(redisStandaloneConfiguration, lettuceClientConfiguration(genericObjectPoolConfig()));
        } else {
            logger.error("未配置redis单点或哨兵，请检查配置文件！");
            return null;
        }
    }

    private Set<String> getSentinelNodes(String sentinelNodes) {
        String[] nodes = sentinelNodes.split(",");
        return new HashSet<>(Arrays.asList(nodes));
    }

    /**
     * 序列化
     *
     * @return
     */
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, String> redisTemplate() {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisOneConnectionFactory());
        setSerializer(template);
        template.afterPropertiesSet();
        template.setEnableTransactionSupport(true);
        return template;
    }

    private void setSerializer(StringRedisTemplate template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }

}

3.2 改动之后的代码

RedisTwoCacheConfig.java

@Configuration
public class RedisTwoCacheConfig extends CachingConfigurerSupport {

    private static final Logger logger = LoggerFactory.getLogger(RedisTwoCacheConfig.class);

    private static final String HOST = "spring.redis2.host";
    private static final String PORT = "spring.redis2.port";
    private static final String DB_INDEX = "spring.redis2.database";
    private static final String PASSWORD = "spring.redis2.password";

    private static final String SENTINEL_NODES = "spring.redis2.sentinel.nodes";
    private static final String SENTINEL_MASTER = "spring.redis2.sentinel.master";

    // 复用redis1的连接池配置
    @Value("${spring.redis.lettuce.pool.max-active}")
    private int pollMaxActive;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int pollMaxIdle;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private int pollMaxWait;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int pollMinIdle;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Bean
    public GenericObjectPoolConfig genericObjectPoolConfig() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxIdle(pollMaxIdle);
        poolConfig.setMaxTotal(pollMaxActive);
        poolConfig.setMaxWaitMillis(pollMaxWait);
        poolConfig.setMinIdle(pollMinIdle);
        return poolConfig;
    }

    @Bean
    public LettuceClientConfiguration lettuceClientConfiguration(GenericObjectPoolConfig genericObjectPoolConfig) {
        return LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig)
                .build();
    }

    /**
     * 配置redis连接工厂
     *
     * @return
     */
    @Primary
    @Bean
    public RedisConnectionFactory redisTwoConnectionFactory() {
        int dbIndex = ConfigUtil.getInt(DB_INDEX, -1);
        String host = ConfigUtil.getValue(HOST);
        int port = ConfigUtil.getInt(PORT, -1);
        String password = ConfigUtil.getValue(PASSWORD);
        String sentinelNodes = ConfigUtil.getValue(SENTINEL_NODES);
        String sentinelMaster = ConfigUtil.getValue(SENTINEL_MASTER);
        return createLettuceConnectionFactory(dbIndex, host, port, password, sentinelNodes, sentinelMaster);
    }

    public LettuceConnectionFactory createLettuceConnectionFactory(int dbIndex, String host, int port, String password, String sentinelNodes, String sentinelMaster) {
        if (!StringUtils.isEmpty(sentinelNodes)) {
            RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration(sentinelMaster, getSentinelNodes(sentinelNodes));
            redisSentinelConfiguration.setDatabase(dbIndex);
            redisSentinelConfiguration.setPassword(password);
            return new LettuceConnectionFactory(redisSentinelConfiguration, lettuceClientConfiguration(genericObjectPoolConfig()));
        } else if (!StringUtils.isEmpty(host)) {
            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setDatabase(dbIndex);
            redisStandaloneConfiguration.setHostName(host);
            redisStandaloneConfiguration.setPort(port);
            redisStandaloneConfiguration.setPassword(password);
            return new LettuceConnectionFactory(redisStandaloneConfiguration, lettuceClientConfiguration(genericObjectPoolConfig()));
        } else {
            logger.error("未配置redis单点或哨兵，请检查配置文件！");
            return null;
        }
    }

    private Set<String> getSentinelNodes(String sentinelNodes) {
        String[] nodes = sentinelNodes.split(",");
        return new HashSet<>(Arrays.asList(nodes));
    }

    /**
     * 配置redisTemplate 注入方式使用@Resource(name="") 方式注入
     *
     * @return
     */
    @Bean(name = "redisTwoTemplate")
    public RedisTemplate<String, String> redisTwoTemplate() {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisTwoConnectionFactory());
        setSerializer(template);
        template.afterPropertiesSet();
        template.setEnableTransactionSupport(true);
        return template;
    }

    /**
     * key产生器，可以不用
     *
     * @return
     */
    @Bean
    public KeyGenerator wiselyKeyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };

    }

    private void setSerializer(StringRedisTemplate template) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        template.setValueSerializer(jackson2JsonRedisSerializer);
    }

}

3.3 service层代码

@Component
public class XXXServiceImpl implements XXXService {
    private final static Logger logger = LoggerFactory.getLogger(XXXServiceImpl.class);
    
    @Autowired
    RedisTemplate redisTemplate;

    @Resource(name = "redisTwoTemplate")
    RedisTemplate redisTwoTemplate;
	
	/**
	* 此处为模拟真实的方法调用
	**/
	public handler() {
		String key = "redis"
		Object valueOne = redisTemplate.get(key);
		Object valueTwo = redisTwoTemplate.get(key);
	}
   }

4 注意点

  • 第二个redisTemplate必须用Resource指明Bean名称，否则报错
  • 第二个redis配置项，原则上对名称不做要求，但为了好理解，所以命名为redis2，其他保持不变

作者寄语：说实话，好久没写文章了，后面会经常写写，将工作中用到的小技巧或好的方式方法分享给大家，不喜勿喷

纯海洋之力
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
详解springboot配置多个redis连接
08-30
Spring Boot为Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自动配置。本文详细介绍了springboot配置多个redis连接，有兴趣的可以了解一下。
RedisTemplate通用工具类RedisUtils
tyjlearning的博客
10-31 1152
/** * RedisTemplate 工具类 * * @author coderBing * @version 2019/04/28 */ @Component public class RedisUtils { @Autowired private RedisTemplate redisTemplate; //- - - - - - - - - - -...
Redis基础二(spring整合redis)
最新发布
LiuCJ_20000的博客
10-05 1315
​ 在开中某些方法查询的结果要放到缓存中（redis），下一次再调用该方法查询的时候先缓存中查找，如果缓存中有数据就直接返回，否则从关系型数据库中去查询数据。
springboot 配置多个Redis数据源详解
A_awen的博客
10-31 3283
springboot 配置多个redis数据源
springboot 配置两个redis
sjian1990的博客
12-10 2209
import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import org.springframework..
Springboot配置多个redis连接
尚未佩妥剑 转眼便江湖
08-11 3526
【代码】Springboot配置多个redis连接。
springboot整合redis代码
05-14
springboot整合redis.算是比较全面的一种整合方式了. springboot整合redis.算是比较全面的一种整合方式了.
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
springboot整合redis集群零配置
07-28
首先，让我们来看看"Springboot整合Redis集群,零配置方式"。在Spring Boot中，我们可以通过引入`spring-boot-starter-data-redis`依赖来启用Redis支持。但是，要配置Redis集群，通常需要设置多个节点地址、密码、...
【SpringBoot】36、SpringBoot整合Redis实现发布/订阅
热门推荐
Asurplus
10-23 21万+
一、简介 1、发布订阅 SUBSCRIBE, UNSUBSCRIBE 和 PUBLISH 实现了 发布/订阅消息范例，发送者 (publishers) 不用编程就可以向特定的接受者发送消息 (subscribers). Rather, 发布的消息进入通道，不需要知道有没有订阅者. 订阅者发表感兴趣的一个或多个通道，并且只接受他们感兴趣的消息，不管发布者是不是存在. 发布者和订阅者的解耦可以允许更大的伸缩性和更多动态的网络拓扑。 2、说明 本篇文章是继： 【SpringBoot】三十四、SpringBoot
springboot配置两套redis 集群，并且需要用sentinel连接问题处理
suject的专栏
04-22 2490
由于公司项目功能优化需要新增一套redis 集群处理数据，那项目就要配置另一套redis 集群。 本来想找度娘解决的，谁知度娘没有相关资料，所以只能自己看了一下源码。 一般来说，直接配置文件就可以了， spring redis: sentinel: master: master nodes: 127.0.0.1:26379 password: 111111111 timeout: 20000 spring 会自动匹配并且处理。 现在新增一套，那配置不知道应该怎么写， 只能新增一个redisconfig配置类
SpringBoot连接多个Redis或者Redis里的多个不同的库_springboot 连接多个redis
2401_84264107的博客
04-15 1568
要想实现连接不同的Redis，只需要将对应的Redis地址写进配置里即可。// ================================ Map类型 =================================// =============================== List类型 =================================// ============================= 公共方法 ============================
SpringBoot连接多个Redis或者Redis里的多个不同的库
Mr_XiMu的博客
11-08 1万+
SpringBoot连接多个Redis或者Redis里的多个不同的库
springboot2 配置连接多个 redis
qyhua的专栏
12-05 803
springboot2 配置连接多个 redis的两种方案
springboot 整合 redis
weixin_42903592的博客
09-30 319
springboot 整合 redis 1:导入依赖 <!-- Spring Boot redis 依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactI
springboot 配置两个redis, 自适应配置集群redis另外在配置一个单机redis
可爱猪猪
11-27 896
spring boot 2.1.1版本 application.properties配置文件配置集群redis #redis集群 spring.redis.sentinel.master=mymaster spring.redis.sentinel.nodes=192.168.150.131:6001,192.168.150.132:6001,192.168.150.133:6001 spring.redis.database=0 spring.redis.password=czty_yhxx .
springboot项目中连接2个redis实例
weixin_30733003的博客
09-18 1248
springboot项目中连接2个redis实例 基于JDK1.8 Maven <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-sta...
SpringBoot配置多个Redis数据源
iGD_Hz的博客
10-28 2991
SpringBoot配置多RedisTemplate
springboot 整合配置redis集群
04-13
好的，关于springboot整合配置redis集群，你可以在application.properties文件中设置如下配置： ``` spring.redis.cluster.nodes=redis://node1:6379,redis://node2:6379,redis://node3:6379 spring.redis.cluster.max-redirects=3 ``` 其中，spring.redis.cluster.nodes为redis集群中所有节点的地址和端口，spring.redis.cluster.max-redirects表示redis客户端在请求时最多可以重定向的次数。 希望能帮到你，还有什么问题可以问我哦！ 对了，笑话时间到了：为什么1+1=10？因为计算机二进制是用0和1表示数字的呀！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值