SpringBoot 集成 Redis 集群
搭建Redis集群可参考这篇文章：Docker 搭建redis集群-三台机机器、三主三从 首先要确保redis集群正常使用，才能往下走，不然在启动的时候初始化redis连接池，会报异常。查看redis集群状态是否正常，可以连接上redis后，使用 cluster info 查看：可以看到:cluster_state 集群状态是 ok ，如果为 fail 则表示集群状态异常。cluster_size
·
搭建Redis集群可参考这篇文章：Docker 搭建redis集群-三台机机器、三主三从 首先要确保redis集群正常使用，才能往下走，不然在启动的时候初始化redis连接池，会报异常。
查看redis集群状态是否正常，可以连接上redis后，使用 cluster info 查看：
可以看到:
cluster_state 集群状态是 ok ，如果为 fail 则表示集群状态异常。
cluster_size 集群 Master 数量
cluster_know_nodes 集群 节点 数量
这里集成了 Redisson 便于使用其中的分布式锁，特意加入了Redisson依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- redisson-springboot -->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.16.2</version>
</dependency>
<!-- redis.client.jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.3.0</version>
</dependency>
- 配置文件：
spring:
# Redis配置
redis:
timeout: 6000 # 连接超时时长（毫秒）
password: abc123456
cluster:
max-redirects: 3
nodes:
- 192.168.104.79:6379
- 192.168.104.79:6380
- 192.168.104.80:6379
- 192.168.104.80:6380
- 192.168.104.81:6379
- 192.168.104.81:6380
lettuce:
pool:
max-active: 1024 # 连接池最大连接数（默认为8，-1表示无限制 如果pool已经分配了超过max_active个jedis实例，则此时pool为耗尽）
max-wait: 10000 #最大等待连接时间，单位毫秒 默认为-1，表示永不超时，超时会抛出JedisConnectionException
max-idle: 10
min-idle: 5
shutdown-timeout: 100
- redis 配置类：RedisConfigProperties.java
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Redis配置映射类
*
* @author linmengmeng
* @date 2021-03-11
**/
@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfigProperties {
private Integer timeout;
private Integer database;
private Integer port;
private String host;
private String password;
private cluster cluster;
public static class cluster {
private List<String> nodes;
public List<String> getNodes() {
return nodes;
}
public void setNodes(List<String> nodes) {
this.nodes = nodes;
}
}
public Integer getTimeout() {
return timeout;
}
public void setTimeout(Integer timeout) {
this.timeout = timeout;
}
public Integer getDatabase() {
return database;
}
public void setDatabase(Integer database) {
this.database = database;
}
public Integer getPort() {
return port;
}
public void setPort(Integer port) {
this.port = port;
}
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public RedisConfigProperties.cluster getCluster() {
return cluster;
}
public void setCluster(RedisConfigProperties.cluster cluster) {
this.cluster = cluster;
}
}
RedissonConfig.java
import gc.cnnvd.config.properties.RedisConfigProperties;
import org.redisson.Redisson;
import org.redisson.config.ClusterServersConfig;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
/**
* @author linmengmeng
* @author 2021-08-30
*/
@Configuration
public class RedissonConfig {
@Autowired
private RedisConfigProperties redisConfigProperties;
/**
* redis://host:port
*/
private static final String REDIS_ADDRESS = "redis://%s:%s";
/**
* 集群模式-添加redisson的bean
* @return
*/
@Bean
public Redisson redisson() {
//redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
List<String> clusterNodes = new ArrayList<>();
for (int i = 0; i < redisConfigProperties.getCluster().getNodes().size(); i++) {
clusterNodes.add("redis://" + redisConfigProperties.getCluster().getNodes().get(i));
}
Config config = new Config();
ClusterServersConfig clusterServersConfig = config.useClusterServers()
.addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
clusterServersConfig.setPassword(redisConfigProperties.getPassword());//设置密码，如果没有密码，则注释这一行，否则启动会报错
return (Redisson) Redisson.create(config);
}
// /**
// * Redisson单机模式
// * @return
// */
// @Bean
// public Redisson RedissonConfig(){
// Config config = new Config();
config.useSingleServer().setAddress("redis://localhost:6379").setDatabase(redisConfigProperties.getDatabase());
// config.useSingleServer().setAddress(String.format(REDIS_ADDRESS, redisConfigProperties.getHost(), redisConfigProperties.getPort()))
// .setDatabase(redisConfigProperties.getDatabase())
// .setPassword(redisConfigProperties.getPassword());
// return (Redisson) Redisson.create(config);
// }
}
RedisTemplateConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* <p>
* Redis Template 配置
* </p>
*
* @author geekidea
* @date 2018-11-08
*/
@Configuration
public class RedisTemplateConfig {
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
// 自定义的string序列化器和fastjson序列化器
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// jackson 序列化器
GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
// kv 序列化
redisTemplate.setKeySerializer(stringRedisSerializer);
redisTemplate.setValueSerializer(jsonRedisSerializer);
// hash 序列化
redisTemplate.setHashKeySerializer(stringRedisSerializer);
redisTemplate.setHashValueSerializer(jsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
RestTemplateConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
/**
* @author geekidea
* @date 2018-11-08
*/
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory){
return new RestTemplate(factory);
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
//单位为ms
factory.setReadTimeout(5000);
//单位为ms
factory.setConnectTimeout(5000);
return factory;
}
}
在使用的地方直接注入即可:
@Lazy
@Autowired
private RedisTemplate redisTemplate;
或者使用封装的工具类：RedisUtil.java
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public final class RedisUtil {
@Resource
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
*/
public boolean expire(String key, long time, TimeUnit timeUnit) {
try {
if (time > 0) {
redisTemplate.expire(key, time, timeUnit);
}
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 del(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);
}
/**
* 普通缓存获取 String 类型的值
*
* @param key 键
* @return 值
*/
public String getString(String key) {
Object getResult = get(key);
if (getResult == null){
return "";
}
if (getResult instanceof String){
return (String) getResult;
}
return "";
}
/**
* 普通缓存放入
*
* @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 value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @param timeUnit 时间单位 TimeUnit
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, timeUnit);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @param timeUnit 时间单位 TimeUnit
* @return true成功 false 失败
*/
public boolean setIfAbsent(String key, Object value, long time, TimeUnit timeUnit) {
try {
if (time > 0) {
redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
*/
public long decr(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
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
*/
public boolean hmset(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 hmset(String key, Map<String, Object> map, long time, TimeUnit timeUnit) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time, timeUnit);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(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 hset(String key, String item, Object value, long time, TimeUnit timeUnit) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time, timeUnit);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
*/
public Set<Object> sGet(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 sHasKey(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 sSet(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 sSetAndTime(String key, long time, TimeUnit timeUnit, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time, timeUnit);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
*/
public long sGetSetSize(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 {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
*/
public long lGetListSize(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倒数第二个元素，依次类推
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
*/
public boolean lSet(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 时间(秒)
*/
public boolean lSet(String key, Object value, long time,TimeUnit timeUnit) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time,timeUnit);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(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
*/
public boolean lSet(String key, List<Object> value, long time,TimeUnit timeUnit) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time,timeUnit);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(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 lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================HyperLogLog=================================
public long pfadd(String key, String value) {
return redisTemplate.opsForHyperLogLog().add(key, value);
}
public long pfcount(String key) {
return redisTemplate.opsForHyperLogLog().size(key);
}
public void pfremove(String key) {
redisTemplate.opsForHyperLogLog().delete(key);
}
public void pfmerge(String key1, String key2) {
redisTemplate.opsForHyperLogLog().union(key1, key2);
}
}
以下为集群模式，SpringBoot 启动日志中redis相关日志，可以看到打印出集群信息：
2021-11-17 17:43:03.255 INFO [ main] [] org.redisson.Version [41] : Redisson 3.16.2
2021-11-17 17:43:04.755 INFO [ main] [] o.r.cluster.ClusterConnectionManager [115] : Redis cluster nodes configuration got from 192.168.104.79/192.168.104.79:6379:
ab94d6ed24c65a51280440d4bee3e126e505f960 192.168.104.81:6379@16379 slave 176081ad778f5518fa7e22c3d109ddb90ab1788f 0 1637142182203 7 connected
acfbc5be5f52b00729373a73db2822b096cfd871 192.168.104.81:6380@16380 slave 508a468c6e53ca352a3a84fffc85f5c5be6edca7 0 1637142181202 3 connected
a1f27e604c3051e16fc91b7065daa15315dab26e 192.168.104.80:6380@16380 slave aa8701f1c94a62eaa59e994508f7d224b20b9c50 0 1637142184205 1 connected
176081ad778f5518fa7e22c3d109ddb90ab1788f 192.168.104.79:6380@16380 master - 0 1637142182000 7 connected 10923-16383
aa8701f1c94a62eaa59e994508f7d224b20b9c50 192.168.104.79:6379@16379 myself,master - 0 1637142183000 1 connected 0-5460
508a468c6e53ca352a3a84fffc85f5c5be6edca7 192.168.104.80:6379@16379 master - 0 1637142183204 3 connected 5461-10922
2021-11-17 17:43:04.973 INFO [sson-netty-2-15] [] o.r.c.pool.MasterPubSubConnectionPool [166] : 1 connections initialized for 192.168.104.79/192.168.104.79:6379
2021-11-17 17:43:05.047 INFO [sson-netty-2-25] [] o.r.c.pool.MasterPubSubConnectionPool [166] : 1 connections initialized for 192.168.104.80/192.168.104.80:6379
2021-11-17 17:43:05.060 INFO [sson-netty-2-22] [] o.r.c.pool.MasterPubSubConnectionPool [166] : 1 connections initialized for 192.168.104.79/192.168.104.79:6380
2021-11-17 17:43:05.108 INFO [sson-netty-2-31] [] o.r.c.pool.MasterConnectionPool [166] : 24 connections initialized for 192.168.104.79/192.168.104.79:6379
2021-11-17 17:43:05.187 INFO [sson-netty-2-10] [] o.r.c.pool.MasterConnectionPool [166] : 24 connections initialized for 192.168.104.80/192.168.104.80:6379
2021-11-17 17:43:05.220 INFO [sson-netty-2-23] [] o.r.c.pool.MasterConnectionPool [166] : 24 connections initialized for 192.168.104.79/192.168.104.79:6380
2021-11-17 17:43:05.432 INFO [sson-netty-2-31] [] o.r.c.pool.PubSubConnectionPool [166] : 1 connections initialized for 192.168.104.80/192.168.104.80:6380
2021-11-17 17:43:05.447 INFO [sson-netty-2-32] [] o.r.c.pool.PubSubConnectionPool [166] : 1 connections initialized for 192.168.104.81/192.168.104.81:6380
2021-11-17 17:43:05.502 INFO [sson-netty-2-29] [] o.r.c.pool.PubSubConnectionPool [166] : 1 connections initialized for 192.168.104.81/192.168.104.81:6379
2021-11-17 17:43:05.503 INFO [sson-netty-2-17] [] o.r.cluster.ClusterConnectionManager [333] : slaves: [redis://192.168.104.80:6380] added for slot ranges: [[0-5460]]
2021-11-17 17:43:05.504 INFO [sson-netty-2-17] [] o.r.cluster.ClusterConnectionManager [340] : master: redis://192.168.104.79:6379 added for slot ranges: [[0-5460]]
2021-11-17 17:43:05.504 INFO [sson-netty-2-17] [] o.r.connection.pool.SlaveConnectionPool [166] : 24 connections initialized for 192.168.104.80/192.168.104.80:6380
2021-11-17 17:43:05.535 INFO [sson-netty-2-22] [] o.r.cluster.ClusterConnectionManager [333] : slaves: [redis://192.168.104.81:6380] added for slot ranges: [[5461-10922]]
2021-11-17 17:43:05.535 INFO [sson-netty-2-22] [] o.r.cluster.ClusterConnectionManager [340] : master: redis://192.168.104.80:6379 added for slot ranges: [[5461-10922]]
2021-11-17 17:43:05.535 INFO [sson-netty-2-22] [] o.r.connection.pool.SlaveConnectionPool [166] : 24 connections initialized for 192.168.104.81/192.168.104.81:6380
2021-11-17 17:43:05.557 INFO [sson-netty-2-26] [] o.r.cluster.ClusterConnectionManager [333] : slaves: [redis://192.168.104.81:6379] added for slot ranges: [[10923-16383]]
2021-11-17 17:43:05.558 INFO [sson-netty-2-26] [] o.r.cluster.ClusterConnectionManager [340] : master: redis://192.168.104.79:6380 added for slot ranges: [[10923-16383]]
2021-11-17 17:43:05.558 INFO [sson-netty-2-26] [] o.r.connection.pool.SlaveConnectionPool [166] : 24 connections initialized for 192.168.104.81/192.168.104.81:6379
2021-11-17 17:43:05.682 INFO [ main] [] trationDelegate$BeanPostProcessorChecker [330] : Bean 'redisson' of type [org.redisson.Redisson] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2021-11-17 17:43:05.696 INFO [ main] [] trationDelegate$BeanPostProcessorChecker [330] : Bean 'redissonConnectionFactory' of type [org.redisson.spring.data.connection.RedissonConnectionFactory] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2021-11-17 17:43:05.785 INFO [ main] [] trationDelegate$BeanPostProcessorChecker [330] : Bean 'redisTemplate' of type [org.springframework.data.redis.core.RedisTemplate] is not eligible for getting processed by all BeanPostProcessors (for example: not eligible for auto-proxying)
2021-11-17 17:43:05.791 INFO [
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
2
0- 0
已为社区贡献9条内容
所有评论(0)