Firebase实时数据库：回调式分页获取各子节点10条数据

开发面向儿童的Android应用，使用Firebase实时数据库存储数据。需实现：

• 首次获取各子节点的10条初始数据，通过回调返回完整的Map<String, List<OneModel>>
• 后续实现分页加载功能

当前用循环发起多个Firebase查询，但因异步回调特性，外部代码无法获取完整数据——循环结束时Map为空，回调提前执行，而各子节点的数据在后续才陆续返回。

尝试的代码 #

private void readAllCategoryData(FirebaseAllCategoryDataCallBack firebaseAllCategoryDataCallBack) {
    Map<String,List<OneModel>> map = new HashMap<>();
    for (int i=0;i<array.size();i++){
        int finalI = i;
        ValueEventListener valueEventListener = new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                List<OneModel> modelList = new ArrayList<>();
                for (DataSnapshot dataSnapshot : snapshot.getChildren()){
                    String key = dataSnapshot.getKey();
                    ModelData modelData = dataSnapshot.getValue(ModelData.class);
                    OneModel model = new OneModel(key,modelData);
                    modelList.add(model);
                }
                map.put(array.get(finalI), modelList);
                testModelMap = map;
                Toast.makeText(MainActivity.this, "Loop "+finalI+","+map, Toast.LENGTH_SHORT).show(); // 能显示数据但顺序不固定
                Log.i("LOOP"+finalI,""+map); // 日志能输出数据但顺序不固定
                
            }

            @Override
            public void onCancelled(@NonNull DatabaseError error) {

            }
        };
        categoryReference.child(array.get(i)).addListenerForSingleValueEvent(valueEventListener);
        
    }
    Toast.makeText(this, "All"+testModelMap, Toast.LENGTH_LONG).show(); // Map为空
    Log.i("OUTSIDE LOOP",""+map); // 日志中Map无数据
    Log.i("OUTSIDE LOOP1",""+testModel); // 日志中Map无数据
    firebaseAllCategoryDataCallBack.onAllCategoryDataCallBack(map);
}

日志输出（带时间戳） #

2024-04-15 22:52:56.772  8222-8222  OUTSIDE LOOP   I  {}
2024-04-15 22:52:56.772  8222-8222  OUTSIDE LOOP1  I  {}
2024-04-15 22:53:00.500  8222-8222  LOOP3          I  {Some Values}
2024-04-15 22:53:00.596  8222-8222  LOOP4          I  {Some more Values than LOOP3}
2024-04-15 22:53:00.657  8222-8222  LOOP0          I  {Some more Values than LOOP4}
2024-04-15 22:53:00.676  8222-8222  LOOP2          I  {Some more Values than LOOP0}
2024-04-15 22:53:00.693  8222-8222  LOOP5          I  {Some more Values than LOOP2}
2024-04-15 22:53:00.768  8222-8222  LOOP1          I  {Some more Values than LOOP5/FullMap I want}

1. 解决异步回调同步问题：计数判断所有查询完成 #

Firebase查询是异步的，循环结束时所有查询还未返回数据。需要在每个onDataChange中计数，当所有子节点数据都加载完成后，再触发回调。

修改后的代码：

private void readAllCategoryData(FirebaseAllCategoryDataCallBack firebaseAllCategoryDataCallBack) {
    Map<String, List<OneModel>> map = new HashMap<>();
    int totalCategories = array.size();
    int completedCount = 0; // 记录已完成的查询数量

    for (int i = 0; i < totalCategories; i++) {
        int finalI = i;
        // 直接用limitToFirst(10)限制初始数据量，减少传输
        Query query = categoryReference.child(array.get(i)).limitToFirst(10);
        
        ValueEventListener valueEventListener = new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                List<OneModel> modelList = new ArrayList<>();
                for (DataSnapshot dataSnapshot : snapshot.getChildren()) {
                    String key = dataSnapshot.getKey();
                    ModelData modelData = dataSnapshot.getValue(ModelData.class);
                    OneModel model = new OneModel(key, modelData);
                    modelList.add(model);
                }
                map.put(array.get(finalI), modelList);
                completedCount++;

                // 所有查询完成后，触发回调
                if (completedCount == totalCategories) {
                    firebaseAllCategoryDataCallBack.onAllCategoryDataCallBack(map);
                    Toast.makeText(MainActivity.this, "所有数据加载完成", Toast.LENGTH_SHORT).show();
                }
            }

            @Override
            public void onCancelled(@NonNull DatabaseError error) {
                completedCount++;
                Log.e("FirebaseError", "加载分类数据失败: " + error.getMessage());
                // 即使查询失败，也判断是否所有任务都完成
                if (completedCount == totalCategories) {
                    firebaseAllCategoryDataCallBack.onAllCategoryDataCallBack(map);
                }
            }
        };
        query.addListenerForSingleValueEvent(valueEventListener);
    }
}

2. 分页功能实现思路 #

对于每个子节点的分页，需要记录最后一条数据的key（或时间戳，若有排序字段），下次加载时使用startAfter()获取下一页数据：

// 保存每个分类的最后一条数据key
private Map<String, String> lastKeyMap = new HashMap<>();

private void loadMoreDataForCategory(String category) {
    String lastKey = lastKeyMap.get(category);
    Query query;
    
    if (lastKey == null) {
        // 首次加载，取前10条
        query = categoryReference.child(category).orderByKey().limitToFirst(10);
    } else {
        // 分页加载，从lastKey之后取10条
        query = categoryReference.child(category).orderByKey().startAfter(lastKey).limitToFirst(10);
    }

    query.addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            List<OneModel> moreModels = new ArrayList<>();
            String newLastKey = null;
            
            for (DataSnapshot dataSnapshot : snapshot.getChildren()) {
                String key = dataSnapshot.getKey();
                ModelData modelData = dataSnapshot.getValue(ModelData.class);
                moreModels.add(new OneModel(key, modelData));
                newLastKey = key;
            }
            
            // 更新当前分类的最后一条key
            if (newLastKey != null) {
                lastKeyMap.put(category, newLastKey);
            }
            
            // 将新数据添加到对应分类的列表，通知UI更新
            // existingList.addAll(moreModels);
            // notifyDataSetChanged();
        }

        @Override
        public void onCancelled(@NonNull DatabaseError error) {
            Log.e("FirebasePaging", "分页加载失败: " + error.getMessage());
        }
    });
}

关键说明 #

• 异步回调核心：不要在循环结束后立即处理结果，通过计数器等待所有异步任务完成后再触发回调。
• 初始数据限制：使用Firebase的limitToFirst(10)比本地遍历截断更高效，减少数据传输量。
• 分页依赖：必须搭配orderBy规则（如orderByKey()）和startAfter()使用，确保分页逻辑正确。

内容的提问来源于stack exchange，提问作者Andro