Firebase RealtimeDatabase获取双节点数据写入CSV文件问题

核心思路是等待两个异步查询的数据全部返回后，再统一写入CSV，或者通过状态标记判断数据是否齐全，触发一次性写入，规避异步回调的时序问题。以下是两种可行的Java实现方案：

方案1：使用CountDownLatch同步等待查询完成（适合Java SE/Android子线程场景） #

通过计数器等待两个查询的回调都执行完毕，再一次性写入所有数据，逻辑清晰且不易出错。

import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.Query;
import com.google.firebase.database.ValueEventListener;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class FirebaseCsvExporter {
    public static void main(String[] args) {
        FirebaseDatabase database = FirebaseDatabase.getInstance();
        Query colorQuery = database.getReference("Color");
        Query timesQuery = database.getReference("Times");

        List<String> colorList = new ArrayList<>();
        List<String> timeList = new ArrayList<>();
        CountDownLatch dataLatch = new CountDownLatch(2);

        // 监听Color节点数据
        colorQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                for (DataSnapshot child : snapshot.getChildren()) {
                    String color = child.getValue(String.class);
                    if (color != null) colorList.add(color);
                }
                dataLatch.countDown();
            }

            @Override
            public void onCancelled(DatabaseError error) {
                error.toException().printStackTrace();
                dataLatch.countDown(); // 错误场景也要减计数器，避免死等
            }
        });

        // 监听Times节点数据
        timesQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                for (DataSnapshot child : snapshot.getChildren()) {
                    String time = child.getValue(String.class);
                    if (time != null) timeList.add(time);
                }
                dataLatch.countDown();
            }

            @Override
            public void onCancelled(DatabaseError error) {
                error.toException().printStackTrace();
                dataLatch.countDown();
            }
        });

        try {
            dataLatch.await(); // 阻塞等待两个查询完成
            writeCombinedCsv(colorList, timeList, "exported_data.csv");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void writeCombinedCsv(List<String> colors, List<String> times, String filePath) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            // 写入表头
            writer.write("Color,Time");
            writer.newLine();

            // 处理数据长度不一致的情况，补空字符串
            int maxSize = Math.max(colors.size(), times.size());
            for (int i = 0; i < maxSize; i++) {
                String color = i < colors.size() ? colors.get(i) : "";
                String time = i < times.size() ? times.get(i) : "";
                writer.write(String.format("%s,%s", color, time));
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：Android平台下dataLatch.await()不能在主线程调用，需放到Thread、Coroutine或AsyncTask中执行，避免ANR。

方案2：用状态标记判断数据是否齐全（适合Android主线程场景） #

通过布尔标记记录两个查询的完成状态，每次回调后检查是否满足写入条件，满足则执行CSV写入。

import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.Query;
import com.google.firebase.database.ValueEventListener;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class FirebaseCsvExporterAndroid {
    private List<String> colorData;
    private List<String> timeData;
    private boolean isColorLoaded = false;
    private boolean isTimeLoaded = false;

    public void startExport() {
        FirebaseDatabase database = FirebaseDatabase.getInstance();
        Query colorQuery = database.getReference("Color");
        Query timesQuery = database.getReference("Times");

        colorData = new ArrayList<>();
        timeData = new ArrayList<>();

        colorQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                for (DataSnapshot child : snapshot.getChildren()) {
                    String color = child.getValue(String.class);
                    if (color != null) colorData.add(color);
                }
                isColorLoaded = true;
                checkAndWriteCsv();
            }

            @Override
            public void onCancelled(DatabaseError error) {
                error.toException().printStackTrace();
                isColorLoaded = true;
                checkAndWriteCsv();
            }
        });

        timesQuery.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                for (DataSnapshot child : snapshot.getChildren()) {
                    String time = child.getValue(String.class);
                    if (time != null) timeData.add(time);
                }
                isTimeLoaded = true;
                checkAndWriteCsv();
            }

            @Override
            public void onCancelled(DatabaseError error) {
                error.toException().printStackTrace();
                isTimeLoaded = true;
                checkAndWriteCsv();
            }
        });
    }

    private void checkAndWriteCsv() {
        if (isColorLoaded && isTimeLoaded) {
            try (BufferedWriter writer = new BufferedWriter(new FileWriter("exported_data.csv"))) {
                writer.write("Color,Time");
                writer.newLine();

                int maxSize = Math.max(colorData.size(), timeData.size());
                for (int i = 0; i < maxSize; i++) {
                    String color = i < colorData.size() ? colorData.get(i) : "";
                    String time = i < timeData.size() ? timeData.get(i) : "";
                    writer.write(String.format("%s,%s", color, time));
                    writer.newLine();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

关键注意事项 #

• 避免在回调中重复创建BufferedWriter：如果必须追加写入，需使用new FileWriter(filePath, true)开启追加模式，并通过synchronized保证线程安全，但这种方式不如全量写入可靠。
• 处理数据不匹配：若Color和Times节点的子项数量不一致，需根据业务逻辑补空或关联主键。
• 错误兜底：每个查询的onCancelled都要标记状态完成，避免程序因单个查询失败陷入无限等待。

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