关于java:spring-cloud-采用nacos作为注册中心动态配置redisson

需要

对于 spring-boot 整合 redisson 的相干计划网上有很多，次要是通过 redisson-spring-boot-starter 实现主动拆卸，现有的我的项目采纳 spring-cloud，nacos 作为服务的发现和注册核心，redis的相干配置信息不在本地保留，集中放到配置核心，我的项目启动时从配置核心读取配置文件，构建对应的 SingleServerProperties，截止本文的公布，redisson-spring-boot-starter 依然不能很好的反对从 nacos 读取属性实现配置（起因在于：SingleServerProperties须要的配置信息无奈通过繁多的 POJO 形容，其中的局部属性依赖其它的bean，必须从最小的单元拆卸，最初整合装配成）；

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.13.3</version>
</dependency>

SingleServerProperties.java

@Bean(destroyMethod="shutdown")
RedissonClient redissonClient(SingleServerProperties properties) throws IOException {ObjectMapper mapper=new ObjectMapper();
    String jsonString = mapper.writeValueAsString(properties);
    Config config = Config.fromYAML(jsonString);
    if (StrUtil.isEmpty(properties.getSingleServerConfig().getPassword())){config.useSingleServer().setPassword(null);
    }
    return Redisson.create(config);
}

解决思路

拆分 SingleServerProperties，合成到最小单元（所有的属性均是根底类型，不再依赖其余的bean）, 从最小的单元拆卸，最初整合装配成SingleServerProperties
参考 SingleServerProperties 的源码，重写该局部

BaseConfig.java

@Data
public class BaseConfig<T extends org.redisson.config.BaseConfig<T>>  {
    /**
 * If pooled connection not used for a <code>timeout</code> time * and current connections amount bigger than minimum idle connections pool size, * then it will closed and removed from pool. * Value in milliseconds. */ @Value("${redisson.singleServerConfig.idleConnectionTimeout:}")
    private int idleConnectionTimeout = 10000;
    /**
 * Timeout during connecting to any Redis server. * Value in milliseconds. */ @Value("${redisson.singleServerConfig.connectTimeout:}")
    private int connectTimeout = 10000;
    /**
 * Redis server response timeout. Starts to countdown when Redis command was succesfully sent. * Value in milliseconds. */ @Value("${redisson.singleServerConfig.timeout:}")
    private int timeout = 3000;
    @Value("${redisson.singleServerConfig.retryAttempts:}")
    private int retryAttempts = 3;
    @Value("${redisson.singleServerConfig.retryInterval:}")
    private int retryInterval = 1500;
    /**
 * Password for Redis authentication. Should be null if not needed */ 
    @Value("${redisson.singleServerConfig.password:}")
    private String password;
    private String username;
    /**
 * Subscriptions per Redis connection limit */ 
    @Value("${redisson.singleServerConfig.subscriptionsPerConnection:}")
    private int subscriptionsPerConnection = 5;
    /**
    * Name of client connection */ 
    @Value("${redisson.singleServerConfig.clientName:}")
    private String clientName;
    private boolean sslEnableEndpointIdentification = true;
    private SslProvider sslProvider = SslProvider.JDK;
    private URL sslTruststore;
    private String sslTruststorePassword;
    private URL sslKeystore;
    private String sslKeystorePassword;
    private int pingConnectionInterval;
    private boolean keepAlive;
    private boolean tcpNoDelay;
}

Codec.java

@Data
@Component
public class Codec implements Serializable {
    private static final long serialVersionUID = -8394853238388494359L;
    @JsonProperty(value = "class")
    @Value("${redisson.codec.class}")
    String cls;
}

SingleServerConfig.java

@EqualsAndHashCode(callSuper = true)
@Data
@Component
public class SingleServerConfig extends BaseConfig {
    private static final long serialVersionUID = -3173391729030180033L;
    
    /*** Redis server address */ 
    @Value("${redisson.singleServerConfig.address:}")
    private String address;
    
    /**Minimum idle subscription connection amount */
    @Value("${redisson.singleServerConfig.subscriptionConnectionMinimumIdleSize:}")
    private int subscriptionConnectionMinimumIdleSize = 1;
    
    /*** Redis subscription connection maximum pool size * */ 
    @Value("${redisson.singleServerConfig.subscriptionConnectionPoolSize:}")
    private int subscriptionConnectionPoolSize = 50;
    
    /**Minimum idle Redis connection amount */ 
    @Value("${redisson.singleServerConfig.connectionMinimumIdleSize:}")
    private int connectionMinimumIdleSize = 24;
    
    /* Redis connection maximum pool size */
    @Value("${redisson.singleServerConfig.connectionPoolSize:}")
    private int connectionPoolSize = 64;
    
    /**Database index used for Redis connection */ 
    @Value("${redisson.singleServerConfig.database:}")
    private int database = 0;
    
    /**Interval in milliseconds to check DNS */   
    @Value("${redisson.singleServerConfig.dnsMonitoringInterval:}")
    private long dnsMonitoringInterval = 5000;
}

SingleServerProperties.java

@Data
@Component
public class SingleServerProperties implements Serializable {
    private static final long serialVersionUID = -385286650728472483L;
    @Autowired
    private SingleServerConfig singleServerConfig;
    
    @Value("${redisson.threads:}")
    private int threads;
    
    @Value("${redisson.nettyThreads:}")
    private int nettyThreads;
    
    @Value("${redisson.transportMode:}")
    private String transportMode;
    
    @Autowired
    private Codec codec;
}

最初集中配置

@Configuration
@ComponentScan
public class RedissonConfiguration {
    @Autowired
 SingleServerProperties singleServerProperties;
    @Bean(destroyMethod="shutdown")
    RedissonClient redissonClient(SingleServerProperties properties) throws IOException {ObjectMapper mapper=new ObjectMapper();
        String jsonString = mapper.writeValueAsString(properties);
        Config config = Config.fromYAML(jsonString);
        if (StrUtil.isEmpty(properties.getSingleServerConfig().getPassword())){config.useSingleServer().setPassword(null);
        }
        return Redisson.create(config);
    }
}