客户端程序连接教程

本示例使用Maven方式进行构建，您也可以手动下载Jedis客户端。

1. 打开编译器，新建项目。

2. 添加下述pom文件。

   本示例的Jedis版本为4.3.0。

   <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>4.3.0</version>
   </dependency>

3. 在编辑器中输入下述代码，然后根据注释提示修改代码。

   import redis.clients.jedis.Jedis;
   import redis.clients.jedis.JedisPool;
   import redis.clients.jedis.JedisPoolConfig;
   
   public class JedisExample {
       public static void main(String[] args) {
           JedisPoolConfig config = new JedisPoolConfig();
           // 最大空闲连接数，需自行评估，不超过Redis实例的最大连接数。
           config.setMaxIdle(200);
           // 最大连接数，需自行评估，不超过Redis实例的最大连接数。
           config.setMaxTotal(300);
           config.setTestOnBorrow(false);
           config.setTestOnReturn(false);
           // 分别将host和password的值替换为实例的连接地址、密码。
           String host = "r-bp1s1bt2tlq3p1****pd.redis.rds.aliyuncs.com";
           String password = "r-bp1s1bt2tlq3p1****:Database123";
           JedisPool pool = new JedisPool(config, host, 6379, 3000, password);
           Jedis jedis = null;
           try {
               jedis = pool.getResource();
               // 执行相关操作，示例如下。
               jedis.set("foo10", "bar");
               System.out.println(jedis.get("foo10"));
               jedis.zadd("sose", 0, "car");
               jedis.zadd("sose", 0, "bike");
               System.out.println(jedis.zrange("sose", 0, -1));
           }
           catch (Exception e) {
               // 超时或其他异常处理。
               e.printStackTrace();
           }
           finally {
               if (jedis != null) {
                   jedis.close();
               }
           }
           pool.destroy();    // 当应用退出，需销毁资源时，调用此方法。此方法会断开连接、释放资源。
       }
   }

4. 运行上述Project，预期会返回如下结果：

   bar
   [bike, car]

   重要

   在使用Jedis的过程中，如果设置了一些不合理的参数或错误使用某些功能可能会引起报错，关于如何排查，请参见常见报错。

本示例使用Maven方式进行构建，您也可以手动下载Lettuce或Jedis客户端。

1. 打开编译器，新建项目。

2. 添加下述pom文件，并下载Lettuce或Jedis。若使用Lettuce，不建议使用Lettuce 6.3.0以下的版本。

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.4.2</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <groupId>com.aliyun.tair</groupId>
       <artifactId>spring-boot-example</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>spring-boot-example</name>
       <description>Demo project for Spring Boot</description>
       <properties>
           <java.version>1.8</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>
           <dependency>
               <groupId>redis.clients</groupId>
               <artifactId>jedis</artifactId>
           </dependency>
           <dependency>
               <groupId>io.lettuce</groupId>
               <artifactId>lettuce-core</artifactId>
               <version>6.3.0.RELEASE</version>
           </dependency>
           <dependency>
               <groupId>io.netty</groupId>
               <artifactId>netty-transport-native-epoll</artifactId>
               <version>4.1.100.Final</version>
               <classifier>linux-x86_64</classifier>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
   </project>

3. 在Spring Data Redis编辑器中输入下述代码，然后根据注释提示修改代码。

   本示例的Spring Data Redis版本为2.4.2。

   • Spring Data Redis With Jedis

     @Bean
          JedisConnectionFactory redisConnectionFactory() {
              RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("host", port);
      
              JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
              // 最大连接数, 根据业务需要设置，不能超过实例规格规定的最大连接数。
              jedisPoolConfig.setMaxTotal(30);
              // 最大空闲连接数, 根据业务需要设置，不能超过实例规格规定的最大连接数。
              jedisPoolConfig.setMaxIdle(20);
              // 关闭 testOn[Borrow|Return]，防止产生额外的PING。
              jedisPoolConfig.setTestOnBorrow(false);
              jedisPoolConfig.setTestOnReturn(false);
      
              JedisClientConfiguration jedisClientConfiguration = JedisClientConfiguration.builder().usePooling().poolConfig(
                  jedisPoolConfig).build();
      
              return new JedisConnectionFactory(config, jedisClientConfiguration);
          }

   • Spring Data Redis With Lettuce 

     @Configuration
     public class BeanConfig {
         /**
          *  TCP_KEEPALIVE打开，并且配置三个参数分别为:
          *  TCP_KEEPIDLE = 30
          *  TCP_KEEPINTVL = 10
          *  TCP_KEEPCNT = 3
          */
         private static final int TCP_KEEPALIVE_IDLE = 30;
     
         /**
          * TCP_USER_TIMEOUT参数可以避免在故障宕机场景下，Lettuce持续超时的问题。
          * refer: https://github.com/lettuce-io/lettuce-core/issues/2082
          */
         private static final int TCP_USER_TIMEOUT = 30;
     
         @Bean
         LettuceConnectionFactory redisConnectionFactory() {
             RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
             config.setHostName("r-bp1y4is8svonly****pd.redis.rds.aliyuncs.com");
             config.setPort(6379);
             config.setUsername("r-bp1y4is8svonly****");
             config.setPassword("Da****3");
     
             // Config TCP KeepAlive
             SocketOptions socketOptions = SocketOptions.builder()
                 .keepAlive(KeepAliveOptions.builder()
                     .enable()
                     .idle(Duration.ofSeconds(TCP_KEEPALIVE_IDLE))
                     .interval(Duration.ofSeconds(TCP_KEEPALIVE_IDLE / 3))
                     .count(3)
                     .build())
                 .tcpUserTimeout(TcpUserTimeoutOptions.builder()
                     .enable()
                     .tcpUserTimeout(Duration.ofSeconds(TCP_USER_TIMEOUT))
                     .build())
                 .build();
             LettuceClientConfiguration lettuceClientConfiguration = LettuceClientConfiguration.builder().clientOptions(
                 ClientOptions.builder().socketOptions(socketOptions).build()).build();
             return new LettuceConnectionFactory(config, lettuceClientConfiguration);
         }
     
         @Bean
         RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
             RedisTemplate<String, Object> template = new RedisTemplate<>();
             template.setConnectionFactory(connectionFactory);
             return template;
         }
     }

4. 执行上述代码。

本示例使用Maven方式进行构建，您也可以手动下载Lettuce客户端。

1. 打开编译器，新建项目。

2. 添加下述pom文件，并下载Lettuce 6.3.0，不建议使用Lettuce 6.3.0以下的版本。

   本示例的Lettuce版本为6.3.0。

   <<dependencies>
       <dependency>
           <groupId>io.lettuce</groupId>
           <artifactId>lettuce-core</artifactId>
           <version>6.3.0.RELEASE</version>
       </dependency>
       <dependency>
           <groupId>io.netty</groupId>
           <artifactId>netty-transport-native-epoll</artifactId>
           <version>4.1.100.Final</version>
           <classifier>linux-x86_64</classifier>
       </dependency>
   </dependencies>

3. 在编辑器中输入下述代码，然后根据注释提示修改代码。

   import io.lettuce.core.ClientOptions;
   import io.lettuce.core.RedisClient;
   import io.lettuce.core.RedisURI;
   import io.lettuce.core.SocketOptions;
   import io.lettuce.core.SocketOptions.KeepAliveOptions;
   import io.lettuce.core.SocketOptions.TcpUserTimeoutOptions;
   import io.lettuce.core.api.StatefulRedisConnection;
   import io.lettuce.core.api.sync.RedisCommands;
   import java.time.Duration;
   
   public class LettuceExample {
       /**
        *  TCP_KEEPALIVE打开，并且配置三个参数分别为:
        *  TCP_KEEPIDLE = 30
        *  TCP_KEEPINTVL = 10
        *  TCP_KEEPCNT = 3
        */
       private static final int TCP_KEEPALIVE_IDLE = 30;
   
       /**
        * TCP_USER_TIMEOUT参数可以避免在故障宕机场景下，Lettuce持续超时的问题。
        * refer: https://github.com/lettuce-io/lettuce-core/issues/2082
        */
       private static final int TCP_USER_TIMEOUT = 30;
   
       private static RedisClient client = null;
       private static StatefulRedisConnection<String, String> connection = null;
   
       public static void main(String[] args) {
           // 分别将host、user、password和port的值替换为实际的实例信息。
           String host = "r-bp1s1bt2tlq3p1****.redis.rds.aliyuncs.com";
           String user = "r-bp1s1bt2tlq3p1****";
           String password = "Da****3";
           int port = 6379;
   
           // Config RedisURL
           RedisURI uri = RedisURI.Builder
                   .redis(host, port)
                   .withAuthentication(user, password)
                   .build();
   
           // Config TCP KeepAlive
           SocketOptions socketOptions = SocketOptions.builder()
                   .keepAlive(KeepAliveOptions.builder()
                           .enable()
                           .idle(Duration.ofSeconds(TCP_KEEPALIVE_IDLE))
                           .interval(Duration.ofSeconds(TCP_KEEPALIVE_IDLE/3))
                           .count(3)
                           .build())
                   .tcpUserTimeout(TcpUserTimeoutOptions.builder()
                           .enable()
                           .tcpUserTimeout(Duration.ofSeconds(TCP_USER_TIMEOUT))
                           .build())
                   .build();
   
           client = RedisClient.create(uri);
           client.setOptions(ClientOptions.builder()
                   .socketOptions(socketOptions)
                   .build());
           connection = client.connect();
           RedisCommands<String, String> commands = connection.sync();
   
           System.out.println(commands.set("foo", "bar"));
           System.out.println(commands.get("foo"));
   
           // 当应用退出，需销毁资源时，调用此方法。此方法会断开连接、释放资源。
           connection.close();
           client.shutdown();
       }
   }

4. 执行上述代码，预期会返回如下结果：

   OK
   bar