SpringBoot项目，配置Redis多数据源

最新推荐文章于 2024-07-05 14:23:08 发布
最新推荐文章于 2024-07-05 14:23:08 发布
阅读量507 收藏 1
点赞数
分类专栏： Spring系列 文章标签： redis 多数据源 springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cactus_lrg/article/details/106618463
版权

一、maven依赖

Springboot版本: 1.5.6.RELEASE
<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--多数据源-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

二、redis配置文件

2.1 application.yml
spring:
  redis:
    host: xxx.xxx.xxx.xxx
    port: xxxx
    timeout: 0
    pool:
      max-active: 8
      max-wait: -1
      max-idle: 8
      min-idle: 0
  redis2:
    host: xxx.xxx.xxx.xxx
    port: xxxx
    timeout: 0
2.2 redis配置类通用父类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Created by liruigao
 * Date: 2020-06-01 13:54
 * Description:
 */

@EnableCaching
@Configuration
public class CommonRedisConfig {
    @Value("${spring.redis.pool.max-active}")
    private int redisPoolMaxActive;

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

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

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

    /**
     * 配置CacheManager
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);
        return redisCacheManager;
    }

    /**
     * 创建redis连接工厂
     *
     * @param host
     * @param port
     * @param timeout
     * @return
     */
    public RedisConnectionFactory createJedisConnectionFactory(String host, int port, int timeout) {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(host);
        jedisConnectionFactory.setPort(port);
        jedisConnectionFactory.setTimeout(timeout);
        jedisConnectionFactory.setPoolConfig(setPoolConfig(redisPoolMaxIdle, redisPoolMinIdle,
                redisPoolMaxActive, redisPoolMaxWait));
        return jedisConnectionFactory;

    }

    /**
     * 设置连接池属性
     *
     * @param maxIdle
     * @param minIdle
     * @param maxActive
     * @param maxWait
     * @return
     */
    public JedisPoolConfig setPoolConfig(int maxIdle, int minIdle, int maxActive, int maxWait) {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxWaitMillis(maxWait);
        return poolConfig;
    }
}
2.3 redis配置类1

import org.springframework.beans.factory.annotation.Value;
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.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Map;

/**
 * Created by liruigao
 * Date: 2020-06-01 15:30
 * Description:
 */

@Configuration
public class TestRedisConfig extends CommonRedisConfig{
    @Value("${spring.redis2.host}")
    private String host2;

    @Value("${spring.redis2.port}")
    private int port2;

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

    @Value("${spring.redis.host}")
    private String host;

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

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

    /**
     * 此bean为必要的，RedisConnectionFactory默认配置项
     * 凡是未指明RedisConnectionFactory的redis配置类，均默认注入此bean
     * @return
     */
    @Primary
    @Bean(name = "defaultRedisConnectionFactory")
    public RedisConnectionFactory defaultRedisConnectionFactory() {
        return createJedisConnectionFactory(host, port, timeout);
    }

    @Bean(name = "secondRedisConnectionFactory")
    public RedisConnectionFactory secondRedisConnectionFactory() {
        return createJedisConnectionFactory(host2, port2, timeout2);
    }

    @Bean("testRedisTemplate")
    public RedisTemplate<String, String> testRedisTemplate() {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(secondRedisConnectionFactory());
        redisTemplate.setDefaultSerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean("testHmsetTemplate")
    public RedisTemplate<String, Map<String, String>> testHmsetTemplate() {
        RedisTemplate<String, Map<String, String>> hmsetTemplate = new RedisTemplate<>();
        hmsetTemplate.setConnectionFactory(secondRedisConnectionFactory());
        hmsetTemplate.setDefaultSerializer(new StringRedisSerializer());
        hmsetTemplate.afterPropertiesSet();
        return hmsetTemplate;
    }
}
2.4 redis配置类2

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.Map;

/**
 * Created by liruigao
 * Date: 2020-04-22 17:41
 * Description:
 */

@Configuration
public class RedisConfig {

    // 默认注入defaultRedisConnectionFactory
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setDefaultSerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public RedisTemplate<String, Map<String, String>> hmsetTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Map<String, String>> hmsetTemplate = new RedisTemplate<>();
        hmsetTemplate.setConnectionFactory(redisConnectionFactory);
        hmsetTemplate.setDefaultSerializer(new StringRedisSerializer());
        hmsetTemplate.afterPropertiesSet();
        return hmsetTemplate;
    }
}

三、redis通用方法类

3.1 redis通用方法类1

import com.baidu.neisou.forward.core.utils.LoggerHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * redis基础工具类
 */
@Component("TestRedisService")
public class TestRedisService {

    @Autowired
    private RedisTemplate<String, String> testRedisTemplate;

    @Autowired
    private RedisTemplate<String, Map<String, String>> testHmsetTemplate;

    /**
     * 读取缓存k
     *
     * @param key
     * @return
     */
    public String get(final String key) {
        String result = null;
        try {
            ValueOperations<String, String> operations = testRedisTemplate.opsForValue();
            result = operations.get(key);
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis get error! key:{}, e:{}", key, e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public void set(final String key, String value, Long expireTime) {
        try {
            ValueOperations<String, String> operations = testRedisTemplate.opsForValue();
            operations.set(key, value);
            // 负数过期时间则永不过期
            if (expireTime != null && expireTime > 0L) {
                testRedisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis set error! key:{}, value:{}, e:{}", key, value, e);
            e.printStackTrace();
        }
    }

    /**
     * hset
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public boolean hset(String key, String field, String value, long... expire) {
        boolean result = false;
        try {
            final byte[] rawKey = testRedisTemplate.getStringSerializer().serialize(key);
            final byte[] rawField = testRedisTemplate.getStringSerializer().serialize(field);
            final byte[] rawValue = testRedisTemplate.getStringSerializer().serialize(value);
            result = testRedisTemplate.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    boolean ret = connection.hSet(rawKey, rawField, rawValue);
                    if (expire.length > 0 && expire[0] > 0) {
                        connection.expire(rawKey, expire[0]);
                    }
                    return ret;
                }
            }, true);
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "hset error, key : {}, field : {}, value : {}, e : {}",
                    key, field, value, e);
        }
        return result;
    }

    /**
     * hget
     *
     * @param key
     * @param field
     * @return
     */
    public String hget(String key, String field) {
        final byte[] rawKey = testRedisTemplate.getStringSerializer().serialize(key);
        final byte[] rawField = testRedisTemplate.getStringSerializer().serialize(field);
        final byte[] rawValue = testRedisTemplate.execute(new RedisCallback<byte[]>() {
            public byte[] doInRedis(RedisConnection connection) {
                return connection.hGet(rawKey, rawField);
            }
        }, true);
        return testRedisTemplate.getStringSerializer().deserialize(rawValue);
    }

    public void expire(String key, long livetime) {
        testRedisTemplate.expire(key, livetime, TimeUnit.SECONDS.SECONDS);
    }

    /**
     * hmset
     * @param key
     * @param map
     * @param expire
     * @return
     */
    public void hmset(String key, Map<String, String> map, long... expire) {
        try {
            testHmsetTemplate.opsForHash().putAll(key, map);
            if (expire.length > 0 && expire[0] > 0) {
                expire(key, expire[0]);
            }
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "hmset error, key : {}, map : {}, e : {}", key, map, e);
        }
    }

}
3.2 redis通用方法类2
package com.baidu.neisou.forward.manager.redis;

import com.baidu.neisou.forward.core.utils.LoggerHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * redis基础工具类
 */
@Service("RedisService")
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Autowired
    private RedisTemplate<String, Map<String, String>> hmsetTemplate;

    /**
     * 读取缓存k
     *
     * @param key
     * @return
     */
    public String get(final String key) {
        String result = null;
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            result = operations.get(key);
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis get error! key:{}, e:{}", key, e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public void set(final String key, String value, Long expireTime) {
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            // 负数过期时间则永不过期
            if (expireTime != null && expireTime > 0L) {
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis set error! key:{}, value:{}, e:{}", key, value, e);
            e.printStackTrace();
        }
    }

    /**
     * hset
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public boolean hset(String key, String field, String value, long... expire) {
        boolean result = false;
        try {
            final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
            final byte[] rawField = redisTemplate.getStringSerializer().serialize(field);
            final byte[] rawValue = redisTemplate.getStringSerializer().serialize(value);
            result = redisTemplate.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    boolean ret = connection.hSet(rawKey, rawField, rawValue);
                    if (expire.length > 0 && expire[0] > 0) {
                        connection.expire(rawKey, expire[0]);
                    }
                    return ret;
                }
            }, true);
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "hset error, key : {}, field : {}, value : {}, e : {}",
                    key, field, value, e);
        }
        return result;
    }

    /**
     * hget
     *
     * @param key
     * @param field
     * @return
     */
    public String hget(String key, String field) {
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        final byte[] rawField = redisTemplate.getStringSerializer().serialize(field);
        final byte[] rawValue = redisTemplate.execute(new RedisCallback<byte[]>() {
            public byte[] doInRedis(RedisConnection connection) {
                return connection.hGet(rawKey, rawField);
            }
        }, true);
        return redisTemplate.getStringSerializer().deserialize(rawValue);
    }

    public void expire(String key, long livetime) {
        redisTemplate.expire(key, livetime, TimeUnit.SECONDS.SECONDS);
    }

    /**
     * hmset
     * @param key
     * @param map
     * @param expire
     * @return
     */
    public void hmset(String key, Map<String, String> map, long... expire) {
        try {
            hmsetTemplate.opsForHash().putAll(key, map);
            if (expire.length > 0 && expire[0] > 0) {
                expire(key, expire[0]);
            }
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "hmset error, key : {}, map : {}, e : {}", key, map, e);
        }
    }
}

四、测试用例


import com.baidu.neisou.forward.manager.redis.RedisService;
import com.baidu.neisou.forward.manager.redis.TestRedisService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by liruigao
 * Date: 2020-04-10 14:38
 * Description:
 */
//@Ignore
@SpringBootTest(classes = App.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class RedisServiceTest {
    @Autowired
    private RedisService redisService;
    @Autowired
    private TestRedisService testRedisService;

    @Test
    public void diffRedisTest() {
        redisService.set("test", "default redis");
        testRedisService.set("test", "second redis");
        String rlt1 = redisService.get("test");
        String rlt2 = testRedisService.get("test");
        System.out.println("redisService.get : " + rlt1);
        System.out.println("testRedisService.get : " + rlt2);

    }
}

result：

redisService.get : default redis
testRedisService.get : second redis
喜鹊先生Richard
关注
专栏目录
spring boot 2.1学习笔记【十】SpringBoot 2 集成redis多数据源
刘本龙的专栏
01-14 4771
spring boot 2.1 集成 redis 多数据源
Springboot 整合多Redis数据源、存储
weixin_44174347的博客
04-26 333
最近项目中用到了多Redis数据源，网上看的都不一样，于是自己弄了个 springboot是2.3.0的版本 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId&g
Springboot配置Redis多数据源样例
qinming的博客
01-22 430
有时候我们需要连接多个不同的redis来进行读写，下面是一个Springboot的多数据源配置demo；配置比较简单，我使用的Springboot的版本是：2.1.0.RELEASE，Springboot默认使用的连接池是:Lettuce 代码清单： pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter.
springboot + redis 实现多数据源
qq_50761817的博客
04-30 496
【代码】springboot + redis 实现多数据源。
Springboot实现Redis多数据源配置
weixin_35252069的博客
02-08 967
Springboot实现Redis多数据源
springboot配置redis多数据源
盖丽男
07-27 1259
Redis多数据源。
springboot redis多数据源
那些年的代码
09-19 2161
springboot中默认的redis配置是只能对单个redis库进行操作的。 那么我们需要多个库操作的时候这个时候就可以采用redis多数据源。 本代码参考RedisAutoConfiguration源码进行整改成的多数据源配置 注意：数据源2就是数据源1copy了一份代码，把所有的gisredis改成appredis，并去除数据源2的@Primary即可。如果还需要增加多个数据源，...
SpringBoot2整合Redis多数据源步骤详解
08-19
SpringBoot2整合Redis多数据源步骤详解 SpringBoot2整合Redis多数据源是一个非常重要的知识点， especially 在分布式系统中，REDIS作为一个高性能的Key-Value数据库，广泛应用于缓存、Session管理、消息队列等领域...
springboot干货——（十三【二】）整合redis（可配置redis多数据源）
东天里的冬天
11-27 1788
上篇博客(springboot整合redis)讲了最简单的整合redis方式，本篇博客讲讲通过RedisTemplate使用redis，与上篇博客的主要区别是本篇博客可以使用redis多数据源   一.项目结构   二.pom.xml 和上篇博客一致，此处不再赘述   三.RedisConfig.java 多数据源的配置就在此处，从demo上看，我这边只配置了redisTemp...
springboot项目框架，多数据源配置，日志，maven多环境打包，集成redis
09-27
通过添加相关依赖，配置Redis连接信息，即可使用Spring提供的API操作Redis，如JedisTemplate或ReactiveRedisTemplate，方便地进行数据的读写操作。 总结来说，这个SpringBoot项目涵盖了现代Web开发中的关键组件和...
SpringBoot配置多个Redis数据源
iGD_Hz的博客
10-28 2986
SpringBoot配置多RedisTemplate
Springboot配置Redis多数据源
Print_lin的博客
08-02 3921
Springboot默认支持一路redis，项目中有需求用到redis多数据源。本文仅基于Springboot进行多数据源配置，不依赖其它JAR包支持，理论可配置无限多的redis连接。
springboot 配置多个Redis数据源详解
A_awen的博客
10-31 3275
springboot 配置多个redis数据源
Redis 多数据源 Spring Boot 实现
最新发布
谢文峰的博客
07-05 1663
本文为大家提供一个 redis 配置多数据源的实现方案，在实际项目中遇到，分享给大家。后续如果有时间会写一个升级版本，升级方向在第5点。
springboot redis多数据源设置
weixin_33743703的博客
06-04 341
遇到这样一个需求：运营人员在发布内容的时候可以选择性的发布到测试库、开发库和线上库。 项目使用的是spring boot集成redis，实现如下： 1. 引入依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.data&lt;/groupId&gt; &lt;art...
Spring Boot实现Redis多数据源
qq_41548206的博客
08-10 1801
Spring Boot实现Redis多数据源
SpringBoot Redis 多数据源配置
Onovo的博客
03-07 635
SpringBoot Redis 多数据源配置
SpringBoot项目中Redis配置多数据库
热门推荐
Abysscarry的博客
02-17 1万+
背景： 一个小需求，单Redis服务实例下根据业务配置多个数据库，需要自定义Redis配置稍作改动才能实现，此时就不能RedisTemplate一步就位了~ 注： Redis使用 单线程-多路复用 IO模型 ，别把多业务的并发全加在一个redis实例上，最好多实例或者集群处理！ 基本的配置我就不多说了，可以参考我之前的博客：SpringBoot 整合 Redis 使用详解 直接上步骤： 在 ap...
springboot 整合 redis 配置多数据源
09-13
在Spring Boot中整合Redis多数据源需要进行以下配置步骤： 1. 导入相关依赖：在项目的pom.xml文件中添加Redis和数据源相关的依赖，例如spring-boot-starter-data-redis和spring-boot-starter-jdbc。 2. 配置Redis连接：在application.properties或application.yml文件中配置Redis连接信息，包括主机名、端口号、密码等。可以使用多个配置块来配置不同的Redis数据源。 3. 配置多数据源：在Spring Boot的配置类中使用@Configuration注解，并使用@Bean注解创建RedisTemplate和DataSource实例。通过设置不同的名称来区分多个数据源。 4. 配置数据源路由：使用AbstractRoutingDataSource抽象类创建一个自定义的数据源路由类，并实现determineCurrentLookupKey()方法，根据不同的条件返回对应的数据源名称。 5. 配置事务管理器：在配置类中创建并配置PlatformTransactionManager，用于支持多数据源的事务管理。 以上是整合Spring Boot和Redis多数据源的基本配置步骤。具体的代码示例和详细步骤可以参考引用和引用中提供的文章。这些文章详细介绍了Spring Boot整合Redis多数据源的步骤和示例代码，对于学习和实践有很大的参考价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

喜鹊先生Richard

随缘~

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

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

打赏作者

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

抵扣说明：

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

余额充值