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

素颜马尾好姑娘i 2024-04-20 22:08 43阅读 0赞

### 配置文件中的配置信息 ###

# 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;
        }
    }