分页查询
在排行榜系统中,分页查询是最常见的需求之一。用户通常只需要查看前 100 名或特定范围内的排名,而非整个榜单。然而,实现高效的分页查询并非易事,尤其当数据量达到百万级别时。
传统的关系型数据库在处理分页查询时,通常使用 LIMIT offset, size 的方式。但当 offset 很大时,数据库需要扫描并跳过大量记录,导致性能急剧下降。
例如,查询第 10001 到 10020 名的用户:
数据设计要点
- 查询目标是快速定位状态、任务或资源,避免在关键路径上做大范围扫描。
这条查询需要扫描前 10000 条记录并丢弃它们,只返回最后的 20 条。随着页码增加,查询时间线性增长。
在排行榜场景中,这个问题更加严重:
- 高频访问:用户频繁翻页查看排名
- 实时性要求:排名可能每秒都在变化
- 大数据量:热门榜单可能有数百万参与者
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) | 不能跳页,只能顺序翻 |
| 榜单实时变化时不会漏条或重条 | 游标需要编码进前端状态 |
| 适合无限滚动的场景 | 需要处理游标过期 |
游标分页的两个使用约束:
- 不能跳页。用户不能直接跳到第 50 页。这在无限滚动场景下无所谓,但如果产品要求「跳转到指定页」,就必须回到偏移量分页。折中做法是:榜单前 50 页用偏移量(开销可控),后面用游标。
- 游标要带有效期。游标编码了分数和内容标识,如果内容被删除了,游标可能失效。给游标加一个时间戳,超过有效期(比如 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 的三条纪律:
- 批次不能太大。Pipeline 里塞进几千条命令,Redis 单线程处理过久会阻塞其他请求。批次大小控制在百条量级以内,具体看单条命令的复杂度。
- 必须调用
sync()。Pipeline 只是把命令发出去,sync()才是读取结果的时机。不调用sync(),后面的response.get()会一直阻塞。 - 只用于只读场景。Pipeline 不是事务,中间的写操作可能被别人插队。如果确实需要原子性,用
MULTI/EXEC(Redis 事务),但它没有 Pipeline 的批量优势。
Pipeline 与多路查询的对比:
| 方式 | 网络往返 | 服务端执行 | 原子性 | 适用 |
|---|---|---|---|---|
| 独立调用 | N 次 | N 次串行 | 无 | 单个查询 |
| Pipeline | 1 次 | N 次串行 | 无 | 多个只读查询 |
| MULTI/EXEC | 1 次 | 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 参数但要设上限 | 防止客户端一次请求拉走全部数据 |
懒加载的三个代价:
- 不能直接分享到某一页。用户复制第 5 页的链接,对方的浏览器打开时只有第一页。要支持深链接,URL 里必须带上游标。
- 对 SEO 不友好。爬虫通常不会滚动加载,抓到的只有第一屏内容。对依赖搜索引擎的内容平台,这个代价要评估。
- 首屏之后还有多次请求。用户快速翻页会产生多个并发请求。可以预加载下一页(当前页加载完就提前请求下一页),把等待藏起来。
监控上要关注三个指标:懒加载触发成功率(哨兵被触发但请求失败的比例)、翻页耗时、以及首屏到第二屏的时间。最后一个指标最能反映懒加载的实际体验。
排行榜分页查询的优化需要综合考虑:
| 方案 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| ZRANGE 基础分页 | 前几千名查询 | 简单高效 | 深度分页慢 |
| 限制最大页码 | 大部分用户场景 | 实现简单 | 无法查看深层排名 |
| 游标分页 | 连续浏览场景 | 避免偏移计算 | 无法跳页 |
| 分段存储 | 超大规模榜单 | 分散查询压力 | 管理复杂 |
| 缓存热门页 | 高并发读取 | 显著降低延迟 | 需要处理缓存更新 |
在实际应用中,通常组合使用多种方案:限制最大查询范围 + 缓存热门页面 + 游标分页,以在性能和功能之间取得平衡。
发现内容有问题?
告诉我们哪里需要改进。
