跨平台开发 / 系统课时

处理下拉刷新与分页共存

处理下拉刷新与分页共存

列表页同时支持下拉刷新和加载下一页时,最危险的问题不是“多一个 loading”,而是两个请求可能交错返回,旧分页结果反过来覆盖刚刷新的数据。本节用 Riverpod 的 AsyncNotifier 把刷新、分页和并发保护放进同一个状态控制器。

学习目标

  • 区分“重新加载第一页”和“追加下一页”两种状态边界
  • 用请求代次标记丢弃已经过期的异步结果
  • 让刷新和分页按钮各自只影响需要的 UI 区域

为什么两个 loading 不能共用

刷新会替换整份列表,并把页码重置到第一页;分页只应把新数据追加到现有列表末尾。如果二者共用一个 isLoading,UI 很难判断该保留旧内容、显示顶部刷新动画,还是显示底部加载状态。

更棘手的是请求顺序。假设第 2 页请求先发出,随后用户立即下拉刷新。若第一页的新数据先返回,而旧的第 2 页稍后才完成,直接写入状态就可能把刷新后的列表再次污染。因此,状态层需要明确“哪一次请求仍然有资格提交结果”。

刷新与分页并发边界

用状态模型分开两类请求

下面的完整 main.dart 使用一个不可变状态保存列表内容、下一页位置以及两个独立的忙碌标记。_generation 代表当前列表版本:刷新会递增它;分页开始时记住当前版本,返回后只有版本仍一致才允许追加。

dart
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

class FeedState {
  const FeedState({
    required this.items,
    required this.nextPage,
    required this.hasMore,
    this.isRefreshing = false,
    this.isLoadingMore = false,
  });

  final List<int> items;
  final int nextPage;
  final bool hasMore;
  final bool isRefreshing;
  final bool isLoadingMore;

  FeedState copyWith({
    List<int>? items,
    int? nextPage,
    bool? hasMore,
    bool? isRefreshing,
    bool? isLoadingMore,
  }) {
    return FeedState(
      items: items ?? this.items,
      nextPage: nextPage ?? this.nextPage,
      hasMore: hasMore ?? this.hasMore,
      isRefreshing: isRefreshing ?? this.isRefreshing,
      isLoadingMore: isLoadingMore ?? this.isLoadingMore,
    );
  }
}

class FeedRepository {
  Future<List<int>> fetchPage(int page) async {
    await Future<void>.delayed(const Duration(milliseconds: 500));
    if (page > 3) return const [];
    final start = (page - 1) * 10;
    return List<int>.generate(10, (index) => start + index + 1);
  }
}

final repositoryProvider = Provider<FeedRepository>((ref) => FeedRepository());

class FeedNotifier extends AsyncNotifier<FeedState> {
  int _generation = 0;

  FeedRepository get _repository => ref.read(repositoryProvider);

  @override
  Future<FeedState> build() async {
    final items = await _repository.fetchPage(1);
    return FeedState(items: items, nextPage: 2, hasMore: items.isNotEmpty);
  }

  Future<void> refresh() async {
    final current = state.value;
    if (current == null || current.isRefreshing) return;

    final generation = ++_generation;
    state = AsyncData(
      current.copyWith(isRefreshing: true, isLoadingMore: false),
    );

    try {
      final items = await _repository.fetchPage(1);
      if (generation != _generation) return;

      state = AsyncData(
        FeedState(items: items, nextPage: 2, hasMore: items.isNotEmpty),
      );
    } catch (error, stackTrace) {
      if (generation == _generation) {
        state = AsyncData(
          current.copyWith(isRefreshing: false, isLoadingMore: false),
        );
      }
      Error.throwWithStackTrace(error, stackTrace);
    }
  }

  Future<void> loadMore() async {
    final current = state.value;
    if (current == null ||
        current.isRefreshing ||
        current.isLoadingMore ||
        !current.hasMore) {
      return;
    }

    final generation = _generation;
    state = AsyncData(current.copyWith(isLoadingMore: true));

    try {
      final newItems = await _repository.fetchPage(current.nextPage);
      if (generation != _generation) return;

      final latest = state.value;
      if (latest == null) return;

      state = AsyncData(
        latest.copyWith(
          items: [...latest.items, ...newItems],
          nextPage: latest.nextPage + 1,
          hasMore: newItems.isNotEmpty,
          isLoadingMore: false,
        ),
      );
    } catch (error, stackTrace) {
      if (generation == _generation) {
        final latest = state.value;
        if (latest != null) {
          state = AsyncData(latest.copyWith(isLoadingMore: false));
        }
      }
      Error.throwWithStackTrace(error, stackTrace);
    }
  }
}

final feedProvider =
    AsyncNotifierProvider<FeedNotifier, FeedState>(FeedNotifier.new);

void main() {
  runApp(const ProviderScope(child: MaterialApp(home: FeedPage())));
}

class FeedPage extends ConsumerWidget {
  const FeedPage({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final feed = ref.watch(feedProvider);

    return Scaffold(
      appBar: AppBar(title: const Text('刷新与分页')),
      body: feed.when(
        loading: () => const Center(child: CircularProgressIndicator()),
        error: (error, stackTrace) => Center(child: Text('加载失败:$error')),
        data: (value) {
          return RefreshIndicator(
            onRefresh: () => ref.read(feedProvider.notifier).refresh(),
            child: ListView(
              physics: const AlwaysScrollableScrollPhysics(),
              children: [
                for (final item in value.items)
                  ListTile(title: Text('Item $item')),
                Padding(
                  padding: const EdgeInsets.all(16),
                  child: FilledButton(
                    onPressed: value.isRefreshing ||
                            value.isLoadingMore ||
                            !value.hasMore
                        ? null
                        : () => ref.read(feedProvider.notifier).loadMore(),
                    child: Text(
                      value.isLoadingMore
                          ? '加载中'
                          : value.hasMore
                              ? '加载下一页'
                              : '没有更多',
                    ),
                  ),
                ),
              ],
            ),
          );
        },
      ),
    );
  }
}

预期结果

text
首次进入页面后显示 Item 1~Item 10。
点击“加载下一页”后,列表追加 Item 11~Item 20,旧内容保留。
分页请求尚未结束时执行下拉刷新,刷新完成后列表回到第一页;较晚返回的旧分页结果不会再次追加到刷新后的列表。
刷新期间“加载下一页”按钮不可用,避免启动新的分页请求。

并发控制的关键点

isRefreshing 和 isLoadingMore 解决的是 UI 与重复触发问题,_generation 解决的是异步结果过期问题。两者不能互相替代:即使按钮已经禁用,之前已经发出的请求仍可能晚到,因此提交状态前仍要检查请求代次。

刷新开始时还要主动把 isLoadingMore 清为 false,因为刷新已经决定用第一页重建列表,原分页请求即使仍在网络层执行,也不再属于当前列表版本。这里不要求真的取消 HTTP 请求,只要保证旧结果不能写回状态,就能避免数据覆盖。

什么时候需要更强的方案

如果真实接口支持取消请求,可以在代次校验之外,再用客户端的取消令牌终止旧分页请求,减少无效流量;如果列表按筛选条件、登录用户或搜索关键字分组,则这些条件变化也应视为“新一代列表”,同样递增版本或直接让对应 Provider 重新构建。

核心边界始终一致:刷新负责替换并重置分页位置,加载下一页只负责追加,而任何属于旧列表版本的异步结果都必须被丢弃。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

处理下拉刷新与分页共存

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通