如何检测Firestore中文档是否存在？AsyncTask代码报错求助

首先，我们来拆解你遇到的两个核心问题：异步回调导致变量更新不及时，以及AsyncTask构造函数错误+异步嵌套逻辑问题，再给出针对性的解决方案。

一、你的核心问题分析 #

1. 第一个代码的异步顺序问题 #

Firestore的get()是异步操作，你在addOnSuccessListener里更新usable变量，但后续代码会在这个回调触发前就执行，自然拿不到最新的usable值——这是异步编程的典型问题，不能依赖全局变量来传递异步结果。

2. AsyncTask的双重错误 #

• 构造函数调用错误：你定义了两个带参数的构造函数，但调用时用了new checkIfUsable().execute()（无参），Java找不到匹配的无参构造，所以报错“无法解析构造函数”。
• 异步嵌套逻辑错误：即使解决了构造函数问题，Firestore的get()在doInBackground里还是异步的——doInBackground会直接返回null，触发onPostExecute，但此时onSuccessListener还没执行，activity.usable还是初始值，逻辑完全失效。

二、解决方案 #

方法1：使用回调接口（推荐，Java异步编程标准写法） #

定义一个回调接口，把后续逻辑放在回调方法里，确保只有Firestore请求完成后才执行相关操作，完全避免全局变量的依赖。

// 第一步：定义回调接口
public interface OnDocumentCheckListener {
    void onDocumentExists(); // 文档存在时触发
    void onDocumentNotFound(); // 文档不存在时触发
    void onCheckFailed(); // 请求失败时触发（比如网络问题）
}

// 第二步：封装文档检测方法
private void checkDocumentExists(String targetPath, OnDocumentCheckListener listener) {
    FirebaseFirestore.getInstance().document(targetPath)
        .get()
        .addOnSuccessListener(documentSnapshot -> {
            if (documentSnapshot.exists()) {
                listener.onDocumentExists();
            } else {
                listener.onDocumentNotFound();
            }
        })
        .addOnFailureListener(e -> {
            e.printStackTrace();
            listener.onCheckFailed();
        });
}

// 第三步：调用检测方法，在回调里处理业务逻辑
checkDocumentExists("savedSampleData/" + yourTargetString, new OnDocumentCheckListener() {
    @Override
    public void onDocumentExists() {
        // 文档存在的逻辑
        Toast.makeText(Settings.this, R.string.something_went_wrong_use_other_code, Toast.LENGTH_LONG).show();
    }

    @Override
    public void onDocumentNotFound() {
        // 文档不存在，执行你的后续操作
        final SharedPreferences sharedPreferences = getSharedPreferences(SETTINGS_SHARED_PREF_FILE_KEY, Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(PERSONAL_SAMPLE_CODE_KEY, String.valueOf(text));
        editor.apply();
        update();
    }

    @Override
    public void onCheckFailed() {
        Toast.makeText(Settings.this, R.string.something_went_wrong_check_internet, Toast.LENGTH_LONG).show();
    }
});

方法2：使用Tasks.await()实现同步获取（适合习惯同步逻辑的场景） #

如果一定要用同步方式获取结果，可以用Tasks.await()阻塞子线程，等待Firestore请求完成。注意：绝对不能在主线程调用这个方法，否则会导致ANR，所以配合AsyncTask使用：

// 修正后的AsyncTask
private static class CheckIfUsableTask extends AsyncTask<String, Void, Boolean> {
    private WeakReference<Settings> activityReference;

    // 只保留一个构造函数，避免调用混淆
    CheckIfUsableTask(Settings context) {
        activityReference = new WeakReference<>(context);
    }

    @Override
    protected Boolean doInBackground(String... strings) {
        try {
            // 用Tasks.await()同步等待Firestore请求结果
            DocumentReference docRef = FirebaseFirestore.getInstance().document("savedSampleData/" + strings[0]);
            DocumentSnapshot snapshot = Tasks.await(docRef.get());
            return !snapshot.exists(); // 返回是否可用：不存在则返回true
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
            return false; // 请求失败时返回不可用
        }
    }

    @Override
    protected void onPostExecute(Boolean isUsable) {
        Settings activity = activityReference.get();
        if (activity == null) return; // 避免内存泄漏

        if (isUsable) {
            // 文档不存在，执行后续操作
            final SharedPreferences sharedPreferences = activity.getSharedPreferences(SETTINGS_SHARED_PREF_FILE_KEY, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedPreferences.edit();
            editor.putString(PERSONAL_SAMPLE_CODE_KEY, String.valueOf(activity.text));
            editor.apply();
            activity.update();
        } else {
            Toast.makeText(activity, R.string.something_went_wrong_check_internet_or_use_other_code, Toast.LENGTH_LONG).show();
        }
    }
}

// 调用方式：传入当前Activity实例和目标字符串
new CheckIfUsableTask(this).execute(yourTargetString);

三、总结 #

• 优先选择回调接口的方式，它更符合Android异步编程的设计思想，避免线程阻塞和内存泄漏风险。
• 如果使用AsyncTask，一定要避免异步嵌套：要么用Tasks.await()同步获取结果，要么把逻辑完全放在Firestore的回调里，不要依赖onPostExecute。

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