个人中心
gpt4 book ai didi

关于SpringBoot整合redis使用Lettuce客户端超时问题

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章关于SpringBoot整合redis使用Lettuce客户端超时问题由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

参考的博客 。

问题起因

做毕设的时候，使用到Lettuce连接redis，一段时间后不操作，再去操作redis，会报连接超时错误，在其重连后又可使用.

原因是：Lettuce 自适应拓扑刷新（Adaptive updates）与定时拓扑刷新（Periodic updates） 是默认关闭的导致问题的出现 。

解决的方案

1、重写连接工厂实例，更改其LettuceClientConfiguration 为开启拓扑更新 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
@Configuration
public class RedisConfig {
 
 
     @Autowired
     private RedisProperties redisProperties;
 
     //这是固定的模板
     //自己定义了一个RedisTemplate
     @Bean
     @SuppressWarnings ( "all" )
     public RedisTemplate<String, Object> redisTemplate( @Qualifier ( "lettuceConnectionFactoryUvPv" ) RedisConnectionFactory factory) {
         RedisTemplate<String, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(factory);
 
         //Json序列化配置
         Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object. class );
         ObjectMapper om = new ObjectMapper();
         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
         om.activateDefaultTyping(om.getPolymorphicTypeValidator());
         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
         //解决序列化问题
         om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false );
         jackson2JsonRedisSerializer.setObjectMapper(om);
 
         //String的序列化
         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;
     }
 
     /**
      * 为RedisTemplate配置Redis连接工厂实现
      * LettuceConnectionFactory实现了RedisConnectionFactory接口
      * UVPV用Redis
      *
      * @return 返回LettuceConnectionFactory
      */
     @Bean (destroyMethod = "destroy" )
     //这里要注意的是，在构建LettuceConnectionFactory 时，如果不使用内置的destroyMethod，可能会导致Redis连接早于其它Bean被销毁
     public LettuceConnectionFactory lettuceConnectionFactoryUvPv() throws Exception {
 
         List<String> clusterNodes = redisProperties.getCluster().getNodes();
         Set<RedisNode> nodes = new HashSet<>();
         clusterNodes.forEach(address -> nodes.add( new RedisNode(address.split( ":" )[ 0 ].trim(), Integer.parseInt(address.split( ":" )[ 1 ]))));
         RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration();
         clusterConfiguration.setClusterNodes(nodes);
         clusterConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword()));
         clusterConfiguration.setMaxRedirects(redisProperties.getCluster().getMaxRedirects());
 
 
         RedisStandaloneConfiguration  redisStandaloneConfiguration= new RedisStandaloneConfiguration();
         redisStandaloneConfiguration.setHostName(redisProperties.getHost());
         redisStandaloneConfiguration.setPassword(redisProperties.getPassword());
         redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase());
         redisStandaloneConfiguration.setPort(redisProperties.getPort());
 
         GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
         poolConfig.setMaxIdle(redisProperties.getLettuce().getPool().getMaxIdle());
         poolConfig.setMinIdle(redisProperties.getLettuce().getPool().getMinIdle());
         poolConfig.setMaxTotal(redisProperties.getLettuce().getPool().getMaxActive());
 
         return new LettuceConnectionFactory(redisStandaloneConfiguration, getLettuceClientConfiguration(poolConfig));
     }
 
     /**
      * 配置LettuceClientConfiguration 包括线程池配置和安全项配置
      *
      * @param genericObjectPoolConfig common-pool2线程池
      * @return lettuceClientConfiguration
      */
     private LettuceClientConfiguration getLettuceClientConfiguration(GenericObjectPoolConfig genericObjectPoolConfig) {
         /*
         ClusterTopologyRefreshOptions配置用于开启自适应刷新和定时刷新。如自适应刷新不开启，Redis集群变更时将会导致连接异常！
          */
         ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                 //开启自适应刷新
                 //.enableAdaptiveRefreshTrigger(ClusterTopologyRefreshOptions.RefreshTrigger.MOVED_REDIRECT, ClusterTopologyRefreshOptions.RefreshTrigger.PERSISTENT_RECONNECTS)
                 //开启所有自适应刷新，MOVED，ASK，PERSISTENT都会触发
                 .enableAllAdaptiveRefreshTriggers()
                 // 自适应刷新超时时间(默认30秒)
                 .adaptiveRefreshTriggersTimeout(Duration.ofSeconds( 25 )) //默认关闭开启后时间为30秒
                 // 开周期刷新
                 .enablePeriodicRefresh(Duration.ofSeconds( 20 ))  // 默认关闭开启后时间为60秒 ClusterTopologyRefreshOptions.DEFAULT_REFRESH_PERIOD 60  .enablePeriodicRefresh(Duration.ofSeconds(2)) = .enablePeriodicRefresh().refreshPeriod(Duration.ofSeconds(2))
                 .build();
         return LettucePoolingClientConfiguration.builder()
                 .poolConfig(genericObjectPoolConfig)
                 .clientOptions(ClusterClientOptions.builder().topologyRefreshOptions(topologyRefreshOptions).build())
                 //将appID传入连接，方便Redis监控中查看
                 //.clientName(appName + "_lettuce")
                 .build();
     }
 
}

2、SpringBoot2.3.x后，可使用配置文件中开启lettuce的拓扑刷新 。

?
1
2
3
4
5
6
7
8
9
10
11
lettuce:
       pool:
         max-active: 20
         max-wait: -1ms
         max-idle: 10
         min-idle: 2
       cluster:
         refresh:
           adaptive: true
           # 20 秒自动刷新一次
           period: 20

3、更改连接redis的连接方式，使用jedis连接 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
             <exclusions>
                 <exclusion>
                     <groupId>io.lettuce</groupId>
                     <artifactId>lettuce-core</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
        
         <dependency>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
         </dependency>
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
spring:
   redis:
     jedis:
       pool:
         max-active: ${redis.config.maxTotal: 1024 }
         max-idle: ${redis.config.maxIdle: 50 }
         min-idle: ${redis.config.minIdle: 1 }
         max-wait: ${redis.config.maxWaitMillis: 5000 }
     #lettuce:
       #pool:
         #max-active: ${redis.config.maxTotal: 1024 }
         #max-idle: ${redis.config.maxIdle: 50 }
         #min-idle: ${redis.config.minIdle: 1 }
         #max-wait: ${redis.config.maxWaitMillis: 5000 }

到此这篇关于SpringBoot整合redis使用Lettuce客户端超时问题的文章就介绍到这了,更多相关SpringBoot整合redis内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://www.cnblogs.com/shouyaya/p/14607270.html 。

最后此篇关于关于SpringBoot整合redis使用Lettuce客户端超时问题的文章就讲到这里了,如果你想了解更多关于关于SpringBoot整合redis使用Lettuce客户端超时问题的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： Python 利用flask搭建一个共享服务器的步骤
文章推荐： 浅谈Android开发中ListView控件性能的一些优化方法
文章推荐： 快速解决pymongo操作mongodb的时区问题
文章推荐： Android getSystemService用法实例总结
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com