Connecting to Redis on Redisson (Java)

Prerequisites

• A Redis instance is created, and is in the Running state. To create a Redis instance, see Buying a DCS Redis Instance.
• View the IP address/domain name and port number of the DCS Redis instance to be accessed. For details, see Viewing and Modifying Basic Settings of a DCS Instance.

Pom Configuration

<!-- spring-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <!--Lettuce is integrated in Spring Boot 2.x by default. This dependency needs to be deleted. -->
        <exclusion>
            <artifactId>lettuce-core</artifactId>
            <groupId>io.lettuce</groupId>
        </exclusion>
    </exclusions>
</dependency>
<!--Redisson's adaptation package for Spring Boot-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>${redisson.version}</version>
</dependency>

Bean Configuration

Spring Boot does not provide Redisson adaptation, and the application.properties configuration file does not have the corresponding configuration item. Therefore, you can only use Bean configuration.

• Single-node, read/write splitting, and Proxy Cluster

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

• Master/Standby

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

• Redis 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);
      }
  }

Parameter Description

Suggestion for Configuring DCS Instances

• readMode

  MASTER is the recommended value, that is, the master node bears all read and write traffic. This is to avoid data inconsistency caused by master/replica synchronization latency. If the value is SLAVE, all read requests will trigger errors when replicas are faulty. If the value is MASTER_SLAVE, some read requests will trigger errors. Read errors last for the period specified by failedSlaveCheckInterval (180s by default) until the faulty nodes are removed from the available node list.

  If read traffic and write traffic need to be separated, you can use read/write splitting DCS instances. Proxy nodes are deployed in the middle to distribute read and write traffic. When a replica node is faulty, traffic is automatically switched to the master node. The switchover does not interrupt service applications, and the fault detection time window is far shorter than Redisson's window.

• subscriptionMode

  Similar to readMode, MASTER is the recommended value.

• Connection pool configuration
  

  The following calculation is applicable only to common service scenarios. You can customize it based on your service requirements.

  There is no standard connection pool size. You can configure one based on your service traffic. The following formulas are for reference:

  • Minimum number of connections = (QPS of a single node accessing Redis)/(1000 ms/Average time spent on a single command)
  • Maximum number of connections = (QPS of a single node accessing Redis)/(1000 ms/Average time spent on a single command) x 150%

  For example, if the QPS of a service application is about 10,000, each request needs to access Redis 10 times (that is, 100,000 accesses to Redis every second), and the service application has 10 hosts, the calculation is as follows:

  QPS of a single node accessing Redis = 100,000/10 = 10,000

  Average time spent on a single command = 20 ms (Redis takes 5 ms to 10 ms to process a single command under normal conditions. If network jitter occurs, it takes 15 ms to 20 ms.)

  Minimum number of connections = 10,000/(1000 ms/20 ms) = 200

  Maximum number of connections = 10,000/(1000 ms/20 ms) × 150% = 300