SpringBoot实现Redis多数据库切换(多数据源配置)
更新时间：2025年07月09日 08:40:58 作者：Anfioo
在实际开发中,随着业务复杂度提升,我们常常会遇到 Redis 需要按不同业务模块分库管理的需求,本文将以 Spring Boot 为例,教大家如何优雅地实现 Redis 多数据库（多数据源）切换,需要的可以了解下
在实际开发中，随着业务复杂度提升，我们常常会遇到 Redis 需要按不同业务模块（如认证、聊天等）分库管理的需求。这样做可以实现数据隔离、便于运维和扩展。本文将以 Spring Boot 为例，手把手教你如何优雅地实现 Redis 多数据库（多数据源）切换。
效果展示
这里只是范例，大家拿到我的实现即可集成到项目中
接口Auth和Chat使用了不同的redis库
配置了不同的redis库
Auth
发送请求并拿到redis的键值
并出现在redis数据库1中
正常拿到数据
Chat
发送请求并拿到redis的键值
并出现在redis数据库2中
正常拿到数据
实现了不同的redis数据库
需求场景
假设我们有如下需求：
- auth 业务使用 Redis 的第 1 号数据库（database=1）
- chat 业务使用 Redis 的第 2 号数据库（database=2）
- 还有一个默认 Redis（database=0）供其他业务使用
我们希望通过配置和代码实现，能够灵活地在不同 Redis 数据库间切换和操作。
配置文件编写
首先，在 application-redis.yml 中分别配置不同的 Redis 数据源：
spring:
data:
redis:
host: localhost
port: 6379
database: 0 # 默认 Redis，JWT 用
auth-redis:
host: localhost
port: 6379
database: 1 # 默认 Redis，JWT 用
chat-redis:
host: localhost
port: 6379
database: 2 # 用于 ChatHistory
属性类封装
为每个自定义 Redis 数据源编写属性类，方便后续自动注入：
AuthRedisProperties.java
package com.anfioo.common.bean;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConfigurationProperties(prefix = "spring.data.auth-redis")
@Data
public class AuthRedisProperties {
private String host;
private int port;
private int database;
}
ChatRedisProperties.java
package com.anfioo.common.bean;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConfigurationProperties(prefix = "spring.data.chat-redis")
@Data
public class ChatRedisProperties {
private String host;
private int port;
private int database;
}
多数据源 Redis 配置
核心配置类如下：
RedisConfig.java
package com.anfioo.admin.config;
import com.anfioo.common.bean.AuthRedisProperties;
import com.anfioo.common.bean.ChatRedisProperties;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
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.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
* Redis配置类，启用Spring Cache并定义多个Redis实例和模板
*/
@Configuration
@EnableCaching
public class RedisConfig {
// ======================= 默认 Redis (database=0) =======================
/**
* 创建默认Redis连接工厂
* @param redisProperties Redis属性配置
* @return LettuceConnectionFactory实例
*/
@Primary
@Bean(name = "defaultRedisConnectionFactory")
public LettuceConnectionFactory defaultRedisConnectionFactory(RedisProperties redisProperties) {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName(redisProperties.getHost());
config.setPort(redisProperties.getPort());
config.setDatabase(redisProperties.getDatabase());
return new LettuceConnectionFactory(config);
}
/**
* 创建默认Redis模板
* @param factory Redis连接工厂
* @return RedisTemplate实例
*/
@Primary
@Bean(name = "defaultRedisTemplate")
public RedisTemplate<Object, Object> defaultRedisTemplate(
@Qualifier("defaultRedisConnectionFactory") RedisConnectionFactory factory) {
return createRedisTemplate(factory);
}
/**
* Spring Cache使用的CacheManager（绑定 defaultRedis database=0）
* @param factory Redis连接工厂
* @return CacheManager实例
*/
@Primary
@Bean
public CacheManager cacheManager(@Qualifier("defaultRedisConnectionFactory") RedisConnectionFactory factory) {
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofHours(1))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(
new Jackson2JsonRedisSerializer<>(Object.class)));
return RedisCacheManager.builder(factory).cacheDefaults(config).build();
}
// ======================= Auth Redis (database=1) =======================
/**
* 创建Auth Redis连接工厂
* @param properties Auth Redis属性配置
* @return LettuceConnectionFactory实例
*/
@Bean(name = "authRedisConnectionFactory")
public LettuceConnectionFactory authRedisConnectionFactory(AuthRedisProperties properties) {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName(properties.getHost());
config.setPort(properties.getPort());
config.setDatabase(properties.getDatabase());
return new LettuceConnectionFactory(config);
}
/**
* 创建Auth Redis模板
* @param factory Redis连接工厂
* @return RedisTemplate实例
*/
@Bean(name = "authRedisTemplate")
public RedisTemplate<Object, Object> authRedisTemplate(
@Qualifier("authRedisConnectionFactory") RedisConnectionFactory factory) {
return createRedisTemplate(factory);
}
// ======================= Chat Redis (database=2) =======================
/**
* 创建Chat Redis连接工厂
* @param properties Chat Redis属性配置
* @return LettuceConnectionFactory实例
*/
@Bean(name = "chatRedisConnectionFactory")
public LettuceConnectionFactory chatRedisConnectionFactory(ChatRedisProperties properties) {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName(properties.getHost());
config.setPort(properties.getPort());
config.setDatabase(properties.getDatabase());
return new LettuceConnectionFactory(config);
}
/**
* 创建Chat Redis模板
* @param factory Redis连接工厂
* @return RedisTemplate实例
*/
@Bean(name = "chatRedisTemplate")
public RedisTemplate<Object, Object> chatRedisTemplate(
@Qualifier("chatRedisConnectionFactory") RedisConnectionFactory factory) {
return createRedisTemplate(factory);
}
// ======================= 公共 RedisTemplate 构造方法 =======================
/**
* 创建RedisTemplate实例
* @param connectionFactory Redis连接工厂
* @return RedisTemplate实例
*/
private RedisTemplate<Object, Object> createRedisTemplate(RedisConnectionFactory connectionFactory) {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
objectMapper.registerModule(new JavaTimeModule());
objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(jacksonSerializer);
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(jacksonSerializer);
template.afterPropertiesSet();
return template;
}
// ======================= 限流 Lua 脚本 =======================
/**
* 创建限流Lua脚本
* @return DefaultRedisScript实例
*/
@Bean
public DefaultRedisScript<Long> limitScript() {
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
redisScript.setScriptText(limitScriptText());
redisScript.setResultType(Long.class);
return redisScript;
}
/**
* 限流Lua脚本文本
* @return Lua脚本字符串
*/
private String limitScriptText() {
return "local key = KEYS[1]\n" +
"local count = tonumber(ARGV[1])\n" +
"local time = tonumber(ARGV[2])\n" +
"local current = redis.call('get', key);\n" +
"if current and tonumber(current) > count then\n" +
" return tonumber(current);\n" +
"end\n" +
"current = redis.call('incr', key)\n" +
"if tonumber(current) == 1 then\n" +
" redis.call('expire', key, time)\n" +
"end\n" +
"return tonumber(current);";
}
}
要点说明：
- 每个 Redis 数据库都对应一个
LettuceConnectionFactory和一个RedisTemplate。 - 通过
@Qualifier注解区分不同的 Bean。 @Primary标注默认 Redis，Spring Cache 相关功能会自动使用它。
工具类封装
为了方便业务调用，我们可以为每个 Redis 数据源封装一个工具类，继承自通用的 RedisCache：
RedisCache.java（通用工具类，支持常用操作，参考ruoyi实现）
package com.anfioo.common.utils;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* spring redis 工具类
*
* @author ruoyi
**/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisCache {
private final RedisTemplate redisTemplate;
public RedisCache(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
return redisTemplate.expire(key, timeout, unit);
}
/**
* 获取有效时间
*
* @param key Redis键
* @return 有效时间
*/
public long getExpire(final String key) {
return redisTemplate.getExpire(key);
}
/**
* 判断 key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public Boolean hasKey(String key) {
return redisTemplate.hasKey(key);
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key) {
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key) {
return redisTemplate.delete(key);
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public boolean deleteObject(final Collection collection) {
return redisTemplate.delete(collection) > 0;
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList) {
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key) {
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
Iterator<T> it = dataSet.iterator();
while (it.hasNext()) {
setOperation.add(it.next());
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key
* @return
*/
public <T> Set<T> getCacheSet(final String key) {
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey) {
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 删除Hash中的某条数据
*
* @param key Redis键
* @param hKey Hash键
* @return 是否成功
*/
public boolean deleteCacheMapValue(final String key, final String hKey) {
return redisTemplate.opsForHash().delete(key, hKey) > 0;
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern) {
return redisTemplate.keys(pattern);
}
}
AuthRedisCache.java
package com.anfioo.common.utils;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class AuthRedisCache extends RedisCache {
public AuthRedisCache(@Qualifier("authRedisTemplate") RedisTemplate redisTemplate) {
super(redisTemplate);
}
}
ChatRedisCache.java
package com.anfioo.common.utils;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Component
public class ChatRedisCache extends RedisCache {
public ChatRedisCache(@Qualifier("chatRedisTemplate") RedisTemplate redisTemplate) {
super(redisTemplate);
}
}
这样，业务层只需注入 AuthRedisCache 或 ChatRedisCache，即可操作对应的 Redis 数据库。
业务调用示例
以 Controller 为例，演示如何分别操作不同 Redis 数据库：
package com.anfioo.sys.controller;
import com.anfioo.common.core.ApiResponse;
import com.anfioo.common.core.BaseController;
import com.anfioo.sys.service.RedisDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/redis-demo")
public class RedisDemoController extends BaseController {
@Autowired
private RedisDemoService redisDemoService;
@PostMapping("/create-auth")
public ApiResponse<String> setAuthRedis() {
String s = redisDemoService.setAuthRedisValue();
return success(s);
}
@PostMapping("/create-chat")
public ApiResponse<String> setChatRedis() {
String s = redisDemoService.setChatRedisValue();
return success(s);
}
@GetMapping("/auth/{id}")
public ApiResponse<String> getAuthRedis(@PathVariable String id) {
String value = redisDemoService.getAuthRedisValueById(id);
return success(value);
}
@GetMapping("/chat/{id}")
public ApiResponse<String> getChatRedis(@PathVariable String id) {
String value = redisDemoService.getChatRedisValueById(id);
return success(value);
}
}
对应Service和其实现类
package com.anfioo.sys.service.impl;
import java.util.ArrayList;
import com.anfioo.common.utils.AuthRedisCache;
import com.anfioo.common.utils.ChatRedisCache;
import com.anfioo.sys.service.RedisDemoService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.UUID;
@Service
public class RedisDemoServiceImpl implements RedisDemoService {
@Autowired
private AuthRedisCache authRedisCache;
@Autowired
private ChatRedisCache chatRedisCache;
private static final String LOGIN_PREFIX = "login_token:";
private static final String CHAT_PREFIX = "chat_token:";
@Override
public String setAuthRedisValue() {
//todo 获取生成的jwt等等，验证登录成功与否 ，看你的设计，
//todo 键 - 可以使用唯一uuid 值 -你要放入的缓存的值
String AuthId = UUID.randomUUID().toString();
String redisKey = LOGIN_PREFIX + AuthId;
YouSaveData youSaveData = new YouSaveData();
youSaveData.setId("1");
ArrayList<String> roles = new ArrayList<>();
roles.add("user");
roles.add("manager");
youSaveData.setRole(roles);
youSaveData.setUsername("Anfioo");
youSaveData.setPassword("Anfioo666");
authRedisCache.setCacheObject(redisKey, youSaveData);
return AuthId;
}
@Override
public String setChatRedisValue() {
String chatId = UUID.randomUUID().toString();
String redisKey = CHAT_PREFIX + chatId;
YouSaveChat youSaveChat = new YouSaveChat();
youSaveChat.setChatId(chatId);
ArrayList<String> members = new ArrayList<>();
members.add("userA");
members.add("userB");
youSaveChat.setMembers(members);
youSaveChat.setChatName("Anfioo聊天室");
youSaveChat.setLastMessage("Hello, world!");
chatRedisCache.setCacheObject(redisKey, youSaveChat);
return chatId;
}
@Override
public String getAuthRedisValueById(String id) {
String redisKey = LOGIN_PREFIX + id;
Object obj = authRedisCache.getCacheObject(redisKey);
return obj != null ? obj.toString() : null;
}
@Override
public String getChatRedisValueById(String id) {
String redisKey = CHAT_PREFIX + id;
Object obj = chatRedisCache.getCacheObject(redisKey);
return obj != null ? obj.toString() : null;
}
@Data
public static class YouSaveChat {
private String chatId;
private List<String> members;
private String chatName;
private String lastMessage;
}
@Data
public static class YouSaveData {
private String id;
private List<String> role;
private String username;
private String password;
}
}
package com.anfioo.sys.service;
public interface RedisDemoService {
String setAuthRedisValue();
String setChatRedisValue();
String getAuthRedisValueById(String id);
String getChatRedisValueById(String id);
}
总结
通过以上配置和代码实现，我们就可以在 Spring Boot 项目中灵活地切换和操作多个 Redis 数据库，实现数据隔离和多业务场景支持。核心思路是：
- 配置文件中分模块配置不同 Redis 数据源
- 编写属性类和配置类，分别注入不同的
RedisTemplate - 通过工具类封装，业务层按需注入和调用
这种方式不仅适用于 auth、chat 场景，也适用于任何需要 Redis 多数据源的业务需求。
以上就是SpringBoot实现Redis多数据库切换(多数据源配置)的详细内容，更多关于SpringBoot Redis多数据库切换的资料请关注脚本之家其它相关文章！
相关文章
今天小编就为大家分享一篇关于Java基础高级综合练习题扑克牌的创建，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧2019-01-01
在Java中,对List进行排序是一项常见的任务,Java提供了多种方法来对List中的元素进行排序,本文将详细介绍如何使用Java来实现List的排序操作,涵盖了常用的排序方法和技巧,需要的朋友可以参考下2024-07-07
代码优化的最重要的作用应该是：避免未知的错误。因此，在写代码的时候，从源头开始注意各种细节，权衡并使用最优的选择，将会很大程度上避免出现未知的错误，从长远看也极大的降低了工作量2018-03-03
命令模式是将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者对请求做日志记录，以及可以支持撤销的操作2022-04-04
这篇文章主要介绍了Java实现简易扑克牌游戏的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2021-04-04
在现代Java生态系统中,Apache Maven作为项目构建的事实标准工具,其核心价值不仅体现在依赖管理能力上,更在于其灵活的插件体系,本文小编就来和大家聊聊Maven中插件调试与性能调优的相关知识吧2025-05-05
springboot扫描自定义的servlet和filter代码详解
本文是一篇根据作者工作经历总结出来的关于springboot扫描自定义的servlet和filter代码详解的文章，小编觉得非常不错，这里给大家分享下，和朋友们一起学习，进步。2017-10-10
最近有一次由于项目升级发现了一个上传方面的问题,下面这篇文章主要给大家介绍了关于SpringBoot上传文件大小受限问题的解决办法,文中通过实例代码介绍的非常详细,需要的朋友可以参考下2022-05-05
这篇文章主要介绍了Java中的JVM虚拟机内存分配详解,虚拟机是一种能够执行 Java 字节码的虚拟机,它是 Java 语言的核心组成部分,负责将 Java 代码转换为机器码并执行,JVM 提供了内存管理、垃圾回收、线程管理等功能,需要的朋友可以参考下2023-10-10
这篇文章主要为大家详细介绍了使用Servlet Filter实现系统登录权限，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2019-10-10
最新评论