多数据源最终表现其实就是 redis connection factory 不同

springboot 默认的redis配置维护了一套 connection factory

自己维护一套 connection factory 即可实现

application.yml

spring:

redis:

# 默认配置

database: 0

host: 10.180.29.19

port: 6379

password: admin

timeout: 2000

lettuce:

pool:

max-active: 20

max-wait: -1

max-idle: 10

min-idle: 0

# 自定义配置

local:

host: 127.0.0.1

port: 6379

password: admin

RedisConfig.java

package site.yuyanjia.template.common.config;

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.factory.annotation.Value;

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisPassword;

import org.springframework.data.redis.connection.RedisStandaloneConfiguration;

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.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import org.springframework.util.ObjectUtils;

import java.time.Duration;

/**

* RedisConfig

*

* @author seer

* @date 2018/5/30 09:32

*/

@Configuration

@EnableCaching

public class RedisConfig extends CachingConfigurerSupport {

/**

* 本地数据源 redis template

*

* @param database

* @param timeout

* @param maxActive

* @param maxWait

* @param maxIdle

* @param minIdle

* @param hostName

* @param port

* @param password

* @return

*/

@Bean

public RedisTemplate redisTemplateLocal(

@Value("${spring.redis.database}") int database,

@Value("${spring.redis.timeout}") long timeout,

@Value("${spring.redis.lettuce.pool.max-active}") int maxActive,

@Value("${spring.redis.lettuce.pool.max-wait}") int maxWait,

@Value("${spring.redis.lettuce.pool.max-idle}") int maxIdle,

@Value("${spring.redis.lettuce.pool.min-idle}") int minIdle,

@Value("${spring.redis.local.host}") String hostName,

@Value("${spring.redis.local.port}") int port,

@Value("${spring.redis.local.password}") String password) {

/* ========= 基本配置 ========= */

RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();

configuration.setHostName(hostName);

configuration.setPort(port);

configuration.setDatabase(database);

if (!ObjectUtils.isEmpty(password)) {

RedisPassword redisPassword = RedisPassword.of(password);

configuration.setPassword(redisPassword);

}

/* ========= 连接池通用配置 ========= */

GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();

genericObjectPoolConfig.setMaxTotal(maxActive);

genericObjectPoolConfig.setMinIdle(minIdle);

genericObjectPoolConfig.setMaxIdle(maxIdle);

genericObjectPoolConfig.setMaxWaitMillis(maxWait);

/* ========= jedis pool ========= */

/*

JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration

.builder();

builder.connectTimeout(Duration.ofSeconds(timeout));

builder.usePooling();

builder.poolConfig(genericObjectPoolConfig);

JedisConnectionFactory connectionFactory = new JedisConnectionFactory(configuration, builder.build());

// 连接池初始化

connectionFactory.afterPropertiesSet();

*/

/* ========= lettuce pool ========= */

LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();

builder.poolConfig(genericObjectPoolConfig);

builder.commandTimeout(Duration.ofSeconds(timeout));

LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, builder.build());

connectionFactory.afterPropertiesSet();

/* ========= 创建 template ========= */

return createRedisTemplate(connectionFactory);

}

/**

* 默认配置(10.180.29.19) redis template

*

* @param redisConnectionFactory

* @return

*/

@Bean

public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

return createRedisTemplate(redisConnectionFactory);

}

/**

* json 实现 redisTemplate

*

* 该方法不能加 @Bean 否则不管如何调用，connectionFactory都会是默认配置

*

* @param redisConnectionFactory

* @return

*/

public RedisTemplate createRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

RedisTemplate redisTemplate = new RedisTemplate<>();

redisTemplate.setConnectionFactory(redisConnectionFactory);

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

redisTemplate.setKeySerializer(new StringRedisSerializer());

redisTemplate.afterPropertiesSet();

return redisTemplate;

}

}

使用

/**

* 本地redis

*/

@Autowired

private RedisTemplate redisTemplateLocal;

/**

* 默认redis

*/

@Autowired

private RedisTemplate redisTemplate;

不甚明白的可以了解下 Autowired 的装配机制