Redisson客户端配置与缓存管理器

 配置文件中的配置信息

# redis 配置
spring:
  redis:
      host: x.x.x.x
      port: 6379
      password: 123456
      database: 0
      # 连接超时时间
      timeout: 10s
      # 是否开启ssl
      ssl: false
      
# redisson 配置
redisson:
  # 线程池数量
  threads: 16
  # Netty线程池数量
  nettyThreads: 32
  # 单节点配置
  singleServerConfig:
    # 客户端名称
    clientName: ${spring.application.name}
    # 最小空闲连接数
    connectionMinimumIdleSize: 8
    # 连接池大小
    connectionPoolSize: 32
    # 连接空闲超时，单位：毫秒
    idleConnectionTimeout: 10000
    # 命令等待超时，单位：毫秒
    timeout: 60000
    # 发布和订阅连接池大小
    subscriptionConnectionPoolSize: 50
  # redisson 缓存配置
  cacheGroup:
    # 用例: @Cacheable(cacheNames="groupId", key="#XXX") 方可使用缓存组配置
    - groupId: redissonCacheMap
      # 组过期时间(脚本监控)
      ttl: 60000
      # 组最大空闲时间(脚本监控)
      maxIdleTime: 60000
      # 组最大长度
      maxSize: 0

 配置信息

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import org.redisson.config.ReadMode;
import org.redisson.config.SubscriptionMode;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.List;

@ConfigurationProperties(
        prefix = "redisson"
)
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class RedissonProperties {
    private int threads;
    private int nettyThreads;
    private SingleServerConfig singleServerConfig;
    private ClusterServersConfig clusterServersConfig;
    private List<CacheGroup> cacheGroup;


    @Data
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public static class CacheGroup {
        private String groupId;
        private long ttl;
        private long maxIdleTime;
        private int maxSize;
    }

    /**
     * 集群服务器配置
     *
     * @author cong.zhen
     * @date 2023/01/18
     */
    @Data
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public static class ClusterServersConfig {
        private String clientName;
        private int masterConnectionMinimumIdleSize;
        private int masterConnectionPoolSize;
        private int slaveConnectionMinimumIdleSize;
        private int slaveConnectionPoolSize;
        private int idleConnectionTimeout;
        private int timeout;
        private int subscriptionConnectionPoolSize;
        private ReadMode readMode;
        private SubscriptionMode subscriptionMode;
    }

    /**
     * 单机模式配置
     *
     * @author cong.zhen
     * @date 2023/01/18
     */
    @Data
    @ToString
    @AllArgsConstructor
    @NoArgsConstructor
    public static class SingleServerConfig {
        private String clientName;
        private int connectionMinimumIdleSize;
        private int connectionPoolSize;
        private int idleConnectionTimeout;
        private int timeout;
        private int subscriptionConnectionPoolSize;
    }
}

Redission客户端和缓存组配置

@AutoConfigureBefore({RedissonAutoConfiguration.class})
@EnableConfigurationProperties({RedissonProperties.class})
@Configuration
@EnableCaching
@Slf4j
public class RedisConfiguration extends CachingConfigurerSupport {
    private static final String REDIS_PROTOCOL_PREFIX = "redis://";
    private static final String REDISS_PROTOCOL_PREFIX = "rediss://";
    @Resource
    private RedisProperties redisProperties;
    @Resource
    private RedissonProperties redissonProperties;

    public RedisConfiguration() {
    }

    @Primary
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        String prefix = REDIS_PROTOCOL_PREFIX;
        if (this.redisProperties.isSsl()) {
            prefix = REDISS_PROTOCOL_PREFIX;
        }
        Config config = new Config();
        config.setThreads(this.redissonProperties.getThreads()).
                setNettyThreads(this.redissonProperties.getNettyThreads()).
                setCodec(new JsonJacksonCodec(JacksonUtil.getObjectMapper()));
        RedissonProperties.SingleServerConfig singleServerConfig = this.redissonProperties.getSingleServerConfig();
        if (ObjectUtil.isNotNull(singleServerConfig)) {
            config.useSingleServer().setAddress(prefix + this.redisProperties.getHost() + ":" + this.redisProperties.getPort())
                    .setConnectTimeout((int)this.redisProperties.getTimeout().toMillis())
                    .setDatabase(this.redisProperties.getDatabase())
                    .setPassword(StrUtil.isNotBlank(this.redisProperties.getPassword()) ? this.redisProperties.getPassword() : null)
                    .setTimeout(singleServerConfig.getTimeout())
                    .setClientName(singleServerConfig.getClientName())
                    .setIdleConnectionTimeout(singleServerConfig.getIdleConnectionTimeout())
                    .setSubscriptionConnectionPoolSize(singleServerConfig.getSubscriptionConnectionPoolSize())
                    .setConnectionMinimumIdleSize(singleServerConfig.getConnectionMinimumIdleSize())
                    .setConnectionPoolSize(singleServerConfig.getConnectionPoolSize());
        }

        RedissonProperties.ClusterServersConfig clusterServersConfig = this.redissonProperties.getClusterServersConfig();
        if (ObjectUtil.isNotNull(clusterServersConfig)) {
            String finalPrefix = prefix;
            List<String> nodes = this.redisProperties.getCluster().getNodes().stream().map((node) -> finalPrefix + node).collect(Collectors.toList());
            config.useClusterServers().setConnectTimeout((int)this.redisProperties.getTimeout().toMillis())
                    .setPassword(StrUtil.isNotBlank(this.redisProperties.getPassword()) ? this.redisProperties.getPassword() : null)
                    .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())
                    .setNodeAddresses(nodes);
        }

        RedissonClient redissonClient = Redisson.create(config);
        log.info("初始化 redis 配置");
        return redissonClient;
    }

    @Bean
    public CacheManager cacheManager(RedissonClient redissonClient) {
//我们从RedissonProperties中获取缓存组的配置信息
        List<RedissonProperties.CacheGroup> cacheGroup = this.redissonProperties.getCacheGroup();
//我们创建一个名为config的Map对象来保存缓存的配置信息。
        Map<String, CacheConfig> config = new HashMap(8);
        Iterator var4 = cacheGroup.iterator();
//遍历cacheGroup，并创建CacheConfig对象，将每个缓存组的配置信息
//设置到CacheConfig对象中，然后将CacheConfig对象保存到config中，
//以便我们可以使用它来创建RedissonSpringCacheManager实例。
        while (var4.hasNext()) {
            RedissonProperties.CacheGroup group = (RedissonProperties.CacheGroup) var4.next();
            CacheConfig cacheConfig = new CacheConfig(group.getTtl(), group.getMaxIdleTime());
            cacheConfig.setMaxSize(group.getMaxSize());
            config.put(group.getGroupId(), cacheConfig);
        }
//使用redissonClient、config和JsonJacksonCodec.INSTANCE创建
//RedissonSpringCacheManager实例，并将其返回作为cacheManager bean。

        return new RedissonSpringCacheManager(redissonClient, config, JsonJacksonCodec.INSTANCE);
    }


}

使用方法

 1.设值 拿值

@Resource
private RedissonClient redissonClient;

//过期时间为一天  设置值
redissonClient.getBucket("key").set("value",1,TimeUnit.DAYS);


//得到值
RBucket<String> bucket = redissonClient.getBucket("key");
//得到"value" 
String a  = bucket.get();

2.缓存

   可以直接使用注解的方式

@Cacheable(cacheNames="redissonCacheMap", key="#userId")
public User getUser(String userId) {
    // ...
}

        当调用getUser方法时，如果缓存中存在以userId作为key值的缓存，则直接从缓存中获取数据并返回；否则会执行方法体中的代码，将返回值存储到缓存中，并返回方法的返回值。

        需要注意的是，如果groupId对应的缓存组在cacheManager()方法中未被定义，则会抛出CacheNotFoundException异常。因此，使用@Cacheable注解时需要确保对应的缓存组已经被定义。(所以这里的cacheNames 就是groupId 要和上面Yml文件中的对应)

不使用注解(一般不采用)

@Repository
public class UserRepository {

    @Autowired
    private CacheManager cacheManager;

    public User findById(Long id) {
        String cacheName = "users";
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null && cache.get(id) != null) {
            // 缓存命中，直接返回缓存中的值
            return (User) cache.get(id).get();
        }
        // 缓存未命中，从数据库中查询用户信息
        User user = new User(id, "user" + id, "user" + id + "@example.com");
        // 将查询结果缓存起来
        cache.put(id, user);
        return user;
    }
}