Redisson

Prerequisites

• A DCS Redis instance has been created and is in the Running state.
• View the IP address/domain name and port number of the DCS Redis instance to be accessed.

  For details, see Viewing Instance Details.

• An ECS has been created. For details about how to create an ECS, see Purchasing an ECS.
• If the ECS runs the Linux OS, ensure that the Java compilation environment has been installed on the ECS.

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

  import org.redisson.codec.JsonJacksonCodec;
  import org.redisson.config.Config;
  import org.redisson.config.SingleServerConfig;
  import org.redisson.spring.data.connection.RedissonConnectionFactory;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class RedisConfiguration {
  
      @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 RedissonConnectionFactory redissonConnectionFactory(Config redissonSingleServerConfig) {
          return new RedissonConnectionFactory(redissonSingleServerConfig);
      }
  
      @Bean
      public Config redissonSingleServerConfig() {
          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 redissonConfig;
      }
  }

• Master/Standby and read/write splitting

  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.redisson.spring.data.connection.RedissonConnectionFactory;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class RedisConfiguration {
      @Value("${redis.master.address}")
      private String redisMasterAddress;
  
      @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 RedissonConnectionFactory redissonConnectionFactory(Config redissonMasterSlaveServersConfig) {
          return new RedissonConnectionFactory(redissonMasterSlaveServersConfig);
      }
  
      @Bean
      public Config redissonMasterSlaveServersConfig() {
          Config redissonConfig = new Config();
  
          MasterSlaveServersConfig serverConfig = redissonConfig.useMasterSlaveServers();
          serverConfig.setMasterAddress(redisMasterAddress);
  
          serverConfig.setDatabase(redisDatabase);
          serverConfig.setPassword(redisPassword);
  
          serverConfig.setMasterConnectionMinimumIdleSize(redisMasterConnectionPoolMinSize);
          serverConfig.setMasterConnectionPoolSize(redisMasterConnectionPoolMaxSize);
  
          serverConfig.setReadMode(ReadMode.MASTER_SLAVE);
          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 redissonConfig;
      }
  }

• Proxy Cluster

  import org.redisson.codec.JsonJacksonCodec;
  import org.redisson.config.Config;
  import org.redisson.config.SingleServerConfig;
  import org.redisson.spring.data.connection.RedissonConnectionFactory;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class RedisConfiguration {
  
      @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 RedissonConnectionFactory redissonConnectionFactory(Config redissonProxyServerConfig) {
          return new RedissonConnectionFactory(redissonProxyServerConfig);
      }
  
      @Bean
      public Config redissonProxyServerConfig() {
          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 redissonConfig;
      }
  }

• Redis Cluster

  import java.util.List;
  
  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.redisson.spring.data.connection.RedissonConnectionFactory;
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  @Configuration
  public class RedisConfiguration {
  
      @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 RedissonConnectionFactory redissonConnectionFactory(Config redissonClusterServersConfig) {
          return new RedissonConnectionFactory(redissonClusterServersConfig);
      }
  
      @Bean
      public Config redissonClusterServersConfig() {
          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 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

  Similarly, 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) x 150% = 300