redis cluster环境下jedis expireAt命令bug探究

关注

原创最新推荐文章于 2026-06-14 12:12:12 发布 821 阅读 AI 写同款· GEO 优化 ›

redis集群客户端JedisCluster优化 - 管道(pipeline)模式支持 redis集群客户端JedisCluster优化 - 管道(pipeline)模式支持Redis在3.0版正式引入了集群这个特性，扩展变得非常简单。然而当你开心的升级到3.0后，却发现有些很好用的功能现在工作不了了，比如我们今天要聊的pipeline功能。我们知道，普通的情况下，redis client与server之间采用的是请求应答的模式，即： Client: command1 阅读详情

面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>>

背景

我们最近在使用spring-data-redis进行redis cluster模式测试时，发现jedis在进行expiredAt命令调用时有bug，最终调用的是pexpire命令，这个bug会导致key过期时间很长，导致redis内存溢出等问题。spring-data-redis中expiredAt命令调用栈如下：

输入图片说明

由于这个类属于jedis，因此升级jedis至最新（2.8.1 -> 2.9.0），依然存在此代码。在GitHub issue里我发布了关于这个问题的讨论，jedis的开发者回复确实是个bug，在jedis 2.9.1中才会解决，目前jedis 2.9.1还未发布。在这里我对该命令的代码解析了一下。

环境

jar版本： spring-data-redis-1.8.4-RELEASE.jar、jedis-2.9.0.jar

测试环境： Redis 3.2.8，八个集群节点

applicationContext-redis-cluster.xml 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

	<!-- 连接池配置. -->
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<!-- 连接池中最大连接数。高版本：maxTotal，低版本：maxActive -->
		<property name="maxTotal" value="8" />
		<!-- 连接池中最大空闲的连接数. -->
		<property name="maxIdle" value="4" />
		<!-- 连接池中最少空闲的连接数. -->
		<property name="minIdle" value="1" />
		<!-- 当连接池资源耗尽时，调用者最大阻塞的时间，超时将跑出异常。单位，毫秒数;默认为-1.表示永不超时。高版本：maxWaitMillis，低版本：maxWait -->
		<property name="maxWaitMillis" value="5000" />
		<!-- 连接空闲的最小时间，达到此值后空闲连接将可能会被移除。负值(-1)表示不移除. -->
		<property name="minEvictableIdleTimeMillis" value="300000" />
		<!-- 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3 -->
		<property name="numTestsPerEvictionRun" value="3" />
		<!-- “空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1. -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
		<!-- testOnBorrow:向调用者输出“链接”资源时，是否检测是有有效，如果无效则从连接池中移除，并尝试获取继续获取。默认为false。建议保持默认值. -->
		<!-- testOnReturn:向连接池“归还”链接时，是否检测“链接”对象的有效性。默认为false。建议保持默认值. -->
		<!-- testWhileIdle:向调用者输出“链接”对象时，是否检测它的空闲超时；默认为false。如果“链接”空闲超时，将会被移除。建议保持默认值. -->
		<!-- whenExhaustedAction:当“连接池”中active数量达到阀值时，即“链接”资源耗尽时，连接池需要采取的手段, 默认为1(0:抛出异常。1:阻塞，直到有可用链接资源。2:强制创建新的链接资源) -->
	</bean>

	<bean id="n1" class="org.springframework.data.redis.connection.RedisNode">
		<constructor-arg value="127.0.0.1" />
		<constructor-arg value="6379" type="int" />
	</bean>
	<bean id="n2" class="org.springframework.data.redis.connection.RedisNode">
		<constructor-arg value="127.0.0.1" />
		<constructor-arg value="6380" type="int" />
	</bean>
	<bean id="n3" class="org.springframework.data.redis.connection.RedisNode">
		<constructor-arg value="127.0.0.1" />
		<constructor-arg value="6381" type="int" />
	</bean>
	
	<bean id="redisClusterConfiguration"
		class="org.springframework.data.redis.connection.RedisClusterConfiguration">
		<property name="clusterNodes">
			<set>
				<ref bean="n1" />
				<ref bean="n2" />
				<ref bean="n3" />
			</set>
		</property>
		<property name="maxRedirects" value="5" />
	</bean>

	<bean id="jedisConnectionFactory"
		class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<constructor-arg ref="redisClusterConfiguration" />
		<constructor-arg ref="jedisPoolConfig" />
	</bean>

	<!-- Spring提供的访问Redis类. -->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory" />
		<property name="KeySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="ValueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashKeySerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
		<property name="hashValueSerializer">
			<bean
				class="org.springframework.data.redis.serializer.StringRedisSerializer" />
		</property>
	</bean>

	<!-- Redis配置结束 -->
</beans>

相关源码解析

现在我们项目中主要使用spring-data-redis来进行redis操作，其中使用RedisTemplate，再配合jedis完成redis相关命令操作。集群环境下，关键类及实现流程如下：

redis集群配置类，负责保存集群配置：

org.springframework.data.redis.connection.RedisClusterConfiguration

redis连接工厂类，负责创建集群连接：

org.springframework.data.redis.connection.jedis.JedisConnectionFactory

集群连接Connection类，负责连接redis集群：

org.springframework.data.redis.connection.jedis.JedisClusterConnection

集群操作类，负责与redis集群进行命令交互：

redis.clients.jedis.JedisCluster

集群操作过程：

当spring容器随应用启动的时候，JedisConnectionFactory会根据RedisClusterConfiguration的配置创建redis集群的配置、连接类实例，最后使用JedisCluster类完成redis命令操作。

JedisConnectionFactory主要源码如下：

/**
 * 主要根据集群配置初始化cluster对象
 **/
public void afterPropertiesSet() {
		if (shardInfo == null) {
			shardInfo = new JedisShardInfo(hostName, port);

			if (StringUtils.hasLength(password)) {
				shardInfo.setPassword(password);
			}

			if (timeout > 0) {
				setTimeoutOn(shardInfo, timeout);
			}
		}

		if (usePool && clusterConfig == null) {
			this.pool = createPool();
		}

		//因为我们的集群配置不为空，因此这里就会创建redis.clients.jedis.JedisCluster类对象
		if (clusterConfig != null) {
			this.cluster = createCluster();
		}
	}

createCluster()源码如下：

/**
 * 创建JedisCluster对象，它负责与redis集群进行命令交互
 **/
private JedisCluster createCluster() {

		JedisCluster cluster = createCluster(this.clusterConfig, this.poolConfig);
		this.clusterCommandExecutor = new ClusterCommandExecutor(
				new JedisClusterConnection.JedisClusterTopologyProvider(cluster),
				new JedisClusterConnection.JedisClusterNodeResourceProvider(cluster), EXCEPTION_TRANSLATION);
		return cluster;
	}

从上面方法的源码我们已经看到了JedisClusterConnection类，该类在JedisConnectionFactory创建的代码如下：

/**
 * 获得JedisClusterConnection对象 
 **/
 public RedisConnection getConnection() {

		//如果JedisCluster对象不为空，则返回JedisClusterConnection对象
		if (cluster != null) {
			return getClusterConnection();
		}

		Jedis jedis = fetchJedisConnector();
		JedisConnection connection = (usePool ? new JedisConnection(jedis, pool, dbIndex, clientName)
				: new JedisConnection(jedis, null, dbIndex, clientName));
		connection.setConvertPipelineAndTxResults(convertPipelineAndTxResults);
		return postProcessConnection(connection);
	}
	
/**
 * 创建JedisClusterConnection对象 
 **/
public RedisClusterConnection getClusterConnection() {

		if (cluster == null) {
			throw new InvalidDataAccessApiUsageException("Cluster is not configured!");
		}
		return new JedisClusterConnection(cluster, clusterCommandExecutor);
	}

JedisClusterConnection类的cluster属性定义如下：

private final JedisCluster cluster;

接着我们看一下JedisCluster类中各种key过期设置的实现源码：

 @Override
  public Long expire(final String key, final int seconds) {
    return new JedisClusterCommand<Long>(connectionHandler, maxAttempts) {
      @Override
      public Long execute(Jedis connection) {
        return connection.expire(key, seconds);
      }
    }.run(key);
  }

  @Override
  public Long pexpire(final String key, final long milliseconds) {
    return new JedisClusterCommand<Long>(connectionHandler, maxAttempts) {
      @Override
      public Long execute(Jedis connection) {
        return connection.pexpire(key, milliseconds);
      }
    }.run(key);
  }

  @Override
  public Long expireAt(final String key, final long unixTime) {
    return new JedisClusterCommand<Long>(connectionHandler, maxAttempts) {
      @Override
      public Long execute(Jedis connection) {
        return connection.expireAt(key, unixTime);
      }
    }.run(key);
  }
  
   @Override
  public Long pexpireAt(final String key, final long millisecondsTimestamp) {
    return new JedisClusterCommand<Long>(connectionHandler, maxAttempts) {
      @Override
      public Long execute(Jedis connection) {
        return connection.pexpireAt(key, millisecondsTimestamp);
      }
    }.run(key);
  }

在JedisCluster类中过期操作的四个方法expire、expireAt、pexpire和pexpireAt调用的命令没有错，而它的父类BinaryJedisCluster的pexpireAt方法调用的命令是pexpire，从而导致了bug。

redisTemplate expireAt操作流程

在这里我重点分析redisTemplate expireAt操作流程以及bug产生过程。

现在我们看下redisTemplate中expireAt方法的实现：

public Boolean expireAt(K key, final Date date) {

		//获取key的字节数组
		final byte[] rawKey = rawKey(key);

		return execute(new RedisCallback<Boolean>() {

			public Boolean doInRedis(RedisConnection connection) {
				try {
					//redis 2.6以上执行该方法
					return connection.pExpireAt(rawKey, date.getTime());
				} catch (Exception e) {
					//redis 2.6以下执行该方法
					return connection.expireAt(rawKey, date.getTime() / 1000);
				}
			}
		}, true);
	}
	
        /**
          * 将key转换为字节数组
          **/
	@SuppressWarnings("unchecked")
	private byte[] rawKey(Object key) {
		Assert.notNull(key, "non null key required");
		if (keySerializer == null && key instanceof byte[]) {
			return (byte[]) key;
		}
		return keySerializer.serialize(key);
	}

在redisTemplate的expireAt方法中，有一个关键的地方：

//获取key的字节数组
final byte[] rawKey = rawKey(key);

获取key的字节数组之后，再调用RedisConnection接口的pExpireAt或expireAt方法。由于redis从3.0开始才支持集群，因此这里调用的是RedisConnection接口的pExpireAt方法。在这里RedisConnection接口的实现类是JedisClusterConnection类，它的pExpireAt方法实现如下：

        /*
	 * (non-Javadoc)
	 * @see org.springframework.data.redis.connection.RedisKeyCommands#pExpireAt(byte[], long)
	 */
	@Override
	public Boolean pExpireAt(byte[] key, long unixTimeInMillis) {

		try {
			//调用JedisCluster对象的pexpireAt方法，最终调用的是父类BinaryJedisCluster的pexpireAt方法
			return JedisConverters.toBoolean(cluster.pexpireAt(key, unixTimeInMillis));
		} catch (Exception ex) {
			throw convertJedisAccessException(ex);
		}
	}

在这里调用JedisCluster对象的pexpireAt方法时，由于key参数是字节数组类型，而JedisCluster类没有对应的pexpireAt(final byte[] key, final long millisecondsTimestamp)方法，因此会调用父类BinaryJedisCluster的pexpireAt方法，它的父类BinaryJedisCluster中pexpireAt方法的定义如下:

 @Override
  public Long pexpireAt(final byte[] key, final long millisecondsTimestamp) ：
    return new JedisClusterCommand<Long>(connectionHandler, maxAttempts) {
      @Override
      public Long execute(Jedis connection) {
        // 调用的是pexpire命令而不是pexpireAt命令
        return connection.pexpire(key, millisecondsTimestamp);
      }
    }.runBinary(key);
  }

因此bug就产生了。pexpireat命令与pexpire命令都是以毫秒形式来设置key的过期时间，它们的不同如下：

命令名称	说明
PEXPIRE	以毫秒为单位设置 key 的生存时间
PEXPIREAT	以毫秒为单位设置 key 的过期 unix 时间戳

比如我们当前使用的时间是2017/10/12 09:41:56，它的unix时间戳为1507772516000毫秒，当我们使用PEXPIREAT命令时，由于是过去的时间，相应的key会立即过期。而我们误用了PEXPIRE命令时，key不会立即过期，而是等到1507772516000毫秒后才过期，key过期时间会相当长，从而可能导致redis内存溢出、服务器崩溃等问题。

测试结果

测试及追踪源码发现，在集群环境下，使用spring-data-redis的RedisTemplate类与redis进行交互时：

如果key为String类型，底层最终调用的是JedisCluster类的相关方法进行redis命令操作
如果key为byte[]字节数组类型，底层最终调用的是BinaryJedisCluster类的相关方法进行redis命令操作

解决办法

在jedis 2.9.0及以下版本中，解决办法有两种，第一种是直接使用RedisTemplate类的execute方法调用expireAt命令，代码如下:

  	@Autowired
	private RedisTemplate<String, String> redisTemplate;
	
	/**
	 * 执行expireAt命令
	 */
	public void expireAt(String key, Date deadLine){
		byte[] rawKey = rawKey(key);
		redisTemplate.execute(new RedisCallback<Boolean>() {
	
			@Override
			public Boolean doInRedis(RedisConnection connection) {
				return connection.expireAt(rawKey, deadLine.getTime() / 1000);
			}
		}, true);
	}

       /**
	 * 获取key序列化方式
	 */
	@SuppressWarnings("rawtypes")
	private RedisSerializer keySerializer() {
		return redisTemplate.getKeySerializer();
	}

	/**
	 * 使用相应的key序列化方式获取key的byte[]数组
	 */
	@SuppressWarnings("unchecked")
	private byte[] rawKey(Object key) {
		if (keySerializer() == null && key instanceof byte[]) {
			return (byte[]) key;
		}
		return keySerializer().serialize(key);
	}

第二种是直接使用JedisCluster，使用JedisCluster来进行expireAt命令操作，可以参考分布式缓存技术redis学习系列（七）——spring整合jediscluster来整合JedisCluster。