SpringBoot集成Lettuce

前提条件

• 已成功申请Redis实例，且状态为“运行中”。
• 已创建弹性云服务器，创建弹性云服务器的方法，请参见《弹性云服务器用户指南》。
• 如果弹性云服务器为Linux系统，该弹性云服务器必须已经安装java编译环境。

操作步骤

1. 查看并获取待连接Redis实例的IP地址/域名和端口。

   具体步骤请参见查看实例信息。

2. 登录弹性云服务器。
3. 首先使用maven在pom.xml添加如下依赖。
   

   • SpringBoot从2.0起默认使用lettuce客户端进行连接。
   • 此次使用的版本：springboot：2.6.6，lettuce：6.1.8。

   <dependency>  
     <groupId>org.springframework.boot</groupId>  
     <artifactId>spring-boot-starter-web</artifactId>  
   </dependency>  
   <dependency>  
     <groupId>org.springframework.boot</groupId>  
     <artifactId>spring-boot-starter-data-redis</artifactId>  
   </dependency> 

4. 使用SpringBoot集成Lettuce连接实例。
   • Springboot+Lettuce单连方式连接Redis单机/主备/Proxy集群示例。
     1. 在application.properties配置文件中加上redis相关配置。

        spring.redis.host=host  
        spring.redis.database=0  
        spring.redis.password=pwd 
        spring.redis.port=port 

     2. Redis配置类RedisConfiguration。

        @Bean  
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {   
            RedisTemplate<String, Object> template = new RedisTemplate<>();  
            template.setConnectionFactory(lettuceConnectionFactory);  
            //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
            ObjectMapper mapper = new ObjectMapper();  
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
            mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
            jackson2JsonRedisSerializer.setObjectMapper(mapper);  
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
            //key采用String的序列化方式  
            template.setKeySerializer(stringRedisSerializer);  
            // hash的key也采用String的序列化方式  
            template.setHashKeySerializer(stringRedisSerializer);  
            // value序列化方式采用jackson  
            template.setValueSerializer(jackson2JsonRedisSerializer);  
            // hash的value序列化方式采用jackson  
            template.setHashValueSerializer(jackson2JsonRedisSerializer);  
            template.afterPropertiesSet();  
            return template;  
        }  

     3. Redis操作类RedisUtil。

         /** 
          * 普通缓存获取 
          * @param key 键 
          * @return 值 
          */  
         public Object get(String key){  
             return key==null?null:redisTemplate.opsForValue().get(key);  
         }  
        
         /** 
          * 普通缓存放入 
          * @param key 键 
          * @param value 值 
          * @return true成功 false失败 
          */  
         public boolean set(String key,Object value) {  
             try {  
                 redisTemplate.opsForValue().set(key, value);  
                 return true;  
             } catch (Exception e) {  
                 e.printStackTrace();  
                 return false;  
             }  
         }

     4. 编写controller类进行测试。

          @RestController  
        public class HelloRedis {  
            @Autowired  
            RedisUtil redisUtil;  
        
        
            @RequestMapping("/setParams")  
            @ResponseBody  
            public String setParams(String name) {  
        	        redisUtil.set("name", name);  
        	        return "success";  
        	    }  
        	
            @RequestMapping("/getParams")  
            @ResponseBody  
            public String getParams(String name) {  
        	System.out.println("--------------" + name + "-------------");  
        	String retName = redisUtil.get(name) + "";  
        	return retName;  
        	}  
        	
            }  

   • SpringBoot+Lettuce连接池方式连接Redis单机/主备/Proxy集群示例。
     1. 在以上maven依赖的基础上添加以下依赖。

        <dependency>  
          <groupId>org.apache.commons</groupId>  
          <artifactId>commons-pool2</artifactId>  
        </dependency> 

     2. 在application.properties配置文件中加上redis相关配置。

        spring.redis.host=host  
        spring.redis.database=0  
        spring.redis.password=pwd  
        spring.redis.port=port  
        # 连接超时时间  
        spring.redis.timeout=1000  
        # 连接池最大连接数（使用负值表示没有限制）  
        spring.redis.lettuce.pool.max-active=50  
        # 连接池中的最小空闲连接  
        spring.redis.lettuce.pool.min-idle=5  
        # 连接池中的最大空闲连接  
        spring.redis.lettuce.pool.max-idle=50  
        # 连接池最大阻塞等待时间（使用负值表示没有限制）  
        spring.redis.lettuce.pool.max-wait=5000  
        #eviction线程调度时间间隔  
        spring.redis.pool.time-between-eviction-runs-millis=2000  

     3. Redis连接配置类RedisConfiguration。

        @Bean  
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
            lettuceConnectionFactory.setShareNativeConnection(false);  
            RedisTemplate<String, Object> template = new RedisTemplate<>();  
            template.setConnectionFactory(lettuceConnectionFactory);  
            //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
            ObjectMapper mapper = new ObjectMapper();  
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
            mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
            jackson2JsonRedisSerializer.setObjectMapper(mapper);  
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
            //key采用String的序列化方式  
            template.setKeySerializer(stringRedisSerializer);  
            // hash的key也采用String的序列化方式  
            template.setHashKeySerializer(stringRedisSerializer);  
            // value序列化方式采用jackson  
            template.setValueSerializer(jackson2JsonRedisSerializer);  
            // hash的value序列化方式采用jackson  
            template.setHashValueSerializer(jackson2JsonRedisSerializer);  
            template.afterPropertiesSet();  
            return template;  
        }  

   • SpringBoot+Lettuce单连接方式连接Redis Cluster集群代码示例。
     1. 在application.properties配置文件中加上redis相关配置。

        spring.redis.cluster.nodes=host:port  
        spring.redis.cluster.max-redirects=3  
        spring.redis.password= pwd 
        # 自动刷新时间 
        spring.redis.lettuce.cluster.refresh.period=60
        # 开启自适应刷新  
        spring.redis.lettuce.cluster.refresh.adaptive=true  
        spring.redis.timeout=60

     2. Redis配置类RedisConfiguration，请务必开启集群自动刷新拓扑配置。

        @Bean  
        public LettuceConnectionFactory lettuceConnectionFactory() {  
             String[] nodes = clusterNodes.split(",");  
             List<RedisNode> listNodes = new ArrayList();  
             for (String node : nodes) {  
                 String[] ipAndPort = node.split(":");  
                 RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
                 listNodes.add(redisNode);  
             }  
             RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
             redisClusterConfiguration.setClusterNodes(listNodes);  
             redisClusterConfiguration.setPassword(password);  
             redisClusterConfiguration.setMaxRedirects(maxRedirects);  
              // 配置集群自动刷新拓扑 
             ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
                 .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
                 .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
                 .build();  
        
             ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
                 //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
                 .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
                 .topologyRefreshOptions(topologyRefreshOptions)  
                 .build();  
             LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
                     .commandTimeout(Duration.ofSeconds(timeout))   
                     .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
                     .clientOptions(clusterClientOptions)  
                     .build();  
             LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
             return factory;  
        }  
        
        @Bean  
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
            RedisTemplate<String, Object> template = new RedisTemplate<>();  
            template.setConnectionFactory(lettuceConnectionFactory);  
            //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
            ObjectMapper mapper = new ObjectMapper();  
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
            mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
            jackson2JsonRedisSerializer.setObjectMapper(mapper);  
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
            //key采用String的序列化方式  
            template.setKeySerializer(stringRedisSerializer);  
            // hash的key也采用String的序列化方式  
            template.setHashKeySerializer(stringRedisSerializer);  
            // value序列化方式采用jackson  
            template.setValueSerializer(jackson2JsonRedisSerializer);  
            // hash的value序列化方式采用jackson  
            template.setHashValueSerializer(jackson2JsonRedisSerializer);  
            template.afterPropertiesSet();  
            return template;  
        }  

   • springboot+lettuce连接池方式连接Redis Cluster集群代码示例。
     1. 在application.properties配置文件中加上Redis相关配置。

        spring.redis.cluster.nodes=host:port  
        spring.redis.cluster.max-redirects=3  
        spring.redis.password=pwd 
        spring.redis.lettuce.cluster.refresh.period=60  
        spring.redis.lettuce.cluster.refresh.adaptive=true  
        # 连接超时时间 
        spring.redis.timeout=60s   
        # 连接池最大连接数（使用负值表示没有限制）  
        spring.redis.lettuce.pool.max-active=50  
        # 连接池中的最小空闲连接  
        spring.redis.lettuce.pool.min-idle=5  
        # 连接池中的最大空闲连接  
        spring.redis.lettuce.pool.max-idle=50  
        # 连接池最大阻塞等待时间（使用负值表示没有限制）  
        spring.redis.lettuce.pool.max-wait=5000  
        #eviction线程调度时间间隔  
        spring.redis.lettuce.pool.time-between-eviction-runs=2000

     2. redis配置类RedisConfiguration，请务必开启集群自动刷新拓扑配置。

        @Bean  
         public LettuceConnectionFactory lettuceConnectionFactory() {  
             GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();  
             genericObjectPoolConfig.setMaxIdle(maxIdle);  
             genericObjectPoolConfig.setMinIdle(minIdle);  
             genericObjectPoolConfig.setMaxTotal(maxActive);  
             genericObjectPoolConfig.setMaxWait(Duration.ofMillis(maxWait));  
             genericObjectPoolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRunsMillis));  
             String[] nodes = clusterNodes.split(",");  
             List<RedisNode> listNodes = new ArrayList();  
             for (String node : nodes) {  
                 String[] ipAndPort = node.split(":");  
                 RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
                 listNodes.add(redisNode);  
             }  
             RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
             redisClusterConfiguration.setClusterNodes(listNodes);  
             redisClusterConfiguration.setPassword(password);  
             redisClusterConfiguration.setMaxRedirects(maxRedirects);  
              // 配置集群自动刷新拓扑 
             ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
                 .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
                 .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
                 .build();  
        
             ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
                 //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
                 .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
                 .topologyRefreshOptions(topologyRefreshOptions)  
                 .build();  
             LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
                     .commandTimeout(Duration.ofSeconds(timeout))  
                     .poolConfig(genericObjectPoolConfig)  
                     .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
                     .clientOptions(clusterClientOptions)  
                     .build();  
             LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
             return factory;  
         }  
        
        @Bean  
        public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
            lettuceConnectionFactory.setShareNativeConnection(false);  
            RedisTemplate<String, Object> template = new RedisTemplate<>();  
            template.setConnectionFactory(lettuceConnectionFactory);  
            //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
            ObjectMapper mapper = new ObjectMapper();  
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
            mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
            jackson2JsonRedisSerializer.setObjectMapper(mapper);  
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
            //key采用String的序列化方式  
            template.setKeySerializer(stringRedisSerializer);  
            // hash的key也采用String的序列化方式  
            template.setHashKeySerializer(stringRedisSerializer);  
            // value序列化方式采用jackson  
            template.setValueSerializer(jackson2JsonRedisSerializer);  
            // hash的value序列化方式采用jackson  
            template.setHashValueSerializer(jackson2JsonRedisSerializer);  
            template.afterPropertiesSet();  
            return template;  
        }  

   说明：host为Redis实例的IP地址/域名，port为Redis实例的端口，请按实际情况修改后执行，pwd为创建Redis实例时自定义的密码，请按实际情况修改后执行。推荐使用连接池方式。超时时间（TimeOut），最大连接数（MaxTotal），最小空闲连接（MinIdle），最大空闲连接（MaxIdle），最大等待时间（MaxWait）等相关参数，请根据业务实际来调优。