Springboot2.x集成lettuce鏈接redis集羣報超時異常Command timed out after 6 second(s)

文/朱季謙

背景：最近在對一新開發Springboot系統作壓測，發現剛開始壓測時，能夠正常對redis集羣進行數據存取，可是暫停幾分鐘後，接着繼續用jmeter進行壓測時，發現redis就開始忽然瘋狂爆出異常提示：Command timed out after 6 second(s)......

 1 Caused by: io.lettuce.core.RedisCommandTimeoutException: Command timed out after 6 second(s)
 2     at io.lettuce.core.ExceptionFactory.createTimeoutException(ExceptionFactory.java:51)
 3     at io.lettuce.core.LettuceFutures.awaitOrCancel(LettuceFutures.java:114)
 4     at io.lettuce.core.cluster.ClusterFutureSyncInvocationHandler.handleInvocation(ClusterFutureSyncInvocationHandler.java:123)
 5     at io.lettuce.core.internal.AbstractInvocationHandler.invoke(AbstractInvocationHandler.java:80)
 6     at com.sun.proxy.$Proxy134.mget(Unknown Source)
 7     at org.springframework.data.redis.connection.lettuce.LettuceStringCommands.mGet(LettuceStringCommands.java:119)
 8     ... 15 common frames omitted

我急忙檢查redis集羣，發現集羣裏的各節點都一切正常，且cpu和內存使用率還不到百分之二十，看着這一切，我忽然陷入漫長的沉思，究竟是哪裏出現問題......百度一番，發現很多人都出現過相似狀況的，有人說把超時timeout設置更大一些就能夠解決了。我按照這樣的解決方法，把超時timeout的值設置到更大後，依然沒有解決該超時問題。

其中，springboot操做redis的依賴包是——

 1 <dependency>
 2     <groupId>org.springframework.boot</groupId>
 3     <artifactId>spring-boot-starter-data-redis</artifactId>
 4 </dependency>

集羣配置——

 1 redis:
 2   timeout: 6000ms
 3   cluster:
 4     nodes:
 5       - xxx.xxx.x.xxx:6379
 6       - xxx.xxx.x.xxx:6379
 7       - xxx.xxx.x.xxx:6379
 8   jedis:
 9     pool:
 10       max-active: 1000
 11       max-idle: 10
 12       min-idle: 5
 13       max-wait: -1

點進spring-boot-starter-data-redis進去，發現裏面包含了lettuce的依賴：

 

看到一些網友說，springboot1.x默認使用的是jedis，到了Springboot2.x就默認使用了lettuce。咱們能夠簡單驗證一下，在redis驅動加載配置類裏，輸出一下RedisConnectionFactory信息：

 1 @Configuration
 2 @AutoConfigureAfter(RedisAutoConfiguration.class)
 3 public class Configuration {
 4     @Bean
 5     public StringRedisTemplate redisTemplate(RedisConnectionFactory factory) {
 6         log.info("測試打印驅動類型:"+factory);
 7 }

打印輸出——

測試打印驅動類型:org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory@74ee761e

可見，這裏使用正是是lettuce驅動鏈接，所以，當把它換成之前用的比較多的jedis驅動鏈接時，就沒有再出現這個Command timed out after 6 second(s)問題了。

 1 <dependency>
 2     <groupId>org.springframework.boot</groupId>
 3     <artifactId>spring-boot-starter-data-redis</artifactId>
 4     <exclusions>
 5         <exclusion>
 6             <groupId>io.lettuce</groupId>
 7             <artifactId>lettuce-core</artifactId>
 8         </exclusion>
 9     </exclusions>
 10 </dependency>
 11 <dependency>
 12     <groupId>redis.clients</groupId>
 13     <artifactId>jedis</artifactId>
 14 </dependency>

那麼問題來了，Springboot2.x是如何默認使用了lettuce，這得去研究下里面的部分代碼。咱們能夠可進入到Springboot2.x自動裝配模塊的redis部分，其中有一個RedisAutoConfiguration類，其主要做用是對Springboot自動配置鏈接redis類：

 1 @Configuration(
 2     proxyBeanMethods = false
 3 )
 4 @ConditionalOnClass({RedisOperations.class})
 5 @EnableConfigurationProperties({RedisProperties.class})
 6 @Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
 7 public class RedisAutoConfiguration {
 8     public RedisAutoConfiguration() {
 9    }
 10    ......省略
 11 }

這裏只須要關注裏面的一行註解：

 1 
 2 @Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
 3 

這就意味着使用spring-boot-starter-data-redis依賴時，可自動導入lettuce和jedis兩種驅動，按理來講，不會同時存在兩種驅動，這樣沒有太大意義，所以，這裏的前後順序就很重要了，爲何這麼說呢？

分別進入到LettuceConnectionConfiguration.class與JedisConnectionConfiguration.class當中，各自展現本文須要涉及到的核心代碼：

 1 //LettuceConnectionConfiguration
 2 @ConditionalOnClass({RedisClient.class})
 3 class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
 4    ......省略
 5     @Bean
 6     @ConditionalOnMissingBean({RedisConnectionFactory.class})
 7     LettuceConnectionFactory redisConnectionFactory(ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers, ClientResources clientResources) throws UnknownHostException {
 8         LettuceClientConfiguration clientConfig = this.getLettuceClientConfiguration(builderCustomizers, clientResources, this.getProperties().getLettuce().getPool());
 9         return this.createLettuceConnectionFactory(clientConfig);
 10    }
 11 }
 12 //JedisConnectionConfiguration
 13 @ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
 14 class JedisConnectionConfiguration extends RedisConnectionConfiguration {
 15    ......省略
 16     @Bean
 17     @ConditionalOnMissingBean({RedisConnectionFactory.class})
 18     JedisConnectionFactory redisConnectionFactory(ObjectProvider<JedisClientConfigurationBuilderCustomizer> builderCustomizers) throws UnknownHostException {
 19         return this.createJedisConnectionFactory(builderCustomizers);
 20    }
 21 }
 22 

可見，LettuceConnectionConfiguration.class與JedisConnectionConfiguration.class當中都有一個相同的註解 @ConditionalOnMissingBean({RedisConnectionFactory.class})，這是說，假如RedisConnectionFactory這個bean已經被註冊到容器裏，那麼與它類似的其餘Bean就不會再被加載註冊，簡單點說，對LettuceConnectionConfiguration與JedisConnectionConfiguration各自加上 @ConditionalOnMissingBean({RedisConnectionFactory.class})註解，二者當中只能加載註冊其中一個到容器裏，另一個就不會再進行加載註冊。

那麼，問題就來了，誰會先被註冊呢？

這就回到了上面提到的一句，@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})這一句裏的前後順序很關鍵，LettuceConnectionConfiguration在前面，就意味着，LettuceConnectionConfiguration將會被註冊。

可見，Springboot默認是使用lettuce來鏈接redis的。

當咱們引入spring-boot-starter-data-redis依賴包時，其實就至關於引入lettuce包，這時就會使用lettuce驅動，若不想使用該默認的lettuce驅動，直接將lettuce依賴排除便可。

 1 <dependency>
 2     <groupId>org.springframework.boot</groupId>
 3     <artifactId>spring-boot-starter-data-redis</artifactId>
 4     <exclusions>
 5         <exclusion>
 6             <groupId>io.lettuce</groupId>
 7             <artifactId>lettuce-core</artifactId>
 8         </exclusion>
 9     </exclusions>
 10 </dependency>

而後再引入jedis依賴——

 1 <dependency>
 2     <groupId>redis.clients</groupId>
 3     <artifactId>jedis</artifactId>
 4 </dependency>

這樣，在進行RedisAutoConfiguration的導入註解時，由於沒有找到lettuce依賴，故而這注解@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})的第二個位置上的JedisConnectionConfiguration就有效了，就能夠被註冊到容器了，當作springboot操做redis的驅動。

lettuce與jedis二者有什麼區別呢？

lettuce：底層是用netty實現，線程安全，默認只有一個實例。

jedis：可直連redis服務端，配合鏈接池使用，可增長物理鏈接。

根據異常提示找到出現錯誤的方法，在下列代碼裏的LettuceConverters.toBoolean(this.getConnection().zadd(key, score, value))——

 1 public Boolean zAdd(byte[] key, double score, byte[] value) {
 2     Assert.notNull(key, "Key must not be null!");
 3     Assert.notNull(value, "Value must not be null!");
 4 ​
 5     try {
 6         if (this.isPipelined()) {
 7             this.pipeline(this.connection.newLettuceResult(this.getAsyncConnection().zadd(key, score, value), LettuceConverters.longToBoolean()));
 8             return null;
 9        } else if (this.isQueueing()) {
 10             this.transaction(this.connection.newLettuceResult(this.getAsyncConnection().zadd(key, score, value), LettuceConverters.longToBoolean()));
 11             return null;
 12        } else {
 13             return LettuceConverters.toBoolean(this.getConnection().zadd(key, score, value));
 14        }
 15    } catch (Exception var6) {
 16         throw this.convertLettuceAccessException(var6);
 17    }
 18 }

LettuceConverters.toBoolean（）是將long轉爲Boolean，正常狀況下，this.getConnection().zadd(key, score, value)若是新增成功話，那麼返回1，這樣LettuceConverters.toBoolean(1)獲得的是true，反之，若是新增失敗，則返回0，即LettuceConverters.toBoolean(0)，還有第三種狀況，就是這個this.getConnection().zadd(key, score, value)方法出現異常，什麼狀況下會出現異常呢？

應該是，connection鏈接失敗的時候。

這就意味着，以lettuce驅動鏈接redis的過程中，會出現鏈接斷開的狀況，致使沒法新增成功，超過必定時間尚未正常，就會出現鏈接超時的狀況。

至因而什麼緣由致使的斷開鏈接，暫時尚未比較好思路，暫且把這個問題留着，等慢慢研究看是否能找到問題所在，如有大神指點，也感激涕零。