Java 一个接一个地执行回调

我不熟悉用Android Java做异步编程。我想知道是否有一种方法可以在初始回调函数完成后运行另一个回调。现在，我认为它们是并行运行的，尽管第二个依赖于第一个

第一次回调：

// GETTING USER
    private interface FirestoreUserCallback {
        void onCallback (User myUser);
    }

    private void getUser(final FirestoreUserCallback firestoreCallback) {
        Task<DocumentSnapshot> task = fStore.collection("users").document(fAuth.getCurrentUser().getUid()).get();
        task.addOnSuccessListener(new OnSuccessListener<DocumentSnapshot>() {
            @Override
            public void onSuccess(DocumentSnapshot documentSnapshot) {
                user = documentSnapshot.toObject(User.class);
                firestoreCallback.onCallback(user);
                Log.d(TAG, "user created");
            }
        });
        task.addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.d(TAG, "user creation failed");
            }
        });
    }

// GETTING ALL DOCUMENTS
    private interface FirestoreDocumentCallback {
        void onCallback (List<TableEntries> myEntries);
    }

    private void getDocuments (final FirestoreDocumentCallback firestoreDocumentCallback) {
        fStore.collection("result")
                .document(Integer.toString(user.getCompanyNumber())) // need to use User object returned from the first Callback
                .collection("SAM").get()
                .addOnCompleteListener(new OnCompleteListener<QuerySnapshot>() {
                    @Override
                    public void onComplete(@NonNull Task<QuerySnapshot> task) {
                        List<TableEntries> results = new ArrayList<>();
                        if (task.isSuccessful()) {
                            for (QueryDocumentSnapshot document : task.getResult()) {
                                // add objects to results ArrayList ...
                                Log.d(TAG, document.getId() + " => " + document.getData());
                            }
                            firestoreDocumentCallback.onCallback(results);
                        } else {
                            Log.d(TAG, "Error getting documents: ", task.getException());
                        }
                    }
                });
    }

---

回调看起来不错。在访问它之前，您只需要检查您的值是否为null。只需添加一个空检查

 if(doubleValue!=null)

---

回调看起来不错。在访问它之前，您只需要检查您的值是否为null。只需添加一个空检查

 if(doubleValue!=null)

---

使用RxJava。首先，我们获取用户，然后获取文档。Rx Java有一个操作员平面图。flatmap用于执行顺序任务，其中第二个任务依赖于第一个任务的数据

    final CompositeDisposable disposable = new CompositeDisposable();
//function to fetch user data
Single<User> getUser(){
    return API.getUserData(...);
}
//function to fetch ducuments
Sinlge<UserDetail> getDocuments(int userId){
    return API.getUserDetail(userId, ...);
}
//Subscribe
disposable.add(getUser()
    .flatmap(user-> return getDocuments(...))
    .subscribeOn(Scheduler.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribeWith(new DisposableSingleObservable(){
              @Override
              public void onSuccess(UserDetail userDetail){
                  Log.v("Api result", "Successful";
                  //Do some work 
              }
              @Override
              public void onError(Throwable e)
                  Log.v("Api result", "Error Returned");
              }
     }));

final CompositeDisposable disposable=新CompositeDisposable（）；
//函数获取用户数据
单getUser（）{
返回API.getUserData（…）；
}
//函数获取数据
Sinlge getDocuments（int userId）{
返回API.getUserDetail（userId，…）；
}
//订阅
一次性添加（getUser（））
.flatmap（用户->返回getDocuments（…）
.subscribeOn（Scheduler.io（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribowith（新的可处置单可观察（）{
@凌驾
成功时的公共void（UserDetail UserDetail）{
Log.v（“Api结果”，“成功”；
//做些工作
}
@凌驾
公共无效申报人（可丢弃的e）
Log.v（“Api结果”，“返回错误”）；
}
}));

---

如果其中一个API调用失败，则调用onError（）。如果第一个API失败，则不执行第二个API调用，并调用onError（）使用RxJava调用。

。首先，我们获取用户，然后获取文档。RxJava有一个操作符flatmap。flatmap用于执行顺序任务，其中第二个任务依赖于第一个任务的数据

    final CompositeDisposable disposable = new CompositeDisposable();
//function to fetch user data
Single<User> getUser(){
    return API.getUserData(...);
}
//function to fetch ducuments
Sinlge<UserDetail> getDocuments(int userId){
    return API.getUserDetail(userId, ...);
}
//Subscribe
disposable.add(getUser()
    .flatmap(user-> return getDocuments(...))
    .subscribeOn(Scheduler.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribeWith(new DisposableSingleObservable(){
              @Override
              public void onSuccess(UserDetail userDetail){
                  Log.v("Api result", "Successful";
                  //Do some work 
              }
              @Override
              public void onError(Throwable e)
                  Log.v("Api result", "Error Returned");
              }
     }));

final CompositeDisposable disposable=新CompositeDisposable（）；
//函数获取用户数据
单getUser（）{
返回API.getUserData（…）；
}
//函数获取数据
Sinlge getDocuments（int userId）{
返回API.getUserDetail（userId，…）；
}
//订阅
一次性添加（getUser（））
.flatmap（用户->返回getDocuments（…）
.subscribeOn（Scheduler.io（））
.observeOn（AndroidSchedulers.mainThread（））
.subscribowith（新的可处置单可观察（）{
@凌驾
成功时的公共void（UserDetail UserDetail）{
Log.v（“Api结果”，“成功”；
//做些工作
}
@凌驾
公共无效申报人（可丢弃的e）
Log.v（“Api结果”，“返回错误”）；
}
}));

---

如果其中一个API调用失败，将调用onError（）。如果第一个API失败，则不执行第二个API调用并调用onError（）。

对于您的用例，最简单的解决方案是将两个查询都传递给方法，如我在以下帖子中的回答所述：

---

因此，一旦任务完成，您可以使用两个查询中的元素。另一个解决方案可能是使用Android Jetpack，正如Android团队所建议的那样。

对于您的用例，最简单的解决方案是将两个查询传递给方法，如我在以下帖子中的回答所述：

---

因此，一旦任务完成，您可以使用两个查询中的元素。另一个解决方案可能是使用Android Jetpack，正如Android团队所建议的那样。

当您链接回调时，首先要记住的是，您将面临“回调地狱”的情况。这是离题的，但请回答您的问题is如果您依赖于第一个操作的完成来启动第二个操作，那么您应该在第一个操作的回调中编写第二个操作。在您的情况下，您应该从

getUsers

的重写方法

onCallback

中调用

getDocuments

方法，从回调中接收用户对象。谢谢r答案！本质上，我应该移动

getDocuments（）

下面是

user=myUser

？是的，这将解决您的问题，在链接回调时检查它，首先要记住的是，您将以“回调地狱”的情况结束。这是离题的，但您的问题的答案是，如果您依赖于第一个操作来完成第二个操作，那么您应该这样做在第一个操作的回调内编写第二个操作。在您的情况下，您应该从

getUsers

的重写方法

onCallback

调用

getDocuments

方法，在那里您从回调接收用户对象。感谢您的回答！基本上，我应该移动

getDocuments（）<代码>下面的代码>用户= MySux< /Calp>？是的，这将修复您的问题，检查Othi AyRoC618！我能帮助您提供其他信息吗？如果您认为我的答案对您有帮助，请考虑接受它。✔️). 我真的很感激。谢谢！嗨，AyRoC618！我能帮你提供其他信息吗？如果你认为我的答案对你有帮助，请考虑接受它。✔️). 我真的很感激。谢谢！