redisson配置类---SpringBoot集成、redis单机和集群模式配置

1项目配置文件：

1.1：pom.xml

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

1.2 application.yml配置文件

spring:
 redis:
  cluster:
    nodes:
      - ip:port
      - ip:port
      - ip:port
      - ip:port
      - ip:port
      - ip:port
  # 密码
  password: *******
  # 连接超时时间
  timeout: 10s
  # 是否开启ssl
  ssl: false
redisson:
# 线程池数量
 threads: 8
# Netty线程池数量
 nettyThreads: 16
# 集群配置
 clusterServersConfig:
  # 客户端名称
  clientName: redisClient
  # master最小空闲连接数
  masterConnectionMinimumIdleSize: 16
  # master连接池大小
  masterConnectionPoolSize: 32
  # slave最小空闲连接数
  slaveConnectionMinimumIdleSize: 16
  # slave连接池大小
  slaveConnectionPoolSize: 64
  # 连接空闲超时，单位：毫秒
  idleConnectionTimeout: 10000
  # 命令等待超时，单位：毫秒
  timeout: 3000
  # 发布和订阅连接池大小
  subscriptionConnectionPoolSize: 50
  # 读取模式
  readMode: "SLAVE"
  # 订阅模式
  subscriptionMode: "MASTER"

cacheGroup:
  # 用例: @Cacheable(cacheNames="groupId", key="#XXX") 方可使用缓存组配置
  - groupId: redissonCacheMap
    # 组过期时间(脚本监控)
    ttl: 60000
    # 组最大空闲时间(脚本监控)
    maxIdleTime: 60000
    # 组最大长度
    maxSize: 0

配置类

2-1配置属性类：RedissonProperties.java

import lombok.Data;
import lombok.NoArgsConstructor;
import org.redisson.config.ReadMode;
import org.redisson.config.SubscriptionMode;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * Redisson 配置属性
 * @author zengshichang
 */
@Data
@Component
@ConfigurationProperties(prefix = "redisson")
public class RedissonProperties {
    /**
     * 线程池数量,默认值 = 当前处理核数量 * 2
     */
    private int threads;
    /**
     * Netty线程池数量,默认值 = 当前处理核数量 * 2
     */
    private int nettyThreads;
    /**
     * 单机服务配置
     */
    private SingleServerConfig singleServerConfig;
    /**
     * 集群服务配置
     */
    private ClusterServersConfig clusterServersConfig;
    /**
     * 缓存组
     */
    private List<CacheGroup> cacheGroup;
    @Data
    @NoArgsConstructor
    public static class SingleServerConfig {
        /**
         * 客户端名称
         */
        private String clientName;
        /**
         * 最小空闲连接数
         */
        private int connectionMinimumIdleSize;
        /**
         * 连接池大小
         */
        private int connectionPoolSize;
        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;
        /**
         * 命令等待超时，单位：毫秒
         */
        private int timeout;
        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;
    }
    @Data
    @NoArgsConstructor
    public static class ClusterServersConfig {
        /**
         * 客户端名称
         */
        private String clientName;

        /**
         * master最小空闲连接数
         */
        private int masterConnectionMinimumIdleSize;
        /**
         * master连接池大小
         */
        private int masterConnectionPoolSize;
        /**
         * slave最小空闲连接数
         */
        private int slaveConnectionMinimumIdleSize;
        /**
         * slave连接池大小
         */
        private int slaveConnectionPoolSize;
        /**
         * 连接空闲超时，单位：毫秒
         */
        private int idleConnectionTimeout;
        /**
         * 命令等待超时，单位：毫秒
         */
        private int timeout;
        /**
         * 发布和订阅连接池大小
         */
        private int subscriptionConnectionPoolSize;
        /**
         * 读取模式
         */
        private ReadMode readMode;
        /**
         * 订阅模式
         */
        private SubscriptionMode subscriptionMode;
    }
    @Data
    @NoArgsConstructor
    public static class CacheGroup {
        /**
         * 组id
         */
        private String groupId;
        /**
         * 组过期时间
         */
        private long ttl;
        /**
         * 组最大空闲时间
         */
        private long maxIdleTime;
        /**
         * 组最大长度
         */
        private int maxSize;
    }
}

2-2redis配置：RedisConfig.java

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.spring.cache.CacheConfig;
import org.redisson.spring.cache.RedissonSpringCacheManager;
import org.redisson.spring.starter.RedissonAutoConfigurationCustomizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import cn.hutool.core.util.ObjectUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * redis配置
 * @author zengshichang
 */
@Slf4j
@Configuration
@EnableCaching
@EnableConfigurationProperties(RedissonProperties.class)
public class RedisConfig extends CachingConfigurerSupport {
    @Autowired
    private RedissonProperties redissonProperties;
    @Autowired
    private ObjectMapper objectMapper;
    @Bean
    public RedissonAutoConfigurationCustomizer redissonCustomizer() {
        return config -> {
            config.setThreads(redissonProperties.getThreads())
                .setNettyThreads(redissonProperties.getNettyThreads())
                .setCodec(new StringCodec());
            RedissonProperties.SingleServerConfig singleServerConfig = redissonProperties.getSingleServerConfig();
            if (ObjectUtil.isNotNull(singleServerConfig)) {
                // 使用单机模式
                config.useSingleServer()
                    .setTimeout(singleServerConfig.getTimeout())
                    .setClientName(singleServerConfig.getClientName())
                    .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
                    .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
                    .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize());
            }
            // 集群配置方式 参考下方注释
            RedissonProperties.ClusterServersConfig clusterServersConfig = redissonProperties.getClusterServersConfig();
            if (ObjectUtil.isNotNull(clusterServersConfig)) {
                config.useClusterServers()
                    .setTimeout(clusterServersConfig.getTimeout())
                    .setClientName(clusterServersConfig.getClientName())
                    .setIdleConnectionTimeout(clusterServersConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(clusterServersConfig.getSubscriptionConnectionPoolSize())
                    .setMasterConnectionMinimumIdleSize(clusterServersConfig.getMasterConnectionMinimumIdleSize())
                    .setMasterConnectionPoolSize(clusterServersConfig.getMasterConnectionPoolSize())
                    .setSlaveConnectionMinimumIdleSize(clusterServersConfig.getSlaveConnectionMinimumIdleSize())
                    .setSlaveConnectionPoolSize(clusterServersConfig.getSlaveConnectionPoolSize())
                    .setReadMode(clusterServersConfig.getReadMode())
                    .setSubscriptionMode(clusterServersConfig.getSubscriptionMode());
            }
            log.info("初始化 redis 配置");
        };
    }

    /**
     * 整合spring-cache
     */
    @Bean
    public CacheManager cacheManager(RedissonClient redissonClient) {
        List<RedissonProperties.CacheGroup> cacheGroup = redissonProperties.getCacheGroup();
        Map<String, CacheConfig> config = new HashMap<>(16);
        for (RedissonProperties.CacheGroup group : cacheGroup) {
            CacheConfig cacheConfig = new CacheConfig(group.getTtl(), group.getMaxIdleTime());
            cacheConfig.setMaxSize(group.getMaxSize());
            config.put(group.getGroupId(), cacheConfig);
        }
        return new RedissonSpringCacheManager(redissonClient, config, new JsonJacksonCodec(objectMapper));
    }
}

注：EnableConfigurationPropertiess用法：

@EnableConfigurationProperties(RedissonProperties.class)是一个注解，用于启用将指定的配置类作为配置属性进行自动配置。

在Spring Boot应用程序中，通常使用@EnableConfigurationProperties注解来启用将配置属性绑定到特定的配置类。在这种情况下，RedissonProperties是用于绑定与Redisson相关的配置属性的配置类。

通过使用@EnableConfigurationProperties(RedissonProperties.class)注解，可以实现以下几点：

将RedissonProperties类作为配置属性类进行注册和加载。
自动将应用程序配置文件中与RedissonProperties相关的属性值与RedissonProperties类中的字段进行绑定。
可以通过在代码中注入RedissonProperties类的实例来获得配置的属性值，从而在应用程序中使用这些属性值。
这样，通过@EnableConfigurationProperties(RedissonProperties.class)注解，Redisson的配置属性就会被正确地加载和绑定，并能够在应用程序中使用这些配置。

2.3:Redisson使用

@RequiredArgsConstructor
@Service
@Slf4j
@RefreshScope
public class ServiceImpl implements IService {

    @Autowired
    private RedisDao redisDao;
}