分页查询

在排行榜系统中,分页查询是最常见的需求之一。用户通常只需要查看前 100 名或特定范围内的排名,而非整个榜单。然而,实现高效的分页查询并非易事,尤其当数据量达到百万级别时。

排行榜分页查询的挑战

传统的关系型数据库在处理分页查询时,通常使用 LIMIT offset, size 的方式。但当 offset 很大时,数据库需要扫描并跳过大量记录,导致性能急剧下降。

例如,查询第 10001 到 10020 名的用户:

数据设计要点

  • 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。

这条查询需要扫描前 10000 条记录并丢弃它们,只返回最后的 20 条。随着页码增加,查询时间线性增长。

在排行榜场景中,这个问题更加严重:

  • 高频访问:用户频繁翻页查看排名
  • 实时性要求:排名可能每秒都在变化
  • 大数据量:热门榜单可能有数百万参与者

Redis ZRANGE 分页实现

Redis 的有序集合(Sorted Set)是实现排行榜的理想数据结构。ZRANGE 命令可以高效地获取指定排名范围内的成员。

基础分页查询

# 获取第 1 页(前 20 名),排名从 0 开始
ZRANGE rankings 0 19 WITHSCORES

# 获取第 2 页(20-39 名)
ZRANGE rankings 20 39 WITHSCORES

# 获取第 n 页(每页 20 条)
# start = (page - 1) * page_size
# end = start + page_size - 1
ZRANGE rankings {start} {end} WITHSCORES

倒序查询(从高到低)

排行榜通常按分数从高到低排序,使用 ZREVRANGE:

# 获取前 100 名(分数从高到低)
ZREVRANGE rankings 0 99 WITHSCORES

# 获取第 5 页(80-99 名)
ZREVRANGE rankings 80 99 WITHSCORES

方案落地示例

把上面的分页思路落成一个可以直接对外提供接口的服务。核心是三件事:参数校验、区间换算、结果组装。

import java.util.ArrayList;
import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

/**
 * 排行榜分页查询服务。
 */
public class RankingQueryService {

    /** 单页最大条数,防止客户端传入超大 pageSize 拖垮 Redis。 */
    private static final int MAX_PAGE_SIZE = 100;

    /** 允许查询的最大页码,超过则视为非法请求。 */
    private static final int MAX_PAGE = 50;

    /** 榜单 key。 */
    private static final String RANKING_KEY = "ranking:hot";

    private final JedisPool jedisPool;

    public RankingQueryService(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /** 分页结果。 */
    public record PageResult(String contentId, long rank, double score) {}

    /**
     * 查询排行榜指定页。
     *
     * @param page     页码,从 1 开始
     * @param pageSize 每页条数
     * @return 该页的条目列表,按分数从高到低
     */
    public List<PageResult> query(int page, int pageSize) {
        int safePage = Math.max(1, page);
        int safeSize = Math.min(Math.max(1, pageSize), MAX_PAGE_SIZE);
        if (safePage > MAX_PAGE) {
            throw new IllegalArgumentException("仅支持查询前 " + MAX_PAGE + " 页");
        }

        // ZSet 的下标从 0 开始,且是升序;排行榜要分数从高到低,因此用 ZREVRANGE
        long start = (long) (safePage - 1) * safeSize;
        long end = start + safeSize - 1;

        List<PageResult> results = new ArrayList<>(safeSize);
        try (Jedis jedis = jedisPool.getResource()) {
            // withScores=true 会连同分数一起返回,客户端无需二次查询
            List<Tuple> tuples = jedis.zrevrangeWithScores(RANKING_KEY, start, end);
            long rank = start + 1;
            for (Tuple tuple : tuples) {
                results.add(new PageResult(tuple.getElement(), rank++, tuple.getScore()));
            }
        }
        return results;
    }

    /**
     * 查询某个条目的当前排名(从 1 开始)。
     *
     * ZREVRANK 返回的是 0 基下标,需要加 1。
     */
    public long rankOf(String contentId) {
        try (Jedis jedis = jedisPool.getResource()) {
            Long rank = jedis.zrevrank(RANKING_KEY, contentId);
            return rank == null ? -1 : rank + 1;
        }
    }
}

这个实现里有几个值得注意的细节:

  • 参数必须做边界收敛。page 小于 1 时按 1 处理,pageSize 超过上限时截断。如果直接用客户端传来的 pageSize 去算 start 和 end,一个恶意请求就能让 Redis 去遍历上百万个元素。
  • 同时限制最大页码。这是成本控制的关键——ZREVRANGE 的开销随偏移量线性增长,把页码限制在前 50 页,就把单次查询的最坏开销钉死在了可控范围内。
  • 用 ZREVRANGE 而不是 ZREVRANGEBYSCORE。按分数区间查询需要业务侧维护分数边界,而排名区间查询直接对应「用户看到的是第几名」,语义更直观,也更容易和前端分页对齐。
  • 一次往返取回分数。zrevrangeWithScores 一次返回成员和分数,避免了拿到 ID 后再逐个 ZSCORE 的 N+1 次往返。

再叠加一层缓存,热门页的查询压力可以进一步降低:

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;

/**
 * 带本地缓存的排行榜查询服务。
 *
 * 缓存的是「已经组装好的结果列表」,而不是 Redis 的原始响应,
 * 这样上层无需关心缓存命中与否,逻辑完全一致。
 */
public class CachedRankingQueryService extends RankingQueryService {

    /** 缓存过期时间(毫秒)。 */
    private static final long TTL_MILLIS = 3_000L;

    /** 最多缓存的页数,避免缓存无限膨胀。 */
    private static final int MAX_CACHED_PAGES = 20;

    private final ConcurrentHashMap<String, CacheEntry> cache = new ConcurrentHashMap<>();

    private record CacheEntry(List<PageResult> value, long expireAt) {}

    public CachedRankingQueryService(JedisPool jedisPool) {
        super(jedisPool);
    }

    @Override
    public List<PageResult> query(int page, int pageSize) {
        String key = page + ":" + pageSize;
        long now = System.currentTimeMillis();

        CacheEntry entry = cache.get(key);
        if (entry != null && entry.expireAt() > now) {
            return entry.value();
        }

        List<PageResult> value = super.query(page, pageSize);

        if (cache.size() < MAX_CACHED_PAGES) {
            cache.put(key, new CacheEntry(value, now + TTL_MILLIS));
        }
        return value;
    }
}

本地缓存的 TTL 要短。排行榜的价值在于实时,本地缓存每多存活一秒,用户看到的就是一秒前的榜单。秒级 TTL 在削峰和抵御缓存击穿之间取得平衡:如果仍嫌压力大,可以把 TTL 调到与底层刷新周期对齐。

深度分页问题及解决

当用户查询靠后的排名(如第 10000 页)时,即使是 Redis 也会面临性能问题。ZRANGE 需要遍历大量元素,导致响应时间增加。

问题表现

# 深度分页:获取第 10000 页(假设每页 20 条)
# 需要扫描 199980 个元素
ZREVRANGE rankings 199980 199999 WITHSCORES

随着偏移量增加:

  • 内存遍历成本上升
  • 网络传输数据量增加
  • 阻塞时间变长,影响其他请求

解决方案

1. 限制最大页码

最简单的方法是限制用户只能查看前 N 名:

大多数用户只关心前几百名,这个限制对体验影响很小。

2. 基于游标的分页

使用最后看到的分数或排名作为游标,避免计算偏移量:

游标分页的思路是:不告诉服务端「我要第几页」,而是告诉服务端「我要上一页最后那条之后的内容」。服务端从游标位置开始往后取固定条数,完全不需要知道前面有多少条。

在 Redis ZSet 上的实现有两种游标形式:

游标形式游标内容查询命令排序稳定性
分数游标上一页最后一条的分数ZREVRANGEBYSCORE需要配合唯一标识打破并列
排名游标上一页最后一条的排名ZREVRANGE 加偏移排名变化时会漏或重
复合游标分数加内容标识分数区间加精确排除最稳定,实现稍复杂

分数游标的查询命令:

# 取分数严格小于游标分数的前 20 条(从高到低)
# 上限用开区间,避免把游标本身再取出来
ZREVRANGEBYSCORE rankings (120.5 -inf WITHSCORES LIMIT 0 20

注意 ( 前缀表示开区间。如果用闭区间(写成 120.5),游标那条内容会被重复返回一次。

分数游标有一个致命问题:并列分数会被跳过。假设游标那条内容的分数是 120.5,而下一页第一条的分数也是 120.5,用 小于 120.5 的开区间查询就会把这条并列内容永远漏掉。

解决办法是用复合游标——游标带上分数和内容标识:

# 游标:score=120.5, member=content:10086
# 先取出 (120.5, -inf) 区间的候选,再在应用层过滤掉 score 等于 120.5
# 且 member 字典序大于等于 content:10086 的条目
import java.util.ArrayList;
import java.util.List;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

/**
 * 基于游标的排行榜分页查询。
 *
 * 游标由分数和内容标识组成,解决并列分数被跳过的问题。
 */
public class CursorRankingQueryService {

    /** 单页条数。 */
    private static final int PAGE_SIZE = 20;

    /** 榜单 key。 */
    private static final String RANKING_KEY = "ranking:hot";

    /** 游标。 */
    public record Cursor(double score, String member) {}

    /** 分页结果,同时带回下一页的游标。 */
    public record CursorPage(List<Tuple> items, Cursor nextCursor, boolean hasMore) {}

    private final JedisPool jedisPool;

    public CursorRankingQueryService(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 查询游标之后的一页。
     *
     * @param cursor 上一页返回的游标;首页传 null
     * @return 本页条目和下一页游标
     */
    public CursorPage query(Cursor cursor) {
        try (Jedis jedis = jedisPool.getResource()) {
            List<Tuple> candidates;

            if (cursor == null) {
                // 首页没有游标约束,直接取头部
                candidates = jedis.zrevrangeWithScores(RANKING_KEY, 0, PAGE_SIZE - 1);
            } else {
                // 游标之后的分数区间:(cursor.score, -inf]
                // 用开区间左括号排除游标本身的分数,再在应用层排除并列且字典序更大的条目
                candidates = jedis.zrevrangeByScoreWithScores(
                        RANKING_KEY, "(" + cursor.score(), "-inf");
            }

            List<Tuple> page = new ArrayList<>(PAGE_SIZE);
            for (Tuple tuple : candidates) {
                if (page.size() >= PAGE_SIZE) {
                    break;
                }
                // 跳过分数与游标相同、且字典序在游标之后的并列条目
                if (cursor != null
                        && Double.compare(tuple.getScore(), cursor.score()) == 0
                        && tuple.getElement().compareTo(cursor.member()) > 0) {
                    continue;
                }
                page.add(tuple);
            }

            if (page.isEmpty()) {
                return new CursorPage(page, cursor, false);
            }

            Tuple last = page.get(page.size() - 1);
            Cursor next = new Cursor(last.getScore(), last.getElement());

            // 多取一条用于判断是否还有下一页
            boolean hasMore = candidates.size() > page.size();
            return new CursorPage(page, next, hasMore);
        }
    }
}

游标分页的取舍:

优点代价
查询开销与页码无关,始终是 O(log N + M)不能跳页,只能顺序翻
榜单实时变化时不会漏条或重条游标需要编码进前端状态
适合无限滚动的场景需要处理游标过期

游标分页的两个使用约束:

  1. 不能跳页。用户不能直接跳到第 50 页。这在无限滚动场景下无所谓,但如果产品要求「跳转到指定页」,就必须回到偏移量分页。折中做法是:榜单前 50 页用偏移量(开销可控),后面用游标。
  2. 游标要带有效期。游标编码了分数和内容标识,如果内容被删除了,游标可能失效。给游标加一个时间戳,超过有效期(比如 10 分钟)就退回第一页。

和偏移量分页的选择:

场景推荐原因
无限滚动游标用户只会顺序往下翻
需要跳页偏移量(限制页数)游标做不到
榜单频繁变化游标偏移量会漏条或重条
榜单相对稳定偏移量实现简单,用户可跳页

3. 分段存储

将排行榜按排名范围分段存储到不同的 key 中:

# 分段存储
ranking:top1000      # 0-999 名
ranking:1000-9999    # 1000-9999 名
ranking:10000-plus   # 10000 名以后

# 查询时先确定段,再在段内分页
ZREVRANGE ranking:top1000 0 19 WITHSCORES

性能优化技巧

1. 使用 Pipeline 批量查询

当需要同时获取多个榜单或多次查询时,使用 Pipeline 减少网络往返:

单次 ZREVRANGE 的开销主要在网络往返上,而不是命令本身的执行。一次请求如果要查 5 个榜单、用 5 次独立调用,那就是 5 个往返。Pipeline 把这些命令打包成一次发送、一次接收,往返次数降到 1。

Pipeline 与事务的区别:Pipeline 不是原子操作,它只保证「批量发送、批量读回」,中间其他客户端的命令可以插入。因此它适合只读查询,不适合有依赖关系的写操作。

# 常规方式:5 次往返
ZREVRANGE ranking:hot 0 19 WITHSCORES
ZREVRANGE ranking:news 0 19 WITHSCORES
ZREVRANGE ranking:tech 0 19 WITHSCORES
ZREVRANGE ranking:sports 0 19 WITHSCORES
ZREVRANGE ranking:finance 0 19 WITHSCORES

# Pipeline:1 次往返,5 条命令
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Response;
import redis.clients.jedis.Tuple;

/**
 * 使用 Pipeline 批量查询多个榜单。
 */
public class BatchRankingQueryService {

    /** 榜单 key 列表。 */
    private static final List<String> RANKING_KEYS = List.of(
            "ranking:hot",
            "ranking:news",
            "ranking:tech",
            "ranking:sports",
            "ranking:finance");

    /** 每个榜单取前 20 名。 */
    private static final int TOP_N = 20;

    private final JedisPool jedisPool;

    public BatchRankingQueryService(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 批量查询多个榜单的头部。
     *
     * @return key 到条目列表的映射
     */
    public Map<String, List<Tuple>> topOfAll() {
        Map<String, List<Tuple>> result = new HashMap<>();

        try (Jedis jedis = jedisPool.getResource()) {
            Pipeline pipeline = jedis.pipelined();

            // 先把所有命令发出去
            Map<String, Response<List<Tuple>>> responses = new HashMap<>();
            for (String key : RANKING_KEYS) {
                responses.put(key, pipeline.zrevrangeWithScores(key, 0, TOP_N - 1));
            }

            // 再一次性读取结果
            pipeline.sync();

            for (String key : RANKING_KEYS) {
                result.put(key, responses.get(key).get());
            }
        } catch (Exception e) {
            // Pipeline 失败时返回空结果,不影响其他榜单
            return result;
        }

        return result;
    }

    /**
     * 批量查询单个榜单的多个区间。
     *
     * 场景:首页需要展示「第 1 到 20 名」「第 21 到 40 名」两个分页。
     */
    public List<List<Tuple>> rangesOf(String key, int... ranges) {
        List<List<Tuple>> result = new ArrayList<>(ranges.length / 2);

        try (Jedis jedis = jedisPool.getResource()) {
            Pipeline pipeline = jedis.pipelined();
            List<Response<List<Tuple>>> responses = new ArrayList<>();

            for (int i = 0; i + 1 < ranges.length; i += 2) {
                int start = ranges[i];
                int end = ranges[i + 1];
                responses.add(pipeline.zrevrangeWithScores(key, start, end));
            }

            pipeline.sync();

            for (Response<List<Tuple>> response : responses) {
                result.add(response.get());
            }
        }

        return result;
    }
}

Pipeline 的三条纪律:

  1. 批次不能太大。Pipeline 里塞进几千条命令,Redis 单线程处理过久会阻塞其他请求。批次大小控制在百条量级以内,具体看单条命令的复杂度。
  2. 必须调用 sync()。Pipeline 只是把命令发出去,sync() 才是读取结果的时机。不调用 sync(),后面的 response.get() 会一直阻塞。
  3. 只用于只读场景。Pipeline 不是事务,中间的写操作可能被别人插队。如果确实需要原子性,用 MULTI/EXEC(Redis 事务),但它没有 Pipeline 的批量优势。

Pipeline 与多路查询的对比:

方式网络往返服务端执行原子性适用
独立调用N 次N 次串行无单个查询
Pipeline1 次N 次串行无多个只读查询
MULTI/EXEC1 次N 次串行有需要原子的写操作

2. 缓存热门页

对于访问频繁的页面(如首页),添加缓存层:

热门页的访问量占整个榜单查询的绝大多数——绝大多数用户只看第一页,很少有人翻到第 30 页。因此只缓存前几页就能拦下大部分请求。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

/**
 * 热门页缓存。
 *
 * 两级缓存:本地缓存挡在 Redis 之前,Redis 缓存挡在计算之前。
 */
public class HotPageCache {

    /** 本地缓存条目的存活时间(毫秒)。 */
    private static final long LOCAL_TTL_MILLIS = 3_000L;

    /** 本地缓存最多保存的条目数。 */
    private static final int MAX_LOCAL_ENTRIES = 200;

    /** Redis 缓存的存活时间(秒)。 */
    private static final int REDIS_TTL_SECONDS = 10;

    private final ConcurrentHashMap<String, CacheEntry> localCache = new ConcurrentHashMap<>();
    private final JedisPool jedisPool;

    private record CacheEntry(List<Tuple> value, long expireAt) {}

    public HotPageCache(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 查询热门页,命中缓存则直接返回。
     */
    public List<Tuple> topN(String rankingKey, int count) {
        String cacheKey = rankingKey + ":" + count;

        // 第一级:本地缓存
        CacheEntry entry = localCache.get(cacheKey);
        long now = System.currentTimeMillis();
        if (entry != null && entry.expireAt() > now) {
            return entry.value();
        }

        // 第二级:Redis 缓存
        List<Tuple> cached = readFromRedis(cacheKey);
        if (cached != null) {
            putLocal(cacheKey, cached, now);
            return cached;
        }

        // 未命中:回源计算
        List<Tuple> fresh = loadFromSource(rankingKey, count);
        writeToRedis(cacheKey, fresh);
        putLocal(cacheKey, fresh, now);
        return fresh;
    }

    /**
     * 读取 Redis 缓存。返回 null 表示未命中。
     */
    private List<Tuple> readFromRedis(String cacheKey) {
        try (Jedis jedis = jedisPool.getResource()) {
            List<String> members = jedis.lrange(cacheKey, 0, -1);
            if (members.isEmpty()) {
                return null;
            }
            List<Tuple> tuples = new ArrayList<>(members.size());
            for (String member : members) {
                // 存储格式是 "member|score",读回时拆开
                int separator = member.lastIndexOf('|');
                if (separator > 0) {
                    tuples.add(new Tuple(
                            member.substring(0, separator),
                            Double.parseDouble(member.substring(separator + 1))));
                }
            }
            return tuples;
        } catch (Exception e) {
            // Redis 不可用时按未命中处理,回源计算
            return null;
        }
    }

    /**
     * 回源计算。这里是真实的计算逻辑。
     */
    private List<Tuple> loadFromSource(String rankingKey, int count) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.zrevrangeWithScores(rankingKey, 0, count - 1);
        }
    }

    /**
     * 写入 Redis 缓存。
     */
    private void writeToRedis(String cacheKey, List<Tuple> value) {
        if (value.isEmpty()) {
            return;
        }
        try (Jedis jedis = jedisPool.getResource()) {
            String[] members = new String[value.size()];
            for (int i = 0; i < value.size(); i++) {
                Tuple tuple = value.get(i);
                members[i] = tuple.getElement() + "|" + tuple.getScore();
            }
            jedis.del(cacheKey);
            jedis.rpush(cacheKey, members);
            jedis.expire(cacheKey, REDIS_TTL_SECONDS);
        }
    }

    /**
     * 写入本地缓存,带容量上限。
     */
    private void putLocal(String cacheKey, List<Tuple> value, long now) {
        if (localCache.size() >= MAX_LOCAL_ENTRIES) {
            return;
        }
        localCache.put(cacheKey, new CacheEntry(value, now + LOCAL_TTL_MILLIS));
    }
}

缓存热门页的几个要点:

要点做法原因
只缓存前几页前 3 到 5 页深页访问量极低,缓存它们收益低、失效成本高
TTL 必须短本地 3 秒、Redis 10 秒榜单的价值在于实时,长 TTL 会让用户看到过期榜单
本地缓存要限容最多 200 条不限容会随 key 组合无限膨胀
空结果不缓存写回前先判空缓存空结果会让计算故障时的空榜单一直挂着

缓存与实时性的矛盾是这个方案的核心代价。榜单每刷新一次,所有实例的本地缓存就都过期了,会出现一次集中回源。缓解办法是给 TTL 加随机抖动:

// TTL 加上最多 20% 的随机抖动,避免所有实例同时过期
long ttl = LOCAL_TTL_MILLIS + (long) (Math.random() * LOCAL_TTL_MILLIS * 0.2);

必须监控缓存命中率。命中率低于预期,说明要么 TTL 设得太短,要么缓存 key 设计有问题。

3. 预计算排名

对于不实时变化的榜单,可以预计算并存储分页结果:

日榜、周榜这类榜单的更新频率是小时级甚至天级。如果每次用户翻页都去读 ZSet 再排序,就是把一个可以提前算好的结果反复计算。预计算的思路是:在榜单发布的瞬间就把每个分页的结果算好并存下来。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 预计算分页结果的榜单仓库。
 *
 * 榜单发布时一次性算出所有分页,查询时直接按下标取。
 */
public class PrecomputedRankingStore {

    /** 每个榜单的 key。 */
    private final String rankingKey;

    /** 预计算出的分页结果。 */
    private volatile List<List<String>> pages;

    /** 当前版本号,用于判断缓存是否失效。 */
    private volatile long version;

    public PrecomputedRankingStore(String rankingKey) {
        this.rankingKey = rankingKey;
        this.version = 0L;
    }

    /**
     * 发布新榜单并预计算所有分页。
     *
     * @param items 排序好的完整榜单
     * @param pageSize 每页条数
     */
    public void publish(List<String> items, int pageSize) {
        List<List<String>> newPages = new ArrayList<>();

        for (int offset = 0; offset < items.size(); offset += pageSize) {
            int end = Math.min(offset + pageSize, items.size());
            newPages.add(new ArrayList<>(items.subList(offset, end)));
        }

        // 先算完再整体替换,读侧不会看到半成品
        this.pages = newPages;
        this.version++;
    }

    /**
     * 查询指定页。
     *
     * @param page 页码,从 0 开始
     * @return 该页内容;页码越界返回空列表
     */
    public List<String> page(int page) {
        List<List<String>> current = this.pages;
        if (current == null || page < 0 || page >= current.size()) {
            return List.of();
        }
        return current.get(page);
    }

    /**
     * 总页数。
     */
    public int pageCount() {
        List<List<String>> current = this.pages;
        return current == null ? 0 : current.size();
    }

    /**
     * 当前版本号。
     */
    public long version() {
        return version;
    }
}

预计算的取舍:

优点代价
查询是 O(1),不受 ZSet 规模影响发布时有一次集中计算
深页查询不再受偏移量影响榜单更新后到下次发布前,看到的是旧版本
可以直接放在 CDN 或本地缓存内存占用与榜单规模成正比

内存占用要算清楚。假设榜单 1000 条,每条内容 ID 20 字节,加上 List 的对象开销,预计算结果大约占用几百 KB。这个量级完全可以接受。但如果榜单到了 100 万条,就要考虑把预计算结果落盘或分片存储,而不是全部放内存。

预计算结果和实时 ZSet 的关系:预计算是快照,不是替代。实时 ZSet 仍然是数据的真实来源,预计算只是把它在某个时刻的状态固化下来。因此必须明确一个语义:用户看到的是最近一次发布的快照,而不是实时数据。这个语义要在产品上说明,否则用户会认为榜单「不更新」。

发布时的原子替换很关键。上面代码里先算完所有分页再整体赋值 this.pages = newPages,这样读侧要么看到旧版本,要么看到新版本,不会看到只填了一半的中间状态。用 volatile 保证可见性。

4. 异步加载与懒加载

前端实现懒加载,用户滚动时才加载下一页:

懒加载解决的是首屏时间问题:如果首页一次返回 100 条内容,用户要等所有内容都加载完才能看到第一屏。改成滚动到接近底部时才加载下一页,首屏就能立刻显示。

后端要提供的能力:返回下一页的游标,而不是页码。理由前面讲过——榜单实时变化时,页码会因为内容插入而错位。

GET /api/ranking/hot?cursor=120.5|content:10086&size=20

响应:
{
  "items": [ { "id": "content:10085", "score": 121.3 }, ... ],
  "nextCursor": "118.2|content:10073",
  "hasMore": true
}

前端的实现:

/**
 * 懒加载列表控制器。
 *
 * 关键点:
 * 1. 用 IntersectionObserver 监听哨兵元素,而不是监听 scroll 事件;
 * 2. 请求期间加锁,防止快速滚动触发重复请求;
 * 3. 用游标而不是页码,向后端要下一页。
 */
class LazyRankingList {
  constructor(container, apiUrl, pageSize = 20) {
    this.container = container;
    this.apiUrl = apiUrl;
    this.pageSize = pageSize;
    this.cursor = null;
    this.loading = false;
    this.hasMore = true;

    this.sentinel = document.createElement('div');
    this.sentinel.className = 'load-more-sentinel';
    this.container.appendChild(this.sentinel);

    this.observer = new IntersectionObserver(
      (entries) => {
        if (entries[0].isIntersecting) {
          this.loadMore();
        }
      },
      // 提前 200px 触发,用户看不到明显的加载等待
      { rootMargin: '200px' }
    );
    this.observer.observe(this.sentinel);
  }

  /**
   * 加载下一页。
   */
  async loadMore() {
    // 请求中直接返回,避免重复请求
    if (this.loading || !this.hasMore) {
      return;
    }
    this.loading = true;

    try {
      const params = new URLSearchParams({ size: this.pageSize });
      if (this.cursor) {
        params.set('cursor', this.cursor);
      }

      const response = await fetch(`${this.apiUrl}?${params}`);
      if (!response.ok) {
        throw new Error(`请求失败: ${response.status}`);
      }

      const data = await response.json();
      this.appendItems(data.items);
      this.cursor = data.nextCursor;
      this.hasMore = data.hasMore;

      // 没有更多内容时停止观察,避免无谓的检查
      if (!this.hasMore) {
        this.observer.disconnect();
      }
    } catch (error) {
      // 加载失败时保留哨兵元素,等用户再次滚动时重试
      console.error('加载下一页失败', error);
    } finally {
      this.loading = false;
    }
  }

  /**
   * 把新一页的内容追加到列表。
   */
  appendItems(items) {
    const fragment = document.createDocumentFragment();
    for (const item of items) {
      const element = document.createElement('div');
      element.className = 'ranking-item';
      element.textContent = `${item.id} · ${item.score}`;
      fragment.appendChild(element);
    }
    this.container.insertBefore(fragment, this.sentinel);
  }
}

后端配合懒加载的三点:

要求原因
返回 nextCursor榜单实时变化,页码会错位
返回 hasMore前端据此判断是否继续观察哨兵
支持 size 参数但要设上限防止客户端一次请求拉走全部数据

懒加载的三个代价:

  1. 不能直接分享到某一页。用户复制第 5 页的链接,对方的浏览器打开时只有第一页。要支持深链接,URL 里必须带上游标。
  2. 对 SEO 不友好。爬虫通常不会滚动加载,抓到的只有第一屏内容。对依赖搜索引擎的内容平台,这个代价要评估。
  3. 首屏之后还有多次请求。用户快速翻页会产生多个并发请求。可以预加载下一页(当前页加载完就提前请求下一页),把等待藏起来。

监控上要关注三个指标:懒加载触发成功率(哨兵被触发但请求失败的比例)、翻页耗时、以及首屏到第二屏的时间。最后一个指标最能反映懒加载的实际体验。

总结

排行榜分页查询的优化需要综合考虑:

方案适用场景优点缺点
ZRANGE 基础分页前几千名查询简单高效深度分页慢
限制最大页码大部分用户场景实现简单无法查看深层排名
游标分页连续浏览场景避免偏移计算无法跳页
分段存储超大规模榜单分散查询压力管理复杂
缓存热门页高并发读取显著降低延迟需要处理缓存更新

在实际应用中,通常组合使用多种方案:限制最大查询范围 + 缓存热门页面 + 游标分页,以在性能和功能之间取得平衡。

发现内容有问题?

告诉我们哪里需要改进。