SpringBoot集成Lettuce连接Redis方法和案例

àì夳堔傛蜴生んèń 2024-05-08 07:19 188阅读 0赞

首先使用maven在pom.xml添加如下依赖

说明：

  • SpringBoot从2.0起默认使用lettuce客户端进行连接。

  • 此次使用的版本：springboot：2.6.6，lettuce：6.1.8。


    org.springframework.boot
    spring-boot-starter-web


    org.springframework.boot
    spring-boot-starter-data-redis

使用SpringBoot集成Lettuce连接实例

  • Springboot+Lettuce单连方式连接Redis单机/主备/Proxy集群示例。

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

  1. spring.redis.host=host  
  2. spring.redis.database=0  
  3. spring.redis.password=pwd 
  4. spring.redis.port=port

2、Redis配置类RedisConfiguration。

  1. @Bean  
  2. public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {   
  3.     RedisTemplate<String, Object> template = new RedisTemplate<>();  
  4.     template.setConnectionFactory(lettuceConnectionFactory);  
  5.     //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
  6.     Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
  7.     ObjectMapper mapper = new ObjectMapper();  
  8.     mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
  9.     mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
  10.         ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
  11.     jackson2JsonRedisSerializer.setObjectMapper(mapper);  
  12.     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
  13.     //key采用String的序列化方式  
  14.     template.setKeySerializer(stringRedisSerializer);  
  15.     // hash的key也采用String的序列化方式  
  16.     template.setHashKeySerializer(stringRedisSerializer);  
  17.     // value序列化方式采用jackson  
  18.     template.setValueSerializer(jackson2JsonRedisSerializer);  
  19.     // hash的value序列化方式采用jackson  
  20.     template.setHashValueSerializer(jackson2JsonRedisSerializer);  
  21.     template.afterPropertiesSet();  
  22.     return template;  
  23. }

3、Redis操作类RedisUtil。

  1. /** 
  2.   * 普通缓存获取 
  3.   * @param key 键 
  4.   * @return 值 
  5.   */  
  6.  public Object get(String key){  
  7.      return key==null?null:redisTemplate.opsForValue().get(key);  
  8.  }  
  10.  /** 
  11.   * 普通缓存放入 
  12.   * @param key 键 
  13.   * @param value 值 
  14.   * @return true成功 false失败 
  15.   */  
  16.  public boolean set(String key,Object value) {  
  17.      try {  
  18.          redisTemplate.opsForValue().set(key, value);  
  19.          return true;  
  20.      } catch (Exception e) {  
  21.          e.printStackTrace();  
  22.          return false;  
  23.      }  
  24.  }

4、编写controller类进行测试。

  1. @RestController  
  2. public class HelloRedis {  
  3.     @Autowired  
  4.     RedisUtil redisUtil;  
  7.     @RequestMapping("/setParams")  
  8.     @ResponseBody  
  9.     public String setParams(String name) {  
  10.         redisUtil.set("name", name);  
  11.         return "success";  
  12.     }  
  14.     @RequestMapping("/getParams")  
  15.     @ResponseBody  
  16.     public String getParams(String name) {  
  17.        System.out.println("--------------" + name + "-------------");  
  18.        String retName = redisUtil.get(name) + "";  
  19.        return retName;  
  20.     }  
  22. }

  • SpringBoot+Lettuce连接池方式连接Redis单机/主备/Proxy集群示例。

    1、在上边maven依赖的基础上添加以下依赖。


    org.apache.commons
    commons-pool2

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

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

这里最后的这个配置：spring.redis.pool.time-between-eviction-runs-millis=2000 在某些版本中会不生效，需要自己DEBUG看一下

  1. LettuceConnectionFactory

实例里边有没设置成功，如果没有则调整成如下配置：

spring.redis.lettuce.pool.time-between-eviction-runs=2000

3、Redis连接配置类RedisConfiguration。

  1. @Bean  
  2. public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
  3.     lettuceConnectionFactory.setShareNativeConnection(false);  
  4.     RedisTemplate<String, Object> template = new RedisTemplate<>();  
  5.     template.setConnectionFactory(lettuceConnectionFactory);  
  6.     //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
  7.     Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
  8.     ObjectMapper mapper = new ObjectMapper();  
  9.     mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
  10.     mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
  11.         ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
  12.     jackson2JsonRedisSerializer.setObjectMapper(mapper);  
  13.     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
  14.     //key采用String的序列化方式  
  15.     template.setKeySerializer(stringRedisSerializer);  
  16.     // hash的key也采用String的序列化方式  
  17.     template.setHashKeySerializer(stringRedisSerializer);  
  18.     // value序列化方式采用jackson  
  19.     template.setValueSerializer(jackson2JsonRedisSerializer);  
  20.     // hash的value序列化方式采用jackson  
  21.     template.setHashValueSerializer(jackson2JsonRedisSerializer);  
  22.     template.afterPropertiesSet();  
  23.     return template;  
  24. }

SpringBoot+Lettuce单连接方式连接Redis Cluster集群代码示例。

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

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

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

  1. @Bean  
  2. public LettuceConnectionFactory lettuceConnectionFactory() {  
  3.      String[] nodes = clusterNodes.split(",");  
  4.      List<RedisNode> listNodes = new ArrayList();  
  5.      for (String node : nodes) {  
  6.          String[] ipAndPort = node.split(":");  
  7.          RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
  8.          listNodes.add(redisNode);  
  9.      }  
  10.      RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
  11.      redisClusterConfiguration.setClusterNodes(listNodes);  
  12.      redisClusterConfiguration.setPassword(password);  
  13.      redisClusterConfiguration.setMaxRedirects(maxRedirects);  
  14.       // 配置集群自动刷新拓扑 
  15.      ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
  16.          .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
  17.          .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
  18.          .build();  
  20.      ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
  21.          //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
  22.          .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
  23.          .topologyRefreshOptions(topologyRefreshOptions)  
  24.          .build();  
  25.      LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
  26.              .commandTimeout(Duration.ofSeconds(timeout))   
  27.              .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
  28.              .clientOptions(clusterClientOptions)  
  29.              .build();  
  30.      LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
  31.      return factory;  
  32. }  
  34. @Bean  
  35. public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
  36.     RedisTemplate<String, Object> template = new RedisTemplate<>();  
  37.     template.setConnectionFactory(lettuceConnectionFactory);  
  38.     //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
  39.     Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
  40.     ObjectMapper mapper = new ObjectMapper();  
  41.     mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
  42.     mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
  43.         ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
  44.     jackson2JsonRedisSerializer.setObjectMapper(mapper);  
  45.     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
  46.     //key采用String的序列化方式  
  47.     template.setKeySerializer(stringRedisSerializer);  
  48.     // hash的key也采用String的序列化方式  
  49.     template.setHashKeySerializer(stringRedisSerializer);  
  50.     // value序列化方式采用jackson  
  51.     template.setValueSerializer(jackson2JsonRedisSerializer);  
  52.     // hash的value序列化方式采用jackson  
  53.     template.setHashValueSerializer(jackson2JsonRedisSerializer);  
  54.     template.afterPropertiesSet();  
  55.     return template;  
  56. }

springboot+lettuce连接池方式连接Redis Cluster集群代码示例。

1、在application.properties配置文件中加上Redis相关配置。

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

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

  1. @Bean  
  2.  public LettuceConnectionFactory lettuceConnectionFactory() {  
  3.      GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();  
  4.      genericObjectPoolConfig.setMaxIdle(maxIdle);  
  5.      genericObjectPoolConfig.setMinIdle(minIdle);  
  6.      genericObjectPoolConfig.setMaxTotal(maxActive);  
  7.      genericObjectPoolConfig.setMaxWait(Duration.ofMillis(maxWait));  
  8.      genericObjectPoolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRunsMillis));  
  9.      String[] nodes = clusterNodes.split(",");  
  10.      List<RedisNode> listNodes = new ArrayList();  
  11.      for (String node : nodes) {  
  12.          String[] ipAndPort = node.split(":");  
  13.          RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
  14.          listNodes.add(redisNode);  
  15.      }  
  16.      RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
  17.      redisClusterConfiguration.setClusterNodes(listNodes);  
  18.      redisClusterConfiguration.setPassword(password);  
  19.      redisClusterConfiguration.setMaxRedirects(maxRedirects);  
  20.       // 配置集群自动刷新拓扑 
  21.      ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
  22.          .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
  23.          .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
  24.          .build();  
  26.      ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
  27.          //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
  28.          .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
  29.          .topologyRefreshOptions(topologyRefreshOptions)  
  30.          .build();  
  31.      LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
  32.              .commandTimeout(Duration.ofSeconds(timeout))  
  33.              .poolConfig(genericObjectPoolConfig)  
  34.              .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
  35.              .clientOptions(clusterClientOptions)  
  36.              .build();  
  37.      LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
  38.      return factory;  
  39.  }  
  41. @Bean  
  42. public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
  43.     lettuceConnectionFactory.setShareNativeConnection(false);  
  44.     RedisTemplate<String, Object> template = new RedisTemplate<>();  
  45.     template.setConnectionFactory(lettuceConnectionFactory);  
  46.     //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
  47.     Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
  48.     ObjectMapper mapper = new ObjectMapper();  
  49.     mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
  50.     mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
  51.         ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
  52.     jackson2JsonRedisSerializer.setObjectMapper(mapper);  
  53.     StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
  54.     //key采用String的序列化方式  
  55.     template.setKeySerializer(stringRedisSerializer);  
  56.     // hash的key也采用String的序列化方式  
  57.     template.setHashKeySerializer(stringRedisSerializer);  
  58.     // value序列化方式采用jackson  
  59.     template.setValueSerializer(jackson2JsonRedisSerializer);  
  60.     // hash的value序列化方式采用jackson  
  61.     template.setHashValueSerializer(jackson2JsonRedisSerializer);  
  62.     template.afterPropertiesSet();  
  63.     return template;  
  64. }

推荐使用连接池方式。

发表评论

表情：
评论列表 （有 0 条评论，188人围观）

还没有评论，来说两句吧...

相关阅读