前言
官方对应2.0连接Redis需要不停的刷新,重新加载配置,如下代码
/**
* 切换Redis数据库
* @param redisTemplate Redis连接
* @param database 第几个数据库
* @return 切换好的redis连接
*/
public static RedisTemplate<String, Object> changeRedisDatabase(RedisTemplate<String, Object> redisTemplate, int database) {
LettuceConnectionFactory lettuceConnectionFactory = (LettuceConnectionFactory)redisTemplate.getConnectionFactory();
if (lettuceConnectionFactory == null) {
LOGGER.error("Redis连接工厂为空,未能切换数据库");
return redisTemplate;
}
lettuceConnectionFactory.setDatabase(database);
redisTemplate.setConnectionFactory(lettuceConnectionFactory);
lettuceConnectionFactory.resetConnection();
lettuceConnectionFactory.afterPropertiesSet();
return redisTemplate;
}
多数据源,多数据库配置
Yml配置
redis:
config:
- key: redis-0
hostName: 172.16.54.209
port: 6379
database:
- 0
- key: redis-1
hostName: 172.16.54.209
port: 6380
database:
- 0
- 1
- 2
- 3
- 4
读取对应配置
package com.lihan.properties;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Data
@Component
@ConfigurationProperties(prefix = "redis")
public class RedisConfigProperties {
private List<RedisProperties> config = new ArrayList<>();
@Data
public static class RedisProperties {
/**
* Redis 别名,通过key获取对应连接
*/
private String key;
/**
* Redis 连接地址
*/
private String hostName;
/**
* Redis 连接端口
*/
private Integer port;
/**
* Redis 使用到的数据库
*/
private Integer[] database;
/**
* 用户名
*/
private String username;
/**
* 密码
*/
private String password;
}
}
生成对应Bean
package com.lihan.config;
import com.lihan.properties.RedisConfigProperties;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
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.serializer.StringRedisSerializer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Configuration
public class RedisConfigUp {
/**
* Redis多数据库Bean
*/
@Bean
public Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase(RedisConfigProperties redisConfigProperties) {
Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase = new HashMap<>();
List<RedisConfigProperties.RedisProperties> redisProperties = redisConfigProperties.getConfig();
for (RedisConfigProperties.RedisProperties redisPropertiesTemp : redisProperties) {
Map<String, RedisTemplate<String, Object>> redisTemplateMap = new HashMap<>();
for (Integer database : redisPropertiesTemp.getDatabase()) {
// 1. 配置连接
RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
redisStandaloneConfiguration.setHostName(redisPropertiesTemp.getHostName());
redisStandaloneConfiguration.setPort(redisPropertiesTemp.getPort());
if (redisPropertiesTemp.getUsername() != null && redisPropertiesTemp.getUsername().length() > 0) {
redisStandaloneConfiguration.setUsername(redisPropertiesTemp.getUsername());
}
if (redisPropertiesTemp.getPassword() != null && redisPropertiesTemp.getPassword().length() > 0) {
redisStandaloneConfiguration.setPassword(redisPropertiesTemp.getPassword());
}
// 2.配置数据库
redisStandaloneConfiguration.setDatabase(database);
// 3.设置连接池
GenericObjectPoolConfig<RedisStandaloneConfiguration> genericObjectPoolConfig = new GenericObjectPoolConfig<>();
LettuceClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(genericObjectPoolConfig).build();
LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(redisStandaloneConfiguration, lettuceClientConfiguration);
lettuceConnectionFactory.afterPropertiesSet();
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(lettuceConnectionFactory);
// key采用String的序列化方式
template.setKeySerializer(new StringRedisSerializer());
// value序列化方式采用jdk
template.setValueSerializer(new StringRedisSerializer());
template.afterPropertiesSet();
// Key 数据库名,value redis操作类
redisTemplateMap.put(String.valueOf(database), template);
}
redisTemplateDatabase.put(redisPropertiesTemp.getKey(), redisTemplateMap);
}
return redisTemplateDatabase;
}
}
对应工具类
package com.lihan.util;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class RedisUtils {
private static Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase;
/**
* 放入Redis
* @param redisKey 对应Redis连接Key
* @param database 对应数据库
* @param key 放入的Key
* @param Value 放入的Value
*/
public static void set(String redisKey, String database, String key, Object Value) {
Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
stringRedisTemplateMap.get(database).opsForValue().set(key, Value);
}
/**
* 取出Redis对应Redis值
* @param redisKey 对应Redis连接Key
* @param database 对应数据库
* @param key 取值的Key
* @return key对应的Value
*/
public static Object get(String redisKey, String database, String key) {
Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
return stringRedisTemplateMap.get(database).opsForValue().get(key);
}
public RedisUtils(Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase) {
RedisUtils.redisTemplateDatabase = redisTemplateDatabase;
}
}
对应工具类
package com.lihan.util;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Map;
@Component
public class RedisUtils {
private static Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase;
/**
* 放入Redis
* @param redisKey 对应Redis连接Key
* @param database 对应数据库
* @param key 放入的Key
* @param Value 放入的Value
*/
public static void set(String redisKey, String database, String key, Object Value) {
Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
stringRedisTemplateMap.get(database).opsForValue().set(key, Value);
}
/**
* 取出Redis对应Redis值
* @param redisKey 对应Redis连接Key
* @param database 对应数据库
* @param key 取值的Key
* @return key对应的Value
*/
public static Object get(String redisKey, String database, String key) {
Map<String, RedisTemplate<String, Object>> stringRedisTemplateMap = redisTemplateDatabase.get(redisKey);
return stringRedisTemplateMap.get(database).opsForValue().get(key);
}
public RedisUtils(Map<String, Map<String, RedisTemplate<String, Object>>> redisTemplateDatabase) {
RedisUtils.redisTemplateDatabase = redisTemplateDatabase;
}
}
测试
@Test
public void test02() {
RedisUtils.set("redis-1", "0", "test-0", "test-0");
RedisUtils.set("redis-1", "1", "test-1", "test-1");
RedisUtils.set("redis-1", "2", "test-2", "test-2");
RedisUtils.set("redis-1", "3", "test-3", "test-3");
RedisUtils.set("redis-1", "4", "test-4", "test-4");
}
@Test
public void test03() {
System.out.println(RedisUtils.get("redis-1", "0", "test-0"));
}