wangrunpu
/
stm32-iot-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix 修复 redisson 集群模式 路径未匹配协议头问题

Browse Source
master
疯狂的狮子li 4 years ago
parent d600cdd8a0
commit 3546ac2854
1 changed files with 154 additions and 147 deletions
Show Stats Download Patch File Download Diff File

301
ruoyi-framework/src/main/java/com/ruoyi/framework/config/RedisConfig.java
Unescape View File

@ -23,6 +23,7 @@ import java.io.IOException;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors;
/** /**
* redis配置 * redis配置
@ -34,158 +35,164 @@ import java.util.Map;
@EnableCaching @EnableCaching
public class RedisConfig extends CachingConfigurerSupport { public class RedisConfig extends CachingConfigurerSupport {
private static final String REDIS_PROTOCOL_PREFIX = "redis://"; private static final String REDIS_PROTOCOL_PREFIX = "redis://";
private static final String REDISS_PROTOCOL_PREFIX = "rediss://"; private static final String REDISS_PROTOCOL_PREFIX = "rediss://";
@Autowired @Autowired
private RedisProperties redisProperties; private RedisProperties redisProperties;
@Autowired @Autowired
private RedissonProperties redissonProperties; private RedissonProperties redissonProperties;
@Bean(destroyMethod = "shutdown") @Bean(destroyMethod = "shutdown")
@ConditionalOnMissingBean(RedissonClient.class) @ConditionalOnMissingBean(RedissonClient.class)
public RedissonClient redisson() throws IOException { public RedissonClient redisson() throws IOException {
String prefix = REDIS_PROTOCOL_PREFIX; String prefix = REDIS_PROTOCOL_PREFIX;
if (redisProperties.isSsl()) { if (redisProperties.isSsl()) {
prefix = REDISS_PROTOCOL_PREFIX; prefix = REDISS_PROTOCOL_PREFIX;
} }
Config config = new Config(); Config config = new Config();
config.setThreads(redissonProperties.getThreads()) config.setThreads(redissonProperties.getThreads())
.setNettyThreads(redissonProperties.getNettyThreads()) .setNettyThreads(redissonProperties.getNettyThreads())
.setCodec(JsonJacksonCodec.INSTANCE) .setCodec(JsonJacksonCodec.INSTANCE)
.setTransportMode(redissonProperties.getTransportMode()); .setTransportMode(redissonProperties.getTransportMode());
RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig(); RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
if (ObjectUtil.isNotNull(singleServerConfig)) { if (ObjectUtil.isNotNull(singleServerConfig)) {
// 使用单机模式 // 使用单机模式
config.useSingleServer() config.useSingleServer()
.setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort()) .setAddress(prefix + redisProperties.getHost() + ":" + redisProperties.getPort())
.setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue()) .setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue())
.setDatabase(redisProperties.getDatabase()) .setDatabase(redisProperties.getDatabase())
.setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null) .setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null)
.setTimeout(singleServerConfig.getTimeout()) .setTimeout(singleServerConfig.getTimeout())
.setRetryAttempts(singleServerConfig.getRetryAttempts()) .setRetryAttempts(singleServerConfig.getRetryAttempts())
.setRetryInterval(singleServerConfig.getRetryInterval()) .setRetryInterval(singleServerConfig.getRetryInterval())
.setSubscriptionsPerConnection(singleServerConfig.getSubscriptionsPerConnection()) .setSubscriptionsPerConnection(singleServerConfig.getSubscriptionsPerConnection())
.setClientName(singleServerConfig.getClientName()) .setClientName(singleServerConfig.getClientName())
.setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout()) .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
.setSubscriptionConnectionMinimumIdleSize(singleServerConfig.getSubscriptionConnectionMinimumIdleSize()) .setSubscriptionConnectionMinimumIdleSize(singleServerConfig.getSubscriptionConnectionMinimumIdleSize())
.setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize()) .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
.setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize()) .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
.setConnectionPoolSize(singleServerConfig.getConnectionPoolSize()) .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize())
.setDnsMonitoringInterval(singleServerConfig.getDnsMonitoringInterval()); .setDnsMonitoringInterval(singleServerConfig.getDnsMonitoringInterval());
} }
// 集群配置方式 参考下方注释 // 集群配置方式 参考下方注释
RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig(); RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
if (ObjectUtil.isNotNull(clusterServersConfig)) { if (ObjectUtil.isNotNull(clusterServersConfig)) {
// 使用集群模式 // 使用集群模式
config.useClusterServers() String finalPrefix = prefix;
.setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue()) List<String> nodes = redisProperties.getCluster().getNodes()
.setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null) .stream()
.setTimeout(clusterServersConfig.getTimeout()) .map(node -> finalPrefix + node)
.setRetryAttempts(clusterServersConfig.getRetryAttempts()) .collect(Collectors.toList());
.setRetryInterval(clusterServersConfig.getRetryInterval())
.setSubscriptionsPerConnection(clusterServersConfig.getSubscriptionsPerConnection())
.setClientName(clusterServersConfig.getClientName())
.setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
.setPingConnectionInterval(clusterServersConfig.getPingConnectionInterval())
.setSubscriptionConnectionMinimumIdleSize(clusterServersConfig.getSubscriptionConnectionMinimumIdleSize())
.setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
.setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
.setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
.setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
.setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
.setDnsMonitoringInterval(clusterServersConfig.getDnsMonitoringInterval())
.setFailedSlaveReconnectionInterval(clusterServersConfig.getFailedSlaveReconnectionInterval())
.setScanInterval(clusterServersConfig.getScanInterval())
.setReadMode(clusterServersConfig.getReadMode())
.setSubscriptionMode(clusterServersConfig.getSubscriptionMode())
.setNodeAddresses(redisProperties.getCluster().getNodes());
}
RedissonClient redissonClient = Redisson.create(config);
log.info("初始化 redis 配置");
return redissonClient;
}
/** config.useClusterServers()
* 整合spring-cache .setConnectTimeout(((Long) redisProperties.getTimeout().toMillis()).intValue())
*/ .setPassword(StringUtils.isNotBlank(redisProperties.getPassword()) ? redisProperties.getPassword() : null)
@Bean .setTimeout(clusterServersConfig.getTimeout())
public CacheManager cacheManager(RedissonClient redissonClient) { .setRetryAttempts(clusterServersConfig.getRetryAttempts())
List<RedissonProperties.CacheGroup> cacheGroup = redissonProperties.getCacheGroup(); .setRetryInterval(clusterServersConfig.getRetryInterval())
Map<String, CacheConfig> config = new HashMap<>(); .setSubscriptionsPerConnection(clusterServersConfig.getSubscriptionsPerConnection())
for (RedissonProperties.CacheGroup group : cacheGroup) { .setClientName(clusterServersConfig.getClientName())
CacheConfig cacheConfig = new CacheConfig(group.getTtl(), group.getMaxIdleTime()); .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
cacheConfig.setMaxSize(group.getMaxSize()); .setPingConnectionInterval(clusterServersConfig.getPingConnectionInterval())
config.put(group.getGroupId(), cacheConfig); .setSubscriptionConnectionMinimumIdleSize(clusterServersConfig.getSubscriptionConnectionMinimumIdleSize())
} .setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
return new RedissonSpringCacheManager(redissonClient, config, JsonJacksonCodec.INSTANCE); .setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
} .setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
.setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
.setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
.setDnsMonitoringInterval(clusterServersConfig.getDnsMonitoringInterval())
.setFailedSlaveReconnectionInterval(clusterServersConfig.getFailedSlaveReconnectionInterval())
.setScanInterval(clusterServersConfig.getScanInterval())
.setReadMode(clusterServersConfig.getReadMode())
.setSubscriptionMode(clusterServersConfig.getSubscriptionMode())
.setNodeAddresses(nodes);
}
RedissonClient redissonClient = Redisson.create(config);
log.info("初始化 redis 配置");
return redissonClient;
}
/** /**
* redis集群配置 yml * 整合spring-cache
* */
* --- # redis 集群配置(单机与集群只能开启一个另一个需要注释掉) @Bean
* spring: public CacheManager cacheManager(RedissonClient redissonClient) {
* redis: List<RedissonProperties.CacheGroup> cacheGroup = redissonProperties.getCacheGroup();
* cluster: Map<String, CacheConfig> config = new HashMap<>();
* nodes: for (RedissonProperties.CacheGroup group : cacheGroup) {
* - 192.168.0.100:6379 CacheConfig cacheConfig = new CacheConfig(group.getTtl(), group.getMaxIdleTime());
* - 192.168.0.101:6379 cacheConfig.setMaxSize(group.getMaxSize());
* - 192.168.0.102:6379 config.put(group.getGroupId(), cacheConfig);
* # 密码 }
* password: return new RedissonSpringCacheManager(redissonClient, config, JsonJacksonCodec.INSTANCE);
* # 连接超时时间 }
* timeout: 10s
* # 是否开启ssl /**
* ssl: false * redis集群配置 yml
* *
* redisson: * --- # redis 集群配置(单机与集群只能开启一个另一个需要注释掉)
* # 线程池数量 * spring:
* threads: 16 * redis:
* # Netty线程池数量 * cluster:
* nettyThreads: 32 * nodes:
* # 传输模式 * - 192.168.0.100:6379
* transportMode: "NIO" * - 192.168.0.101:6379
* # 集群配置 * - 192.168.0.102:6379
* clusterServersConfig: * # 密码
* # 客户端名称 * password:
* clientName: ${ruoyi.name} * # 连接超时时间
* # master最小空闲连接数 * timeout: 10s
* masterConnectionMinimumIdleSize: 32 * # 是否开启ssl
* # master连接池大小 * ssl: false
* masterConnectionPoolSize: 64 *
* # slave最小空闲连接数 * redisson:
* slaveConnectionMinimumIdleSize: 32 * # 线程池数量
* # slave连接池大小 * threads: 16
* slaveConnectionPoolSize: 64 * # Netty线程池数量
* # 连接空闲超时，单位：毫秒 * nettyThreads: 32
* idleConnectionTimeout: 10000 * # 传输模式
* # ping连接间隔 * transportMode: "NIO"
* pingConnectionInterval: 1000 * # 集群配置
* # 命令等待超时，单位：毫秒 * clusterServersConfig:
* timeout: 3000 * # 客户端名称
* # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。 * clientName: ${ruoyi.name}
* retryAttempts: 3 * # master最小空闲连接数
* # 命令重试发送时间间隔，单位：毫秒 * masterConnectionMinimumIdleSize: 32
* retryInterval: 1500 * # master连接池大小
* # 从可用服务器的内部列表中排除 Redis Slave 重新连接尝试的间隔。 * masterConnectionPoolSize: 64
* failedSlaveReconnectionInterval: 3000 * # slave最小空闲连接数
* # 发布和订阅连接池最小空闲连接数 * slaveConnectionMinimumIdleSize: 32
* subscriptionConnectionMinimumIdleSize: 1 * # slave连接池大小
* # 发布和订阅连接池大小 * slaveConnectionPoolSize: 64
* subscriptionConnectionPoolSize: 50 * # 连接空闲超时，单位：毫秒
* # 单个连接最大订阅数量 * idleConnectionTimeout: 10000
* subscriptionsPerConnection: 5 * # ping连接间隔
* # 扫描间隔 * pingConnectionInterval: 1000
* scanInterval: 1000 * # 命令等待超时，单位：毫秒
* # DNS监测时间间隔，单位：毫秒 * timeout: 3000
* dnsMonitoringInterval: 5000 * # 如果尝试在此限制之内发送成功，则开始启用 timeout 计时。
* # 读取模式 * retryAttempts: 3
* readMode: "SLAVE" * # 命令重试发送时间间隔，单位：毫秒
* # 订阅模式 * retryInterval: 1500
* subscriptionMode: "MASTER" * # 从可用服务器的内部列表中排除 Redis Slave 重新连接尝试的间隔。
*/ * failedSlaveReconnectionInterval: 3000
* # 发布和订阅连接池最小空闲连接数
* subscriptionConnectionMinimumIdleSize: 1
* # 发布和订阅连接池大小
* subscriptionConnectionPoolSize: 50
* # 单个连接最大订阅数量
* subscriptionsPerConnection: 5
* # 扫描间隔
* scanInterval: 1000
* # DNS监测时间间隔，单位：毫秒
* dnsMonitoringInterval: 5000
* # 读取模式
* readMode: "SLAVE"
* # 订阅模式
* subscriptionMode: "MASTER"
*/
} }

Write Preview
Loading…
Cancel
Save