Redisson客户端连接Redis（Java）

前提条件

• 已成功创建Redis实例，且状态为“运行中”。
• 查看并获取待连接Redis实例的IP地址/域名和端口。具体步骤请参见《分布式缓存服务用户指南》中“快速入门 > 查看实例信息”章节。

Pom配置

<!-- 引入spring-data-redis组件 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <!-- 因springboot2.x中默认集成了lettuce，因此需要排掉该依赖 -->
        <exclusion>
            <artifactId>lettuce-core</artifactId>
            <groupId>io.lettuce</groupId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 引入redisson对springboot的集成适配包 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>${redisson.version}</version>
</dependency>

基于Bean方式配置

因springboot中没有提供对redisson的适配，在application.properties配置文件自然也没有对应的配置项，只能通过基于Bean的方式注入。

• 单机、Proxy集群实例配置

  import org.redisson.Redisson;
  import org.redisson.api.RedissonClient;
  import org.redisson.codec.JsonJacksonCodec;
  import org.redisson.config.Config;
  import org.redisson.config.SingleServerConfig;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class SingleConfig {
  
      @Value("${redis.address:}")
      private String redisAddress;
  
      @Value("${redis.password:}")
      private String redisPassword;
  
      @Value("${redis.database:0}")
      private Integer redisDatabase = 0;
  
      @Value("${redis.connect.timeout:3000}")
      private Integer redisConnectTimeout = 3000;
  
      @Value("${redis.connection.idle.timeout:10000}")
      private Integer redisConnectionIdleTimeout = 10000;
  
      @Value("${redis.connection.ping.interval:1000}")
      private Integer redisConnectionPingInterval = 1000;
  
      @Value("${redis.timeout:2000}")
      private Integer timeout = 2000;
  
      @Value("${redis.connection.pool.min.size:50}")
      private Integer redisConnectionPoolMinSize;
  
      @Value("${redis.connection.pool.max.size:200}")
      private Integer redisConnectionPoolMaxSize;
  
      @Value("${redis.retry.attempts:3}")
      private Integer redisRetryAttempts = 3;
  
      @Value("${redis.retry.interval:200}")
      private Integer redisRetryInterval = 200;
  
      @Bean
      public RedissonClient redissonClient(){
          Config redissonConfig = new Config();
  
          SingleServerConfig serverConfig = redissonConfig.useSingleServer();
          serverConfig.setAddress(redisAddress);
          serverConfig.setConnectionMinimumIdleSize(redisConnectionPoolMinSize);
          serverConfig.setConnectionPoolSize(redisConnectionPoolMaxSize);
  
          serverConfig.setDatabase(redisDatabase);
          serverConfig.setPassword(redisPassword);
          serverConfig.setConnectTimeout(redisConnectTimeout);
          serverConfig.setIdleConnectionTimeout(redisConnectionIdleTimeout);
          serverConfig.setPingConnectionInterval(redisConnectionPingInterval);
          serverConfig.setTimeout(timeout);
          serverConfig.setRetryAttempts(redisRetryAttempts);
          serverConfig.setRetryInterval(redisRetryInterval);
  
          redissonConfig.setCodec(new JsonJacksonCodec());
          return Redisson.create(redissonConfig);
      }
  }

• 主备实例配置

  import org.redisson.Redisson;
  import org.redisson.api.RedissonClient;
  import org.redisson.codec.JsonJacksonCodec;
  import org.redisson.config.Config;
  import org.redisson.config.MasterSlaveServersConfig;
  import org.redisson.config.ReadMode;
  import org.redisson.config.SubscriptionMode;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  import java.util.HashSet;
  
  @Configuration
  public class MasterStandbyConfig {
      @Value("${redis.master.address}")
      private String redisMasterAddress;
  
      @Value("${redis.slave.address}")
      private String redisSlaveAddress;
  
      @Value("${redis.database:0}")
      private Integer redisDatabase = 0;
  
      @Value("${redis.password:}")
      private String redisPassword;
  
      @Value("${redis.connect.timeout:3000}")
      private Integer redisConnectTimeout = 3000;
  
      @Value("${redis.connection.idle.timeout:10000}")
      private Integer redisConnectionIdleTimeout = 10000;
  
      @Value("${redis.connection.ping.interval:1000}")
      private Integer redisConnectionPingInterval = 1000;
  
      @Value("${redis.timeout:2000}")
      private Integer timeout = 2000;
  
      @Value("${redis.master.connection.pool.min.size:50}")
      private Integer redisMasterConnectionPoolMinSize = 50;
  
      @Value("${redis.master.connection.pool.max.size:200}")
      private Integer redisMasterConnectionPoolMaxSize = 200;
  
      @Value("${redis.retry.attempts:3}")
      private Integer redisRetryAttempts = 3;
  
      @Value("${redis.retry.interval:200}")
      private Integer redisRetryInterval = 200;
  
      @Bean
      public RedissonClient redissonClient() {
          Config redissonConfig = new Config();
  
          MasterSlaveServersConfig serverConfig = redissonConfig.useMasterSlaveServers();
          serverConfig.setMasterAddress(redisMasterAddress);
          HashSet<String> slaveSet = new HashSet<>();
          slaveSet.add(redisSlaveAddress);
          serverConfig.setSlaveAddresses(slaveSet);
  
          serverConfig.setDatabase(redisDatabase);
          serverConfig.setPassword(redisPassword);
  
          serverConfig.setMasterConnectionMinimumIdleSize(redisMasterConnectionPoolMinSize);
          serverConfig.setMasterConnectionPoolSize(redisMasterConnectionPoolMaxSize);
  
          serverConfig.setReadMode(ReadMode.MASTER);
          serverConfig.setSubscriptionMode(SubscriptionMode.MASTER);
  
          serverConfig.setConnectTimeout(redisConnectTimeout);
          serverConfig.setIdleConnectionTimeout(redisConnectionIdleTimeout);
          serverConfig.setPingConnectionInterval(redisConnectionPingInterval);
          serverConfig.setTimeout(timeout);
          serverConfig.setRetryAttempts(redisRetryAttempts);
          serverConfig.setRetryInterval(redisRetryInterval);
  
          redissonConfig.setCodec(new JsonJacksonCodec());
          return Redisson.create(redissonConfig);
      }
  }

• Cluster集群实例配置

  import org.redisson.Redisson;
  import org.redisson.api.RedissonClient;
  import org.redisson.codec.JsonJacksonCodec;
  import org.redisson.config.ClusterServersConfig;
  import org.redisson.config.Config;
  import org.redisson.config.ReadMode;
  import org.redisson.config.SubscriptionMode;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  import java.util.List;
  
  @Configuration
  public class ClusterConfig {
  
      @Value("${redis.cluster.address}")
      private List<String> redisClusterAddress;
  
      @Value("${redis.cluster.scan.interval:5000}")
      private Integer redisClusterScanInterval = 5000;
  
      @Value("${redis.password:}")
      private String redisPassword;
  
      @Value("${redis.connect.timeout:3000}")
      private Integer redisConnectTimeout = 3000;
  
      @Value("${redis.connection.idle.timeout:10000}")
      private Integer redisConnectionIdleTimeout = 10000;
  
      @Value("${redis.connection.ping.interval:1000}")
      private Integer redisConnectionPingInterval = 1000;
  
      @Value("${redis.timeout:2000}")
      private Integer timeout = 2000;
  
      @Value("${redis.retry.attempts:3}")
      private Integer redisRetryAttempts = 3;
  
      @Value("${redis.retry.interval:200}")
      private Integer redisRetryInterval = 200;
  
      @Value("${redis.master.connection.pool.min.size:50}")
      private Integer redisMasterConnectionPoolMinSize = 50;
  
      @Value("${redis.master.connection.pool.max.size:200}")
      private Integer redisMasterConnectionPoolMaxSize = 200;
  
      @Bean
      public RedissonClient redissonClient() {
          Config redissonConfig = new Config();
  
          ClusterServersConfig serverConfig = redissonConfig.useClusterServers();
          serverConfig.setNodeAddresses(redisClusterAddress);
          serverConfig.setScanInterval(redisClusterScanInterval);
  
          serverConfig.setPassword(redisPassword);
  
          serverConfig.setMasterConnectionMinimumIdleSize(redisMasterConnectionPoolMinSize);
          serverConfig.setMasterConnectionPoolSize(redisMasterConnectionPoolMaxSize);
  
          serverConfig.setReadMode(ReadMode.MASTER);
          serverConfig.setSubscriptionMode(SubscriptionMode.MASTER);
  
          serverConfig.setConnectTimeout(redisConnectTimeout);
          serverConfig.setIdleConnectionTimeout(redisConnectionIdleTimeout);
          serverConfig.setPingConnectionInterval(redisConnectionPingInterval);
          serverConfig.setTimeout(timeout);
          serverConfig.setRetryAttempts(redisRetryAttempts);
          serverConfig.setRetryInterval(redisRetryInterval);
  
          redissonConfig.setCodec(new JsonJacksonCodec());
          return Redisson.create(redissonConfig);
      }
  }

参数明细

DCS实例配置建议

• 读取模式（readMode）

  建议采用MASTER，即Master节点承担所有的读写流量，一方面避免数据因主从同步时延带来的一致性问题；另一方面，如果从节点故障，配置值=SLAVE，所有读请求会触发报错；配置值=MASTER_SLAVE，部分读请求会触发异常。读报错会持续failedSlaveCheckInterval（默认180s）时间，直至从可用节点列表中摘除。

• 订阅模式（subscriptionMode）

  建议采用MASTER，原理同读取模式（readMode）。

• 连接池配置
  

  以下计算方式只适用于一般业务场景，建议根据业务情况做适当调整适配。

  连接池的大小没有绝对的标准，建议根据业务流量进行合理配置，一般连接池大小的参数计算公式如下：

  • 最小连接数 =（单机访问Redis QPS）/（1000ms / 单命令平均耗时）
  • 最大连接数 =（单机访问Redis QPS）/（1000ms / 单命令平均耗时）* 150%

  举例：某个业务应用的QPS为10000左右，每个请求需访问Redis10次，即每秒对Redis的访问次数为100000次，同时该业务应用有10台机器，计算如下：

  单机访问Redis QPS = 100000 / 10 = 10000

  单命令平均耗时 = 20ms（Redis处理单命令耗时为5~10ms，遇到网络抖动按照15~20ms来估算）

  最小连接数 =（10000）/（1000ms / 20ms）= 200

  最大连接数 =（10000）/（1000ms / 20ms）* 150% = 300