redis多数据源
因为代码简单，所有没有太多注释，请谅解
一.基础配置类
主要用于加载redis配置
@Configuration
@ConfigurationProperties(prefix = "spring.multiple-redis")
public class RedisConfig {
private String primary;
private Map source;
private Map pool;
public String getPrimary() {
return primary;
}
public void setPrimary(String primary) {
this.primary = primary;
}
public Map getSource() {
return source;
}
public void setSource(Map source) {
this.source = source;
}
public Map getPool() {
return pool;
}
public void setPool(Map pool) {
this.pool = pool;
}
}
/**
* 详细信息
*/
class Detail {
private String host;
private int port;
private String password;
private int database;
private int timeout;
private Map pool;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getDatabase() {
return database;
}
public void setDatabase(int database) {
this.database = database;
}
public int getTimeout() {
return timeout;
}
public void setTimeout(int timeout) {
this.timeout = timeout;
}
public Map getPool() {
return pool;
}
public void setPool(Map pool) {
this.pool = pool;
}
}
redis多数据源相关配置
spring:
multiple-redis:
primary: redis
source:
redis:
host: xxxxx
port: 6379
password: xxxxx
database: 5
redis0:
host: xxxxx
port: 6379
password: xxxxx
database: 0
redis15:
host: xxxxx
port: 6379
password: xxxxx
database: 15
pool:
#连接池最大连接数（使用负值表示没有限制）
max-active: 200
# 连接池中的最大空闲连接
max-idle: 20
#连接池中的最小空闲连接
min-idle: 5
# 当连接池耗尽时， 抛出异常之前，连接分配被阻塞的时间，也就是连接池满后最长等待时间，负值表示无限期等待
max-wait: 2000二.redis基础工厂
BaseRedisConfig
@EnableCaching
@Configuration
public class BaseRedisConfig {
@Value("${spring.multiple-redis.pool.max-active}")
private int redisPoolMaxActive;
@Value("${spring.multiple-redis.pool.max-wait}")
private int redisPoolMaxWait;
@Value("${spring.multiple-redis.pool.max-idle}")
private int redisPoolMaxIdle;
@Value("${spring.multiple-redis.pool.min-idle}")
private int redisPoolMinIdle;
/**
* 创建redis连接工厂
*/
public JedisConnectionFactory createJedisConnectionFactory(Detail detail) {
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
jedisConnectionFactory.setDatabase(detail.getDatabase());
jedisConnectionFactory.setHostName(detail.getHost());
jedisConnectionFactory.setPort(detail.getPort());
jedisConnectionFactory.setPassword(detail.getPassword());
jedisConnectionFactory.setTimeout(detail.getTimeout());
if(CollectionUtils.isEmpty(detail.getPool())){
jedisConnectionFactory.setPoolConfig(setPoolConfig(redisPoolMaxIdle, redisPoolMinIdle, redisPoolMaxActive, redisPoolMaxWait, true));
}else{
Map pool = detail.getPool();
try{
jedisConnectionFactory.setPoolConfig(setPoolConfig(pool.get("max-idle"),pool.get("min-idle"),pool.get("max-active"),pool.get("max-wait"),true));
} catch (Exception e){
throw new RuntimeException("pool detail error!");
}
}
return jedisConnectionFactory;
}
/**
* 设置连接池属性
*/
public JedisPoolConfig setPoolConfig(int maxIdle, int minIdle, int maxActive, int maxWait, boolean testOnBorrow) {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setMaxTotal(maxActive);
poolConfig.setMaxWaitMillis(maxWait);
poolConfig.setTestOnBorrow(testOnBorrow);
return poolConfig;
}
/**
* 设置RedisTemplate的序列化方式
*/
public void setSerializer(RedisTemplate redisTemplate) {
Jackson2JsonRedisSerializer jacksonJsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonJsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
redisTemplate.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
redisTemplate.setValueSerializer(jacksonJsonRedisSerializer);
// hash的value序列化方式采用jackson
redisTemplate.setHashValueSerializer(jacksonJsonRedisSerializer);
}
} redis默认数据源类
DefaultRedisConfig
@EnableCaching
@Configuration
public class DefaultRedisConfig extends BaseRedisConfig {
@Autowired
private RedisConfig redisConfig;
/**
* 配置redis连接工厂
*/
@Bean
@Primary
public RedisConnectionFactory defaultRedisConnectionFactory() {
String defaultRedis = redisConfig.getPrimary();
if(StringUtils.isEmpty(defaultRedis)){
throw new RuntimeException("redis not have Primary");
}
Detail detail = redisConfig.getSource().get(defaultRedis);
return createJedisConnectionFactory(detail);
}
@Bean(name = "redisTemplate")
public RedisTemplate redisTemplate() {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(defaultRedisConnectionFactory());
setSerializer(template);
template.afterPropertiesSet();
return template;
}
@Bean
public RedisCache redisCache(RedisTemplate redisTemplate){
return new RedisCacheImpl(redisTemplate);
}
}
redis多数据源类
MultipleRedisConfig
@Configuration
@EnableCaching
public class MultipleRedisConfig extends BaseRedisConfig {
@Autowired
private RedisConfig redisConfig;
public JedisConnectionFactory redisConnectionFactory(Detail detailConfig) {
return createJedisConnectionFactory(detailConfig);
}
@Bean
public Map multipleRedis() {
Map map = redisConfig.getSource();
Map templates = new HashMap<>(map.size());
for (String key : map.keySet()) {
Detail detail = map.get(key);
JedisConnectionFactory factory = redisConnectionFactory(detail);
RedisTemplate redisTemplate = redisTemplate(factory);
RedisCache redisCache = muRedisCache(redisTemplate);
templates.put(key,redisCache);
}
return templates;
}
public RedisTemplate redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
RedisTemplate template = new RedisTemplate();
template.setConnectionFactory(jedisConnectionFactory);
setSerializer(template);
template.afterPropertiesSet();
return template;
}
public RedisCache muRedisCache(RedisTemplate redisTemplate){
return new RedisCacheImpl(redisTemplate);
}
}
三：使用方式
//默认数据源
@Autowired
private RedisCache redisCache;
//redis0数据源
@Value("#{multipleRedis.redisCache0}")
private RedisCache redisCache0;