Android中FirebaseRecyclerAdapter多数据库引用查询优化问题

Hey there! Let's figure out a better way to handle this Firebase Realtime Database scenario you're dealing with. Using multiple addValueEventListener calls for each chat key is definitely not ideal—it can clutter up your code, cause unnecessary network requests, and even lead to memory leaks if you're not careful. Here are a few optimized approaches you can try:

1. Optimize Listener Usage in Your FirebaseRecyclerAdapter's ViewHolder #

Since you already have a FirebaseRecyclerAdapter pulling chat keys from users/firebase_user_uid/chats, you can load the corresponding chat details directly in your ViewHolder—but with proper listener management to avoid issues:

• Use addListenerForSingleValueEvent if you only need to load the chat data once (no real-time updates). This reduces ongoing network traffic compared to a persistent listener.
• If you do need real-time updates, attach a ValueEventListener when binding the ViewHolder, and remove it when the ViewHolder is recycled to prevent memory leaks.

Here's a quick code snippet to illustrate this:

public class ChatViewHolder extends RecyclerView.ViewHolder {
    private TextView chatType;
    private TextView createdTime;
    private DatabaseReference chatRef;
    private ValueEventListener chatListener;

    public ChatViewHolder(View itemView) {
        super(itemView);
        chatType = itemView.findViewById(R.id.chat_type);
        createdTime = itemView.findViewById(R.id.created_time);
    }

    public void bind(String chatKey) {
        // Clean up any existing listener first
        if (chatListener != null) {
            chatRef.removeEventListener(chatListener);
        }

        chatRef = FirebaseDatabase.getInstance().getReference("chats").child(chatKey);
        chatListener = chatRef.addValueEventListener(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                if (snapshot.exists()) {
                    String type = snapshot.child("chattype").getValue(String.class);
                    long time = snapshot.child("createdTime").getValue(Long.class);
                    chatType.setText(type);
                    createdTime.setText(new Date(time).toString());
                }
            }

            @Override
            public void onCancelled(DatabaseError error) {
                // Handle error (e.g., log it or show a toast)
            }
        });
    }

    // Call this when the ViewHolder is recycled to clean up listeners
    public void cleanup() {
        if (chatListener != null) {
            chatRef.removeEventListener(chatListener);
        }
    }
}

Then in your adapter, override onViewRecycled to trigger the cleanup:

@Override
public void onViewRecycled(@NonNull ChatViewHolder holder) {
    super.onViewRecycled(holder);
    holder.cleanup();
}

2. Denormalize Your Data (Firebase's Recommended Approach) #

The most efficient long-term solution is to duplicate critical chat data into the user's chat list node. This aligns with Firebase's design philosophy of optimizing for read performance by denormalizing data.

Instead of just storing chat keys under users/firebase_user_uid/chats, store a small subset of the chat's details alongside the key:

"users": {
  "firebase_user_uid": {
    "chats": {
      "chat_key_1": {
        "chattype": "group",
        "createdTime": 1699999999,
        "lastMessage": "Hey there!"
      },
      "chat_key_2": {
        "chattype": "private",
        "createdTime": 1699998888,
        "lastMessage": "See you soon!"
      }
    }
  }
}

This way, your existing FirebaseRecyclerAdapter can directly access chattype and createdTime without any additional queries. You'll just need to sync this data whenever the chat details are updated—use Firebase's runTransaction or batch updates to keep both the chats/{chat_key} and users/{uid}/chats/{chat_key} nodes in sync.

3. Use a Single ChildEventListener on the Chats Node #

If denormalization isn't an option right now, you can reduce the number of listeners by using a single ChildEventListener on the root chats node, filtered to only the chat keys your user has access to:

1. First, fetch all chat keys from users/firebase_user_uid/chats and store them in a Set<String>.
2. Attach a ChildEventListener to chats, and only process events for keys that exist in your set.

Example code:

// First get the user's chat keys
FirebaseDatabase.getInstance().getReference("users/firebase_user_uid/chats")
        .addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot snapshot) {
                Set<String> userChatKeys = new HashSet<>();
                for (DataSnapshot chatKeySnapshot : snapshot.getChildren()) {
                    userChatKeys.add(chatKeySnapshot.getKey());
                }

                // Now listen to the chats node for only these keys
                FirebaseDatabase.getInstance().getReference("chats")
                        .addChildEventListener(new ChildEventListener() {
                            @Override
                            public void onChildAdded(DataSnapshot snapshot, String previousChildName) {
                                String chatKey = snapshot.getKey();
                                if (userChatKeys.contains(chatKey)) {
                                    // Process the chat data (chattype, createdTime)
                                    String type = snapshot.child("chattype").getValue(String.class);
                                    long time = snapshot.child("createdTime").getValue(Long.class);
                                    // Update your UI with this data
                                }
                            }

                            @Override
                            public void onChildChanged(DataSnapshot snapshot, String previousChildName) {
                                // Handle updates to existing chats your user has
                                String chatKey = snapshot.getKey();
                                if (userChatKeys.contains(chatKey)) {
                                    // Update UI with new data
                                }
                            }

                            // Implement other ChildEventListener methods as needed
                            @Override
                            public void onChildRemoved(DataSnapshot snapshot) {}
                            @Override
                            public void onChildMoved(DataSnapshot snapshot, String previousChildName) {}
                            @Override
                            public void onCancelled(DatabaseError error) {}
                        });
            }

            @Override
            public void onCancelled(DatabaseError error) {
                // Handle error
            }
        });

Final Recommendation #

Denormalization is hands down the best approach here—it minimizes network requests, simplifies your code, and plays to Firebase's strengths. If you can adjust your data structure to include the necessary chat details in the user's chat list, you'll see the biggest performance and maintainability gains.

内容的提问来源于stack exchange，提问作者marcelo.wdrb