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

关注

原创最新推荐文章于 2026-06-27 09:10:12 发布 4.7k 阅读 AI 写同款· GEO 优化 ›

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

背景

我们最近在使用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);
    }