Redis 从入门到精通【应用篇】之SpringBoot Redis 配置多数据源
使用 RedisTemplate 支持多个 Redis 数据库
0. Redis从入门到精通系列文章
- 《Redis 从入门到精通【进阶篇】之Lua脚本详解》
- 《Redis 从入门到精通【实践篇】SpringBoot Redis 配置多数据源》
- 《Redis 从入门到精通【进阶篇】三分钟了解Redis地理位置数据结构GeoHash》
- 《Redis 从入门到精通【进阶篇】一文学会Lua脚本》
- 《Redis使用Lua脚本和Redisson来保证库存扣减中的原子性和一致性》
- 《SpringBoot Redis 使用Lettuce和Jedis配置哨兵模式》
- 《Redis【应用篇】之RedisTemplate基本操作》
- 《Redis 从入门到精通【实践篇】之SpringBoot配置Redis多数据源》
- 《Redis 从入门到精通【进阶篇】之三分钟了解Redis HyperLogLog 数据结构》
- 《Redis 从入门到精通【进阶篇】之三分钟了解Redis地理位置数据结构GeoHash》
- 《Redis 从入门到精通【进阶篇】之高可用哨兵机制(Redis Sentinel)详解》
- 《Redis 从入门到精通【进阶篇】之redis主从复制详解》
- 《Redis 从入门到精通【进阶篇】之Redis事务详解》
- 《Redis从入门到精通【进阶篇】之对象机制详解》
- 《Redis从入门到精通【进阶篇】之消息传递发布订阅模式详解》
- 《Redis从入门到精通【进阶篇】之持久化 AOF详解》
- 《Redis从入门到精通【进阶篇】之持久化RDB详解》
- 《Redis从入门到精通【高阶篇】之底层数据结构字典(Dictionary)详解》
- 《Redis从入门到精通【高阶篇】之底层数据结构快表QuickList详解》
- 《Redis从入门到精通【高阶篇】之底层数据结构简单动态字符串(SDS)详解》
- 《Redis从入门到精通【高阶篇】之底层数据结构压缩列表(ZipList)详解》
- 《Redis从入门到精通【进阶篇】之数据类型Stream详解和使用示例》
感谢@爱喝茶同学和其他几位同学的问题反馈。对Redis多数据源进行了改造升级,兼容不同版本和硬编码配置项的问题,将Jedis 替换为Lettuce, 支持<=Spring boot 2.7.12
1.教程
0. 添加依赖
在项目中使用 RedisTemplate 支持多个 Redis 数据库之前,需要先添加 Spring Data Redis 的依赖。在 Maven 项目中,可以通过在 pom.xml 文件中添加以下依赖来引入 Spring Data Redis:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<spring-boot.version>2.7.12</spring-boot.version>
1. 配置多个 Redis 连接信息
在 Spring Boot 中,可以通过在 application.properties 或 application.yml 文件中指定不同的 Redis 连接信息来配置多个 RedisConnectionFactory 实例,并通过 @Bean 注解将它们注入到 RedisTemplate 中,例如:
Redis的常用配置大概是这些
# Redis 服务器的主机名或 IP 地址
spring.redis.host=127.0.0.1
# Redis 服务器的端口号
spring.redis.port=6379
# Redis 服务器的密码,如果没有设置密码,则为空字符串
spring.redis.password=
# Redis 数据库的编号,默认为 0
spring.redis.database=0
# Redis 服务器连接超时时间(毫秒),默认为 5000 毫秒
spring.redis.timeout=5000
# 连接池最大连接数,即最多允许多少个客户端同时连接到 Redis 服务器
spring.redis.pool.max-active=8
# 连接池中最大空闲连接数,即在连接池中最多允许多少个连接处于空闲状态
spring.redis.pool.max-idle=8
# 连接池中最小空闲连接数,即在连接池中最少保持多少个连接处于空闲状态
spring.redis.pool.min-idle=0
# 连接池最大等待时间(毫秒),即当连接池中的连接全部被占用时,新的连接请求最多等待多长时间
# 如果设置为-1,则表示无限等待
spring.redis.pool.max-wait=-1
# 是否启用 SSL 加密连接,默认为 false
spring.redis.ssl=false
我们将上面的配置改造一下,支持Redis多数据源
有同学反馈之前的写法有两方面问题,配置写死了,新增一个Redis 实例,需要改代码。还有一个问题是如果没有排除spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
会报错
所以本次进行修正。将配置支持不限个数的Redis数据源,将Jedis
客户端改为了lettuce
Spring boot版本升级为<spring-boot.version>2.7.12</spring-boot.version>
# 配置 Redis 数据库 主数据源
spring.redis.master.host=172.0.0.1
spring.redis.master.port=6379
spring.redis.master.password=
spring.redis.master.database=15
spring.redis.master.timeout=5000
spring.redis.master.pool.max-active=8
spring.redis.master.pool.max-idle=8
spring.redis.master.pool.min-idle=0
spring.redis.master.pool.max-wait=-1
spring.redis.master.ssl=false
# 配置 Redis 数据库 0
spring.redis.database0.host=172.0.0.1
spring.redis.database0.port=6379
spring.redis.database0.password=
spring.redis.database0.database=0
spring.redis.database0.timeout=5000
spring.redis.database0.pool.max-active=8
spring.redis.database0.pool.max-idle=8
spring.redis.database0.pool.min-idle=0
spring.redis.database0.pool.max-wait=-1
spring.redis.database0.ssl=false
# 配置 Redis 数据库 1
spring.redis.database1.host=172.0.0.1
spring.redis.database1.port=6379
spring.redis.database1.password=
spring.redis.database1.database=1
spring.redis.database1.timeout=5000
spring.redis.database1.pool.max-active=8
spring.redis.database1.pool.max-idle=8
spring.redis.database1.pool.min-idle=0
spring.redis.database1.pool.max-wait=-1
spring.redis.database1.ssl=false
2. 配置
@ConfigurationProperties(prefix = "spring.redis.database0")
和 @ConfigurationProperties(prefix = "spring.redis.database1")
注解来将不同的 Redis 配置注入到 Java 类中,例如:
package com.icepip.project;
import com.alibaba.nacos.common.utils.StringUtils;
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.beans.MutablePropertyValues;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.MapPropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@Configuration
@ConfigurationProperties(prefix = "spring")
public class RedisConfig implements ApplicationContextAware, InitializingBean, BeanPostProcessor {
/**
* 将多个Redis 数据源的配置信息放到一个Map中,然后遍历Map 创建不同的RedisTemplate实例
* Map<String, Map<String, Object>> redis 中的 key 为配置的spring.redis.xx xx为key value xx一组的值组装成了map
* 创建的RedisTemplate实例的名称为 xxRedisTemplate
*/
protected static Map<String, Map<String, Object>> redis = new HashMap<>();
// 配置主数据源
@Value("${primary.redis.key:master}")
private String primaryKey;
private static ApplicationContext applicationContext;
public RedisConfig() {
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
RedisConfig.applicationContext = applicationContext;
}
@Override
public void afterPropertiesSet() {
redis.forEach((k, v) -> {
if (Objects.equals(k, this.primaryKey)) {
Map<String, Object> paramMap = new HashMap(4);
v.forEach((k1, v1) -> {
paramMap.put("spring.redis." + k1, v1);
});
MapPropertySource mapPropertySource = new MapPropertySource("redisAutoConfigProperty", paramMap);
((StandardEnvironment) applicationContext.getEnvironment()).getPropertySources().addLast(mapPropertySource);
}
RedisConnectionFactory lettuceConnectionFactory = this.buildLettuceConnectionFactory(k, v, this.buildGenericObjectPoolConfig(k, v));
this.buildRedisTemplate(k, lettuceConnectionFactory);
this.buildStringRedisTemplate(k, lettuceConnectionFactory);
});
}
@Bean
public RedisTemplate<Object, Object> redisTemplate() {
Map<String, Object> redisParam = redis.get(this.primaryKey);
GenericObjectPoolConfig<?> genericObjectPoolConfig = this.buildGenericObjectPoolConfig(this.primaryKey, redisParam);
RedisConnectionFactory lettuceConnectionFactory = this.buildLettuceConnectionFactory(this.primaryKey, redisParam, genericObjectPoolConfig);
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(lettuceConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean
public StringRedisTemplate stringRedisTemplate() {
Map<String, Object> redisParam = redis.get(this.primaryKey);
GenericObjectPoolConfig<?> genericObjectPoolConfig = this.buildGenericObjectPoolConfig(this.primaryKey, redisParam);
RedisConnectionFactory lettuceConnectionFactory = this.buildLettuceConnectionFactory(this.primaryKey, redisParam, genericObjectPoolConfig);
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(lettuceConnectionFactory);
return template;
}
private void buildStringRedisTemplate(String k, RedisConnectionFactory lettuceConnectionFactory) {
ConstructorArgumentValues constructorArgumentValues = new ConstructorArgumentValues();
constructorArgumentValues.addIndexedArgumentValue(0, lettuceConnectionFactory);
this.setCosBean(k + "StringRedisTemplate", StringRedisTemplate.class, constructorArgumentValues);
}
private void buildRedisTemplate(String k, RedisConnectionFactory lettuceConnectionFactory) {
Jackson2JsonRedisSerializer<?> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper);
Map<String, Object> original = new HashMap<>(2);
original.put("connectionFactory", lettuceConnectionFactory);
original.put("valueSerializer", serializer);
original.put("keySerializer", new StringRedisSerializer());
original.put("hashKeySerializer", new StringRedisSerializer());
original.put("hashValueSerializer", serializer);
this.setBean(k + "RedisTemplate", RedisTemplate.class, original);
}
public GenericObjectPoolConfig<?> buildGenericObjectPoolConfig(String redisKey, Map<String, Object> param) {
GenericObjectPoolConfig<?> result;
if (applicationContext.containsBean(redisKey + "GenericObjectPoolConfig")) {
result = getBean(redisKey + "GenericObjectPoolConfig");
} else {
Map<String, Object> original = new HashMap<>(8);
original.put("maxTotal", param.getOrDefault("maxTotal", 8));
original.put("maxIdle", param.getOrDefault("maxIdle", 8));
original.put("minIdle", param.getOrDefault("minIdle", 0));
original.put("maxWaitMillis", param.getOrDefault("maxWaitMillis", -1L));
original.put("testOnBorrow", param.getOrDefault("testOnBorrow", Boolean.FALSE));
this.setBean(redisKey + "GenericObjectPoolConfig", GenericObjectPoolConfig.class, original);
result = getBean(redisKey + "GenericObjectPoolConfig");
}
return result;
}
public RedisConnectionFactory buildLettuceConnectionFactory(String redisKey, Map<String, Object> param, GenericObjectPoolConfig genericObjectPoolConfig) {
if (!applicationContext.containsBean(redisKey + "redisConnectionFactory")) {
long timeout = Long.parseLong((String) param.getOrDefault("timeout", "3000"));
LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder().commandTimeout(Duration.ofMillis(timeout)).poolConfig(genericObjectPoolConfig).build();
RedisConfiguration firstArgument = null;
// 根据配置项判断是否是集群或者哨兵或者单机
if (this.isCluster(param)) {
firstArgument = this.buildClusterConfig(param);
} else if (this.isSentinel(param)) {
firstArgument = this.buildSentinelConfig(param);
} else {
firstArgument = this.buildStandaloneConfig(param);
}
ConstructorArgumentValues constructorArgumentValues = new ConstructorArgumentValues();
constructorArgumentValues.addIndexedArgumentValue(0, firstArgument);
constructorArgumentValues.addIndexedArgumentValue(1, clientConfig);
this.setCosBean(redisKey + "redisConnectionFactory", LettuceConnectionFactory.class, constructorArgumentValues);
}
return getBean(redisKey + "redisConnectionFactory");
}
private RedisStandaloneConfiguration buildStandaloneConfig(Map<String, Object> param) {
RedisStandaloneConfiguration standaloneConfig = new RedisStandaloneConfiguration();
standaloneConfig.setHostName(String.valueOf(param.get("host")));
standaloneConfig.setDatabase(Integer.parseInt((String) param.get("database")));
standaloneConfig.setPort(Integer.parseInt((String) param.get("port")));
standaloneConfig.setPassword(RedisPassword.of((String) param.get("password")));
return standaloneConfig;
}
private RedisSentinelConfiguration buildSentinelConfig(Map<String, Object> param) {
RedisSentinelConfiguration config = new RedisSentinelConfiguration();
// todo 如果是哨兵模式需要要在此处额外的配置,可以完善
return config;
}
private RedisClusterConfiguration buildClusterConfig(Map<String, Object> param) {
RedisClusterConfiguration config = new RedisClusterConfiguration();
// todo 如果是Cluster模式需要在此处额外的配置,可以完善
return config;
}
private static void checkApplicationContext() {
if (applicationContext == null) {
throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextUtil");
}
}
public static <T> T getBean(String name) {
checkApplicationContext();
return applicationContext.containsBean(name) ? (T) applicationContext.getBean(name) : null;
}
public synchronized void setBean(String beanName, Class<?> clazz, Map<String, Object> original) {
checkApplicationContext();
DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
if (!beanFactory.containsBean(beanName)) {
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(clazz);
if (beanName.startsWith(this.primaryKey)) {
definition.setPrimary(true);
}
definition.setPropertyValues(new MutablePropertyValues(original));
beanFactory.registerBeanDefinition(beanName, definition);
}
}
public synchronized void setCosBean(String beanName, Class<?> clazz, ConstructorArgumentValues original) {
checkApplicationContext();
DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
if (!beanFactory.containsBean(beanName)) {
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(clazz);
if (beanName.startsWith(this.primaryKey)) {
definition.setPrimary(true);
}
definition.setConstructorArgumentValues(new ConstructorArgumentValues(original));
beanFactory.registerBeanDefinition(beanName, definition);
}
}
private boolean isSentinel(Map<String, Object> param) {
String sentinelMaster = (String) param.get("sentinel.master");
String sentinelNodes = (String) param.get("sentinel.nodes");
return StringUtils.isNotEmpty(sentinelMaster) && StringUtils.isNotEmpty(sentinelNodes);
}
private boolean isCluster(Map<String, Object> param) {
String clusterNodes = (String) param.get("cluster.nodes");
return StringUtils.isNotEmpty(clusterNodes);
}
public Map<String, Map<String, Object>> getRedis() {
return redis;
}
}
使用
@ConfigurationProperties(prefix = "spring")
注解将不同的redis Map配置 实例中,并通过动态构造RedisTemplate
实例.并且放置到Spring容器中, 这样,在代码中就可以通过@Qualifier
注解来注入不同的RedisTemplate
实例,从而访问不同的 Redis 数据库。还有同学反馈 需要有个主Redis 实例,所以又把RedisTemplate 手动构造了一份放置容器
3. 使用 RedisTemplate 实例
在 Spring Boot 中,可以通过 @Qualifier
和 @Autowired
注解将不同的 RedisTemplate 实例注入到 Java 类中,例如:
@RestController
public class ConsumerController {
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
@Qualifier("database0RedisTemplate")
private RedisTemplate<Object, Object> redisTemplate0;
@Autowired
@Qualifier("database1RedisTemplate")
private RedisTemplate<Object, Object> redisTemplate1;
@Autowired
@Qualifier("database0StringRedisTemplate")
private StringRedisTemplate stringRedisTemplate0;
@Autowired
@Qualifier("database1StringRedisTemplate")
private StringRedisTemplate stringRedisTemplate1;
@GetMapping("/call")
public String call() {
return "call";
}
@GetMapping("/save")
public String save() {
return "save";
}
}
4. 使用 RedisTemplate 操作 Redis
在 RedisTemplate 中,提供了一系列方法来操作 Redis,例如:
// 存储数据到 Redis 数据库 0
redisTemplate0.opsForValue().set("key0", "value0");
// 获取数据从 Redis 数据库 0
Object value0 = redisTemplate0.opsForValue().get("key0");
// 删除数据从 Redis 数据库 0
redisTemplate0.delete("key0");
// 存储数据到 Redis 数据库 1
redisTemplate1.opsForValue().set("key1", "value1");
// 获取数据从 Redis 数据库 1
Object value1 = redisTemplate1.opsForValue().get("key1");
// 删除数据从 Redis 数据库 1
redisTemplate1.delete("key1");
2. 常见问题
按照之前版本在使用 Spring Boot 中的 Redis 进行多数据源配置时,可能会遇到以下几个常见问题,新版本应该不会遇到,已经做了兼容。
2.1. RedisTemplate 实例重名问题
在配置多个 Redis 数据库时,需要为每个 Redis 数据库创建一个 RedisTemplate 实例。如果不同的 RedisTemplate 实例的名称相同,可能会导致实例重名的问题,进而导致应用程序无法启动。为每个 RedisTemplate 实例指定不同的名称。例如,可以在配置类中通过 @Bean 注解为每个 RedisTemplate 实例指定名称
@Bean(name = "redisTemplate0")
public RedisTemplate<String, Object> redisTemplate0(RedisConnectionFactory redisConnectionFactory0) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory0);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Bean(name = "redisTemplate1")
public RedisTemplate<String, Object> redisTemplate1(RedisConnectionFactory redisConnectionFactory1) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory1);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
在上面的代码中,我们分别为两个 RedisTemplate 实例指定了不同的名称,分别为 “redisTemplate0” 和 “redisTemplate1”。
2.2. RedisConnectionFactory 实例重用问题
在配置多个 Redis 数据库时,需要为每个 Redis 数据库创建一个 RedisConnectionFactory 实例。如果多个 RedisConnectionFactory 实例使用了同一个 Redis 连接池,可能会导致实例重用的问题,进而导致应用程序无法启动。可以为每个 RedisConnectionFactory 实例配置不同的 Redis 连接池。例如,可以在配置类中创建不同的 RedisConnectionFactory 实例,并分别为它们配置不同的 Redis 连接池
@Bean(name = "redisConnectionFactory0")
public RedisConnectionFactory redisConnectionFactory0() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName("localhost");
config.setPort(6379);
config.setPassword(RedisPassword.of("password"));
LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(config);
connectionFactory.setDatabase(0);
connectionFactory.afterPropertiesSet();
return connectionFactory;
}
@Bean(name = "redisConnectionFactory1")
public RedisConnectionFactory redisConnectionFactory1() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName("localhost");
config.setPort(6379);
config.setPassword(RedisPassword.of("password"));
LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(config);
connectionFactory.setDatabase(1);
connectionFactory.afterPropertiesSet();
return connectionFactory;
}
2.3. 数据库编号配置问题
在配置多个 Redis 数据库时,需要为每个 Redis 数据库指定不同的数据库编号。如果多个 Redis 数据库使用了同一个数据库编号,可能会导致数据被覆盖或丢失。为了解决这个问题,可以为每个 RedisConnectionFactory 实例配置不同的数据库编号。例如,可以在 RedisStandaloneConfiguration 中指定不同的数据库编号
@Bean(name = "redisConnectionFactory0")
public RedisConnectionFactory redisConnectionFactory0() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName("localhost");
config.setPort(6379);
config.setPassword(RedisPassword.of("password"));
config.setDatabase(0);
LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(config);
connectionFactory.afterPropertiesSet();
return connectionFactory;
}
@Bean(name = "redisConnectionFactory1")
public RedisConnectionFactory redisConnectionFactory1() {
RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
config.setHostName("localhost");
config.setPort(6379);
config.setPassword(RedisPassword.of("password"));
config.setDatabase(1);
LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(config);
connectionFactory.afterPropertiesSet();
return connectionFactory;
}
2.4. RedisTemplate 序列化问题
在使用 RedisTemplate 时,需要对数据进行序列化和反序列化。如果不同的 Redis 数据库使用了不同的序列化方式,可能会导致数据无法正常读写。每个 RedisTemplate 实例指定不同的序列化器。例如,可以为每个 RedisTemplate 实例分别设置不同的 keySerializer 和 valueSerializer 。但是通常情况下我们的的项目中的序列化方式都是一致的,除非是在连别的项目的Redis时候人家已经按自己的序列化方式将值已经写入,我们只能按照对接方的方式配置序列化。文章来源:https://www.toymoban.com/news/detail-599074.html
@Bean(name = "redisTemplate0")
public RedisTemplate<String, Object> redisTemplate0(RedisConnectionFactory redisConnectionFactory0) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory0);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Bean(name = "redisTemplate1")
public RedisTemplate<String, Object> redisTemplate1(RedisConnectionFactory redisConnectionFactory1) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory1);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
大家好,我是冰点,今天的Redis【实践篇】之SpringBoot Redis 配置多数据源,全部内容就是这些。如果你有疑问或见解可以在评论区留言。文章来源地址https://www.toymoban.com/news/detail-599074.html
到了这里,关于SpringBoot Redis 配置多数据源的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!