如何确保一个firebase查找的完整处理程序在另一个壁炉查找之前完成

Question

我有以下firebase DB节点结构：

UserInGroup
    --- GroupID
      --- UserId : true/false  


Users
    --- UserId
      --- Username : String
      --- ...


GroupStatus
    --- GroupId
      --- UserId: true/false    

我需要拉动第一个节点以获取组中的所有用户

，然后使用该信息获取用户帐户信息详细信息，

最终检查以查看组中的用户

状态在Java/Android中实现完成的方法？我已经为iOS提供了完整的手机。

谁能帮助我在Java中实施解决方案？

----更新----

我已经完成了以下操作：

// Create an interface to init all the callback functions
private interface AllUsersCallback {

    void onSuccess(DataSnapshot dataSnapshot);

    void onStart();

    void onFailure();

}

private void readData(Query query, AllUsersActivity.AllUsersCallback listener) {

    listener.onStart();

    query.addListenerForSingleValueEvent(new ValueEventListener() {

        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {

            if (dataSnapshot.exists()) {

                listener.onSuccess(dataSnapshot);

            } else { // dataSnapshot doesn't exist

            }

        }

        @Override
        public void onCancelled(DatabaseError databaseError) {

            Log.d(TAG, databaseError.getMessage());
            //
            listener.onFailure();

        }

    });

}

最后是活动视图：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Init ArrayList
    userList = new ArrayList<>();

    userInGroupReference = mFirebaseDatabase.getReference("GroupUsers");

    userInGroupQuery = userInGroupReference.child(groupID).orderByValue().equalTo(true);

    // Completion Handler for Lookups
    readData(userInGroupQuery, new AllUsersActivity.AllUsersCallback() {

        @Override
        public void onSuccess(DataSnapshot dataSnapshot) {

            // Clear the List (remove dupes)
            userList.clear();

            for (DataSnapshot snapshot : dataSnapshot.getChildren()) {

                String userId = snapshot.getKey();
               
                // Call function to set usernames to the users
                setUsername(userId); 

            }

            /*
              THIS ALWAYS COMES OUT BLANK!? <--------
            */
            for (int i = 0; i < userList.size(); i++) {

                Log.e(TAG,"List element: " + userList.get(i).getUsername());

            }

        }

        @Override
        public void onStart() {

            // When starting
            Log.d("ONSTART", "Started");

        }

        @Override
        public void onFailure() {

            // If failed
            Log.d("onFailure", "Failed");

        }

    });

}

以及用于将用户用户名设置为用户列表的功能：

public void setUsername(String userId) {

    userReference = mFirebaseDatabase.getReference("Users");

    userQuery = userReference.child(userId).child("username");

    // Add handle for listener
    userQuery.addListenerForSingleValueEvent(new ValueEventListener() {

        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {

            if (dataSnapshot.exists()) {

                String username = dataSnapshot.getValue().toString();

                AllUsers result = new AllUsers(username);
                
                userList.add(result);

            }

        }

        @Override
        public void onCancelled(DatabaseError databaseError) {

        }

    });

}

Answer 1

这些数据库调用是异步 - 回调代码不会立即运行，将来可以在您实际获取数据时运行一段时间。

链条多个依赖性异步查询的最简单方法是将每个查询放入其自身的函数中，并将其从因查询的回调中调用。在您的情况下，您可能会一次运行多个回调，因此，在每个回调完成时，您可以检查要完成的检查，并通过将列表的大小与启动的查询数进行比较来检查所有这些回调。

例如：

private ArrayList<String> userList = new ArrayList<>();
private int numUsers = 0;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    
    // other setup stuff
    startInitialQuery();
}

private void startInitialQuery() {
    // make your initial query
    
    query.addListenerForSingleValueEvent(new ValueEventListener() {

        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            if (dataSnapshot.exists()) {
                userList.clear();
                numUsers = 0; // dataSnapshot.getChildren().size();
                
                // If the size() call above works, use that, otherwise
                // you can count the number of children this way.
                for(DataSnapshot snap : dataSnapshot.getChildren()) {
                    ++numUsers;
                }   
                
                for(DataSnapshot snap : dataSnapshot.getChildren()) {
                    String userId = snap.getKey();
                    readUser(userId);
                }
            }
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            Log.d(TAG, databaseError.getMessage());
        }
    });
}

private void readUser(String userId) {

    // make userQuery using "userId" input
    
    userQuery.addListenerForSingleValueEvent(new ValueEventListener() {

        @Override
        public void onDataChange(DataSnapshot dataSnapshot) {
            if (dataSnapshot.exists()) {
                String username = dataSnapshot.getValue().toString();
                userList.add(username);
                checkLoaded();
            }
            else {
                --numUsers;
                checkLoaded();
            }
        }

        @Override
        public void onCancelled(DatabaseError databaseError) {
            Log.d(TAG, databaseError.getMessage());
            --numUsers;
            checkLoaded();
        }
    });
}

private void checkLoaded() {
    if( userList.size() == numUsers ) {
        // All done getting users! Show a toast, update a view, etc...
    }
}

或者，如果您切换到使用Kotlin和Coroutines，则可以将其写成非常简单的线性暂停功能您实际上可以使不同的任务等待。

更清洁但更具侵入性的变化将是将所有这些都移至包含每个步骤中的Livedata的ViewModel。当收到数据时，您将其发布到Livedata，UI可以观察并做出相应的反应（例如，更新视图，触发下一个呼叫等）。

Update

这是一个示例，展示了如何使用ViewModel和Livedata进行此操作

public class MainViewModel extends ViewModel {
    private final MutableLiveData<List<String>> users = new MutableLiveData<>();
    LiveData<List<String>> getUsers() {
        return users;
    }

    private final ArrayList<String> userList = new ArrayList<>();

    void startFetchingData() {
        // build query
        query.addListenerForSingleValueEvent(new ValueEventListener() {

            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                if (dataSnapshot.exists()) {
                    userList.clear();

                    for(DataSnapshot snap : dataSnapshot.getChildren()) {
                        String userId = snap.getKey();
                        readUser(userId);
                    }
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
                Log.d(TAG, databaseError.getMessage());
            }
        });
    }


    private void readUser(String userId) {
        // build userQuery
        userQuery.addListenerForSingleValueEvent(new ValueEventListener() {

            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                if (dataSnapshot.exists()) {
                    String username = dataSnapshot.getValue().toString();
                    userList.add(username);
                    users.postValue(userList);
                }
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
                Log.d(TAG, databaseError.getMessage());
            }
        });
    }
}

，并且在活动中，您为Livedata设置了一个观察者，该观察者随时在数据更改时通知。

model = new ViewModelProvider(this).get(MainViewModel.class);

final Observer<List<String>> userObserver = userList -> {
    // Update the UI, or call something else
    // this will get called every time the list of users is
    // updated in the ViewModel
    System.out.println("TEST: got data " + userList);
};

// Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
model.getUsers().observe(this, userObserver);

model.startFetchingData();