【前言】在开发需求中，很多情况一个数据源是不能够满足业务需求的，常常需要我们去配置多个数据源去综合使用完成业务需要的功能
其实多数据源本质就是多个redisTemplate
【代码】
1、依赖(这里以gradle项目为例)
dependencies {
compile('org.springframework.boot:spring-boot-starter-data-redis')
compile('redis.clients:jedis:2.9.0')
}
这里需要注意的是jedis的版本要在2.7以上，低版本会出现类缺省问题
2、application配置
# ------------redis多数据源配置-----------------
#共有配置
spring.redis.pool.max-active=50
spring.redis.pool.max-wait=10000
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=200
#开发缓存redis
spring.redis.dev.host=10.168.99.149
spring.redis.dev.port=6379
spring.redis.dev.password=
spring.redis.dev.database=0
spring.redis.dev.testOnBorrow=false
#测试环境redis
#spring.redis.test.host=10.168.99.149
#spring.redis.test.port=6379
#spring.redis.test.password=
#spring.redis.test.database=0
#spring.redis.test.testOnBorrow=false
#线上环境redis
#spring.redis.prod.host=10.168.99.149
#spring.redis.prod.port=6379
#spring.redis.prod.password=
#spring.redis.prod.database=0
#spring.redis.prod.testOnBorrow=false
3、注入数据源
/**
* @Author: LvFang
* @Date: Created in 2018/7/25.
* @Description:redis多数据源配置
*/
@Configuration
public class RedisReivceConfig {
private static Logger logger = LoggerFactory.getLogger(ReceiverService.class);
//---------------------------------------多数据源配置-----------------------------------------------------
/**
* redisDevTemplate 数据源
*/
@Bean(name = "redisDevTemplate")
public StringRedisTemplate redisTemplate(@Value("${spring.redis.dev.host}") String hostName,
@Value("${spring.redis.dev.port}") int port,
// @Value("${spring.redis.dev.password}") String password,
@Value("${spring.redis.dev.testOnBorrow}") boolean testOnBorrow,
@Value("${spring.redis.dev.database}") int index,
@Value("${spring.redis.pool.max-idle}") int maxIdle,
@Value("${spring.redis.pool.max-active}") int maxTotal,
@Value("${spring.redis.pool.max-wait}") long maxWaitMillis) {
StringRedisTemplate temple = new StringRedisTemplate();
temple.setConnectionFactory(
connectionFactory(hostName, port, maxIdle, maxTotal, index, maxWaitMillis, testOnBorrow));
return temple;
}
/**
* redisTestTemplate 数据源
*/
@Bean(name = "redisTestTemplate")
public StringRedisTemplate redisTemplate(@Value("${spring.redis.test.host}") String hostName,
@Value("${spring.redis.test.port}") int port,
// @Value("${spring.redis.test.password}") String password,
@Value("${spring.redis.test.testOnBorrow}") boolean testOnBorrow,
@Value("${spring.redis.test.database}") int index,
@Value("${spring.redis.pool.max-idle}") int maxIdle,
@Value("${spring.redis.pool.max-active}") int maxTotal,
@Value("${spring.redis.pool.max-wait}") long maxWaitMillis) {
StringRedisTemplate temple = new StringRedisTemplate();
temple.setConnectionFactory(
connectionFactory(hostName, port, maxIdle, maxTotal, index, maxWaitMillis, testOnBorrow));
return temple;
}
/**
* 有密码
*/
public RedisConnectionFactory connectionFactory(String hostName, int port, String password, int maxIdle,
int maxTotal, int index, long maxWaitMillis, boolean testOnBorrow) {
JedisConnectionFactory jedis = new JedisConnectionFactory();
jedis.setHostName(hostName);
jedis.setPort(port);
//如果密码不为空才去设置密码（如果没有密码，不设置或者设置空字符串即可）
if (StringUtils.isNotEmpty(password)) {
jedis.setPassword(password);
}
if (index != 0) {
jedis.setDatabase(index);
}
jedis.setPoolConfig(poolCofig(maxIdle, maxTotal, maxWaitMillis, testOnBorrow));
// 初始化连接pool
jedis.afterPropertiesSet();
RedisConnectionFactory factory = jedis;
return factory;
}
/**
* 无密码
*/
public RedisConnectionFactory connectionFactory(String hostName, int port, int maxIdle,
int maxTotal, int index, long maxWaitMillis, boolean testOnBorrow) {
JedisConnectionFactory jedis = new JedisConnectionFactory();
jedis.setHostName(hostName);
jedis.setPort(port);
if (index != 0) {
jedis.setDatabase(index);
}
jedis.setPoolConfig(poolCofig(maxIdle, maxTotal, maxWaitMillis, testOnBorrow));
// 初始化连接pool
jedis.afterPropertiesSet();
RedisConnectionFactory factory = jedis;
return factory;
}
public JedisPoolConfig poolCofig(int maxIdle, int maxTotal, long maxWaitMillis, boolean testOnBorrow) {
JedisPoolConfig poolCofig = new JedisPoolConfig();
poolCofig.setMaxIdle(maxIdle);
poolCofig.setMaxTotal(maxTotal);
poolCofig.setMaxWaitMillis(maxWaitMillis);
poolCofig.setTestOnBorrow(testOnBorrow);
return poolCofig;
}
}
4、redisService服务类
@Service
public class RedisService {
private Logger logger = LoggerFactory.getLogger(getClass());
@Resource(name = "redisDevTemplate")
private StringRedisTemplate redisTemplate;
@Value("${global.env}")
private String env;
public int keys(String regEx) {
regEx = env.concat("-").concat(regEx);
try {
return redisTemplate.keys(regEx).size();
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return -1;
}
public Object getValue(String key) {
key = env.concat("-").concat(key);
try {
BoundValueOperations valueOperations = redisTemplate.boundValueOps(key);
Object retValue = valueOperations.get();
logger.info("get from redis {}:{}", key, retValue);
return retValue;
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
return null;
}
public void setValue(String key, Object value) {
key = env.concat("-").concat(key);
try {
BoundValueOperations valueOperations = redisTemplate.boundValueOps(key);
valueOperations.set(String.valueOf(value), 1, TimeUnit.DAYS);
logger.info("set to redis {}:{}", key, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
public void setValue(String key, Object value, int timeOut) {
key = env.concat("-").concat(key);
try {
BoundValueOperations valueOperations = redisTemplate.boundValueOps(key);
valueOperations.set(String.valueOf(value), timeOut, TimeUnit.SECONDS);
logger.info("set to redis {}:{}", key, value);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
/**
* 自增1
* @param key
*/
public long increment(String key) {
//给Redis中key加前缀：dev-ApiAccessCntqibumaiche2018-07-17
key = env.concat("-").concat(key);
// return redisTemplate.opsForValue().increment(env.concat("-").concat(key), 1);
logger.info("increment redis {}", key);
//对应Redis的value的值加1
return redisTemplate.opsForValue().increment(key, 1);
}
/**
* 初始化0
* @param key
*/
public void init(String key) {
redisTemplate.opsForValue().set(env.concat("-").concat(key), String.valueOf(0));
}
public void delteKey(String key) {
try {
redisTemplate.delete(key);
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
/**
* 入队
* @param key
* @param value
* @return
*/
public Long inQueue(String key, String value) {
return redisTemplate.opsForList().rightPush(key, value);
}
/**
* 出队
* @param key
* @return
*/
public String outQueue(String key) {
return redisTemplate.opsForList().leftPop(key);
}
/**
* 栈/队列长
* @param key
* @return
*/
public Long length(String key) {
return redisTemplate.opsForList().size(key);
}
/**
* hash添加
* @param key
* @param field
* @param value
*/
public void hset(String key, String field, String value){
try {
HashOperations<String, String, String> vo = redisTemplate.opsForHash();
vo.put(key,field,value);
}catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
/**
* hash获取
* @param key
* @param field
* @return
*/
public String hget(String key, String field){
String value = null;
try {
HashOperations<String, String, String> vo = redisTemplate.opsForHash();
if(vo.hasKey(key,field)){
value = vo.get(key,field);
}
}catch (Exception e) {
logger.error(e.getMessage(), e);
}
return value;
}
/**
* hash获取所有
* @param key
* @return
*/
public Map<String,String> hgetall(String key){
HashOperations<String, String, String> vo = redisTemplate.opsForHash();
Map<String,String> map = new HashMap<>();
for(String haskey:vo.keys(key)){
String value = vo.get(key,haskey);
map.put(haskey,value);
}
return map;
}
}
以上可以注入多个redis数据源进行操作
