springboot redis自定义连接工厂
springboot自定义redis连接工厂，创建多个redis连接工厂
·
EtcdUtil
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class EtcdUtil {
@Autowired
private BackendAgent backendAgent;
public EtcdUtil() {
}
public List<Node> getNodeItemList(String path) {
List<Node> list = this.backendAgent.list(path, true);
return list;
}
}
EtcdBean定义
import java.util.HashMap;
import java.util.Map;
public class EtcdRedisBean {
private Map redismap = new HashMap();
public EtcdRedisBean() {
}
public Map<String, String> getRedismap() {
return this.redismap;
}
public void setRedismap(Map redismap) {
this.redismap = redismap;
}
}
创建EtcdBean，从etcd指定路径下加载redis连接属性配置
mport org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.List;
@Configuration
public class EtcdDataConfiguration {
@Autowired
private EtcdUtil etcdUtil;
@Value("${redis.etcd.path:/sysconfig/redis/test}")
private String redispath;
public EtcdDataConfiguration() {
}
@Bean("etcdRedisBean")
public EtcdRedisBean getEtcdRdisBean() {
EtcdRedisBean bean = new EtcdRedisBean();
List<Node> nodeItemList = this.etcdUtil.getNodeItemList(this.redispath);
nodeItemList.stream().forEach((node) -> {
bean.getRedismap().put(node.getName(), node.getValue());
});
return bean;
}
}
自定义redis连接工厂
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.data.redis.LettuceClientConfigurationBuilderCustomizer;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.util.ClassUtils;
import io.lettuce.core.RedisClient;
import io.lettuce.core.resource.ClientResources;
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({RedisClient.class})
@ConditionalOnProperty(name = {"spring.redis.client-type"}, havingValue = "lettuce", matchIfMissing = true)
@AutoConfigureAfter({EtcdDataConfiguration.class})
public class LettuceConnectionExtConfiguration
{
@Autowired
EtcdRedisBean etcdRedisBean;
public LettuceConnectionExtConfiguration()
{
}
@Primary
/*由于我们每个组都会连接自己的redis服务器，创建多个redis连接工厂，所以需要指定一个连接工厂为Primary，否则启动的时候会报错，RedisReactiveAutoConfiguration required a single bean, but 2 were found */
@Bean({"testRedisConnectionFactory"})
public LettuceConnectionFactory redisLettuceConnectionFactory(
ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers, ClientResources clientResources,
RedisProperties redisProperties, ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider,
ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider)
{
Map<String, String> redismap = this.etcdRedisBean.getRedismap();
if (!redismap.isEmpty())
{
if (!StringTools.isEmpty((String)redismap.get("timeout")))
{
redisProperties.setTimeout(Duration.ofMillis(Long.parseLong((String)redismap.get("timeout"))));
}
if (!StringTools.isEmpty((String)redismap.get("nodes")))
{
String nodes = (String)redismap.get("nodes");
String[] nodearray = nodes.split(",");
if (nodearray.length == 1)
{
String[] node = nodearray[0].split(":");
redisProperties.setHost(node[0]);
redisProperties.setPort(Integer.parseInt(node[1]));
redisProperties.setCluster((RedisProperties.Cluster)null);
}
else if (nodearray.length > 1)
{
redisProperties.setHost((String)null);
redisProperties.setPort(0);
RedisProperties.Cluster cluster = redisProperties.getCluster();
if (cluster == null)
{
cluster = new RedisProperties.Cluster();
}
List<String> nodeList = Arrays.asList(nodearray);
cluster.setNodes(nodeList);
redisProperties.setCluster(cluster);
}
}
if (!StringTools.isEmpty((String)redismap.get("password")))
{
redisProperties.setPassword((String)redismap.get("password"));
}
if (!StringTools.isEmpty((String)redismap.get("max-redirects")))
{
RedisProperties.Cluster cluster = redisProperties.getCluster();
if (cluster == null)
{
cluster = new RedisProperties.Cluster();
}
cluster.setMaxRedirects(Integer.parseInt((String)redismap.get("max-redirects")));
}
}
ClassLoader classLoader = ClassUtils.getDefaultClassLoader();
try
{
Class<?> instanceClass =
ClassUtils.forName("org.springframework.boot.autoconfigure.data.redis.LettuceConnectionConfiguration",
classLoader);
Constructor<?> constructor =
instanceClass.getDeclaredConstructor(RedisProperties.class, ObjectProvider.class, ObjectProvider.class);
constructor.setAccessible(true);
Object lettuceConfiguration =
constructor.newInstance(redisProperties, sentinelConfigurationProvider, clusterConfigurationProvider);
Method redisConnectionFactory =
instanceClass.getDeclaredMethod("redisConnectionFactory", ObjectProvider.class, ClientResources.class);
redisConnectionFactory.setAccessible(true);
return (LettuceConnectionFactory)redisConnectionFactory
.invoke(lettuceConfiguration, builderCustomizers, clientResources);
}
catch (Exception var12)
{
throw new IllegalArgumentException(var12.getMessage());
}
}
}
创建redisTemplate bean
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* redis 序列化 使用redisTemplate自动调用
*/
@Configuration
public class RedisConfigMktg {
public RedisConfigMktg()
{
}
@Bean({"testRedisTemplate"})
public RedisTemplate<String, Object> redisTemplate(@Autowired @Qualifier("testRedisConnectionFactory") LettuceConnectionFactory lettuceConnectionFactory) {
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(lettuceConnectionFactory);
template.setEnableDefaultSerializer(false);
template.setKeySerializer(new StringRedisSerializer());
template.setHashKeySerializer(new StringRedisSerializer());
template.setValueSerializer(template.getKeySerializer());
template.afterPropertiesSet();
return template;
}
}
RedisUtil中使用redisTemplate的实例
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
@Component
public class RedisUtil
{
static Logger logger = LoggerFactory.getLogger(RedisUtil.class);
@Resource(
name = "testRedisTemplate"
)
private RedisTemplate<String, Object> redisTemplate;
// public RedisUtil(RedisTemplate<String, Object> template)
// {
// this.redisTemplate=template;
// }
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if ( time > 0){
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void delete(String... key) {
if ( key != null && key.length >0 ){
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete((Collection<String>)CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if ( time > 0){
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else{
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return long
*/
public long increment(String key, long delta) {
if ( delta < 0){
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return long
*/
public long decrement(String key, long delta) {
if ( delta < 0){
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hashGet(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
* @param key 键
* @return 对应的多个键值
*/
public Map<Object,Object> hashGetAll(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hashSetAll(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hashSetAll(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if ( time > 0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hashSet(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hashGet(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if ( time > 0){
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hashDelete(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hasHashKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return double
*/
public double hashIncrement(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return double
*/
public double hashDecrement(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return Set<Object>
*/
public Set<Object> setMembers(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean setIsMember(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long setAdd(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long setAdd(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if ( time > 0)
expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return long
*/
public long setSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
return redisTemplate.opsForSet().remove(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return List<Object>
*/
public List<Object> listGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return long
*/
public long listGetSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return Object
*/
public Object listGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return true 成功 false 不成功
*/
public boolean listSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return true 成功 false 不成功
*/
public boolean listSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if ( time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return true 成功 false 不成功
*/
public boolean listSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return true 成功 false 不成功
*/
public boolean listSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if ( time > 0)
expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return true 成功 false 不成功
*/
public boolean listUpdateByIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long listRemove(String key, long count, Object value) {
try {
return redisTemplate.opsForList().remove(key, count, value);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
过程中遇到的问题
我们和另一组都自定义了自己的redis连接工厂，然后在同一个项目中启动，就会创建两个LettuceConnectionFactory类型的bean，然后启动失败报错
Parameter 0 of method reactiveRedisTemplate in org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration required a single bean, but 2 were found…
Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed
看看RedisReactiveAutoConfiguration 这个类的源码
这个类里面会创建两个bean,都需要注入ReactiveRedisConnectionFactory这个类型的bean
而LettuceConnectionFactory是ReactiveRedisConnectionFactory的具体实现类
如果我们自己没有自定义连接工厂，那spring会根据我们RedisConfig里的属性自动创建一个连接工厂bean，然后注入到redisTemplate中，如果我们只自定义了一个，那会使用我们自定义的连接工厂。
如果我们自定义了多个，这时候RedisReactiveAutoConfiguration 里这两个bean在初始化的时候就不知道使用哪个了，看这个提示解决方法有两种：
1，使用@Primary标记一个连接工厂作为主选
2，在使用时加上@Qualifier指定需要的是哪个bean
但是我们无法去改springboot的源码，所以只能选择使用第一种方式了，在多个LettuceConnectionFactory 类型的bean中指定一个作为主选。
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
1
0- 0
已为社区贡献3条内容
所有评论(0)