Firestore技术问询：如何将ArrayList类型数据转为文档的子集合存储

嘿，这个思路太对了！把不需要每次都加载的exercises拆分到子集合里，既能减少单次读取的数据量，又能让你的数据结构更贴合Firestore的最佳实践。我来给你拆解具体的实现步骤：

1. 重新设计数据结构 #

首先你需要调整Firestore里的数据存储方式：

• 主集合routines里的每个文档只保留Routine的核心字段（比如name），不再包含exercises数组。
• 给每个Routine文档创建一个子集合（比如命名为exercises），把每个RoutineExercise对象单独作为子集合里的一个文档存储。

最终的结构大概是这样：

/routines/{routineId}
  - name: "Morning Full-Body Workout"
  /exercises/{exerciseId}
    - exerciseName: "Push-Ups"
    - sets: 4
    - reps: 12
    - restTime: 60
    ...（其他RoutineExercises的属性）

2. 实现数据写入逻辑 #

现在需要分两步完成写入：先保存Routine的主文档，再往它的子集合里写入所有RoutineExercise。这里用Java代码示例（适配Android/Java环境）：

第一步：写入Routine主文档 #

// 调整你的Routine类，暂时移除exercises属性（或者保留但写入时不序列化它）
Routine routine = new Routine("Morning Full-Body Workout");
// 生成一个自动ID的Routine文档引用
DocumentReference routineDocRef = FirebaseFirestore.getInstance()
        .collection("routines")
        .document();

// 写入主文档
routineDocRef.set(routine)
        .addOnSuccessListener(aVoid -> {
            // 主文档写入成功后，批量写入子集合的练习数据
            writeExercisesToSubcollection(routineDocRef, yourExerciseList);
        })
        .addOnFailureListener(e -> {
            Log.e("Firestore", "Failed to save routine", e);
        });

第二步：写入子集合的练习数据 #

private void writeExercisesToSubcollection(DocumentReference routineDocRef, List<RoutineExercise> exercises) {
    CollectionReference exercisesSubcolRef = routineDocRef.collection("exercises");
    WriteBatch batch = FirebaseFirestore.getInstance().batch();

    // 批量添加所有练习到子集合
    for (RoutineExercise exercise : exercises) {
        // 给每个练习生成自动ID的文档
        DocumentReference exerciseDocRef = exercisesSubcolRef.document();
        batch.set(exerciseDocRef, exercise);
    }

    // 提交批量操作
    batch.commit()
            .addOnSuccessListener(batchVoid -> {
                Log.d("Firestore", "Routine and exercises saved successfully!");
            })
            .addOnFailureListener(e -> {
                Log.e("Firestore", "Failed to save exercises", e);
            });
}

3. 分场景读取数据 #

现在你可以根据需求选择只读主文档，或者同时读取主文档和子集合：

场景1：只读取Routine的基础信息（比如name） #

直接读取主文档即可，完全不用碰子集合，节省带宽：

routineDocRef.get()
        .addOnSuccessListener(documentSnapshot -> {
            if (documentSnapshot.exists()) {
                Routine routine = documentSnapshot.toObject(Routine.class);
                // 处理routine的name等核心字段
            }
        })
        .addOnFailureListener(e -> {
            Log.e("Firestore", "Failed to fetch routine", e);
        });

场景2：读取完整的Routine+对应的练习数据 #

先读取主文档，再查询子集合的所有练习：

// 先获取主文档数据
routineDocRef.get().addOnSuccessListener(docSnapshot -> {
    Routine routine = docSnapshot.toObject(Routine.class);
    if (routine == null) return;

    // 再获取子集合的练习数据
    routineDocRef.collection("exercises").get()
            .addOnSuccessListener(querySnapshot -> {
                List<RoutineExercise> exercises = new ArrayList<>();
                for (DocumentSnapshot exerciseDoc : querySnapshot) {
                    RoutineExercise exercise = exerciseDoc.toObject(RoutineExercise.class);
                    exercises.add(exercise);
                }
                // 把练习数据赋值给routine（如果你的Routine类还保留exercises属性的话）
                routine.setExercises(exercises);
                // 现在可以处理完整的Routine对象了
            })
            .addOnFailureListener(e -> {
                Log.e("Firestore", "Failed to fetch exercises", e);
            });
});

4. 关键注意事项 #

• 批量操作限制：Firestore的批量写入最多支持500个文档，如果你的练习数量超过这个数，需要拆分多个批量操作循环执行。
• 原子性保障：如果需要确保主文档和子集合的写入要么全部成功要么全部失败，可以用Firestore的事务代替批量操作，不过大部分场景下批量写入已经足够。
• 安全规则更新：记得同步更新你的Firestore安全规则，确保用户能正确读写主文档和子集合的数据，比如：

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /routines/{routineId} {
      allow read, write: if request.auth != null;
      match /exercises/{exerciseId} {
        allow read, write: if request.auth != null;
      }
    }
  }
}

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