在 Android 上读取和写入数据

本文将介绍读取和写入 Firebase 数据的基础知识。

Firebase 数据会被写入某个 FirebaseDatabase 引用，并通过在该引用上附加异步侦听器进行检索。该监听器会针对数据的初始状态触发一次，以后只要数据有更改就会再次触发。

注意：默认情况下，对数据库的读写权限是有限制的，只有通过身份验证的用户才能读写数据。如需在未设置身份验证的情况下开始使用数据库，您可以将您的规则配置为允许公开访问。这会使得您的数据库向所有人开放，包括不使用您的应用的用户，因此在设置身份验证时，请务必重新限制对您的数据库的访问权限。

获取 DatabaseReference

要读取或写入数据库数据，您需要一个 DatabaseReference 实例：

Java

private DatabaseReference mDatabase;
// ...
mDatabase = FirebaseDatabase.getInstance().getReference();
NewPostActivity.java

Kotlin+KTX

private lateinit var database: DatabaseReference
// ...
database = Firebase.database.reference
NewPostActivity.kt

读取和写入数据

基本写入操作

对于基本写入操作，您可以使用 setValue() 将数据保存至指定引用，替换该路径中的任何现有数据。您可以使用此方法执行下列操作：

• 传递与可用 JSON 类型对应的类型（如下所示）：
  • String
  • Long
  • Double
  • Boolean
  • Map<String, Object>
  • List<Object>
• 传递自定义 Java 对象（如果定义该对象的类的默认构造函数不接受参数，且该类为要分配的属性提供了公共 getter 方法）。

如果使用 Java 对象，则对象的内容将自动以嵌套方式映射到子位置。使用 Java 对象通常还会提高代码的可读性，使其更易于维护。例如，如果应用包含用户的基本个人资料，则 User 对象可能如下所示：

Java

@IgnoreExtraProperties
public class User {

    public String username;
    public String email;

    public User() {
        // Default constructor required for calls to DataSnapshot.getValue(User.class)
    }

    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }

}
User.java

Kotlin+KTX

@IgnoreExtraProperties
data class User(
    var username: String? = "",
    var email: String? = ""
)
User.kt

您可以使用 setValue() 添加用户，如下所示：

Java

private void writeNewUser(String userId, String name, String email) {
    User user = new User(name, email);

    mDatabase.child("users").child(userId).setValue(user);
}
SignInActivity.java

Kotlin+KTX

private fun writeNewUser(userId: String, name: String, email: String?) {
    val user = User(name, email)
    database.child("users").child(userId).setValue(user)
}
SignInActivity.kt

以这种方式使用 setValue() 将重写指定位置（包括所有子节点）的数据。但是，您仍可在不重写整个对象的情况下更新子节点。如果要允许用户更新其个人资料，您可按照如下所示更新用户名：

Java

mDatabase.child("users").child(userId).child("username").setValue(name);

Kotlin+KTX

database.child("users").child(userId).child("username").setValue(name)

侦听值事件

要读取路径中的数据并侦听更改，您可使用 addValueEventListener() 或 addListenerForSingleValueEvent() 方法，将 ValueEventListener 添加到 DatabaseReference。

侦听器	事件回调函数	典型用法
ValueEventListener	onDataChange()	读取并侦听对路径中所有内容的更改。

您可以使用 onDataChange() 方法来读取给定路径上内容的静态快照，因为这些内容在事件发生时就存在。此方法会在附加侦听器时触发一次，以后会在每次数据（包括子节点数据）发生更改时再次触发。系统会向事件回调函数传递一个包含该位置中所有数据（包括子节点数据）的快照。如果该位置没有任何数据，则当您针对其调用 exists() 时，该快照会返回 false；当您针对其调用 getValue() 时，该快照会返回 null。

重要提示：每当指定的数据库引用中发生数据更改（包括子节点更改）时，系统就会调用 onDataChange() 方法。为了限制快照的大小，请仅在监控更改所需的最高层级附加侦听器。例如，建议不要在数据库的根目录附加侦听器。

以下示例演示了社交博客应用如何从数据库中检索博文详细信息：

Java

ValueEventListener postListener = new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        // Get Post object and use the values to update the UI
        Post post = dataSnapshot.getValue(Post.class);
        // ...
    }

    @Override
    public void onCancelled(DatabaseError databaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException());
        // ...
    }
};
mPostReference.addValueEventListener(postListener);
PostDetailActivity.java

Kotlin+KTX

val postListener = object : ValueEventListener {
    override fun onDataChange(dataSnapshot: DataSnapshot) {
        // Get Post object and use the values to update the UI
        val post = dataSnapshot.getValue<Post>()
        // ...
    }

    override fun onCancelled(databaseError: DatabaseError) {
        // Getting Post failed, log a message
        Log.w(TAG, "loadPost:onCancelled", databaseError.toException())
        // ...
    }
}
postReference.addValueEventListener(postListener)
PostDetailActivity.kt

侦听器接收到一个 DataSnapshot，其中包含事件发生时数据库中指定位置存在的数据。对快照调用 getValue() 时，系统返回数据的 Java 对象表示形式。如果该位置不存在任何数据，则调用 getValue() 将返回 null。

在本示例中，ValueEventListener 还指定了 onCancelled() 方法。当读取操作被取消时，系统会调用该方法。例如，如果客户端没有权限从某一 Firebase 数据库位置读取数据，便可能会取消读取操作。系统会向此方法传递一个 DatabaseError 对象，说明失败的原因。

读取数据一次

在某些情况下，您需要在调用一次回调函数后立即将其移除。例如，在初始化预计不会发生更改的界面元素时就需如此。 您可以使用 addListenerForSingleValueEvent() 方法来简化此场景：该方法会触发一次，之后不会再次触发。

对于只需加载一次且预计不会频繁变化或不需要主动侦听的数据，这种方法非常有用。例如，上述示例中的博客应用就使用了此方法在用户开始撰写新博文时加载其个人资料：

更新或删除数据

更新特定字段

要同时向一个节点的某些特定子节点写入数据，而又不重写其他子节点，请使用 updateChildren() 方法。

调用 updateChildren() 时，您可以通过为键指定路径来更新较低层级的子节点值。如果为了更好地实现扩缩而将数据存储在多个位置，则可使用数据扇出更新这些数据的所有实例。例如，社交博客应用可能具有一个 Post 类，如下所示：

Java

@IgnoreExtraProperties
public class Post {

    public String uid;
    public String author;
    public String title;
    public String body;
    public int starCount = 0;
    public Map<String, Boolean> stars = new HashMap<>();

    public Post() {
        // Default constructor required for calls to DataSnapshot.getValue(Post.class)
    }

    public Post(String uid, String author, String title, String body) {
        this.uid = uid;
        this.author = author;
        this.title = title;
        this.body = body;
    }

    @Exclude
    public Map<String, Object> toMap() {
        HashMap<String, Object> result = new HashMap<>();
        result.put("uid", uid);
        result.put("author", author);
        result.put("title", title);
        result.put("body", body);
        result.put("starCount", starCount);
        result.put("stars", stars);

        return result;
    }

}
Post.java

Kotlin+KTX

@IgnoreExtraProperties
data class Post(
    var uid: String? = "",
    var author: String? = "",
    var title: String? = "",
    var body: String? = "",
    var starCount: Int = 0,
    var stars: MutableMap<String, Boolean> = HashMap()
) {

    @Exclude
    fun toMap(): Map<String, Any?> {
        return mapOf(
                "uid" to uid,
                "author" to author,
                "title" to title,
                "body" to body,
                "starCount" to starCount,
                "stars" to stars
        )
    }
}
Post.kt

要创建一篇博文，然后相应地同时更新近期活动 Feed 和用户活动 Feed，该博客应用需使用如下代码：

Java

private void writeNewPost(String userId, String username, String title, String body) {
    // Create new post at /user-posts/$userid/$postid and at
    // /posts/$postid simultaneously
    String key = mDatabase.child("posts").push().getKey();
    Post post = new Post(userId, username, title, body);
    Map<String, Object> postValues = post.toMap();

    Map<String, Object> childUpdates = new HashMap<>();
    childUpdates.put("/posts/" + key, postValues);
    childUpdates.put("/user-posts/" + userId + "/" + key, postValues);

    mDatabase.updateChildren(childUpdates);
}
NewPostActivity.java

Kotlin+KTX

private fun writeNewPost(userId: String, username: String, title: String, body: String) {
    // Create new post at /user-posts/$userid/$postid and at
    // /posts/$postid simultaneously
    val key = database.child("posts").push().key
    if (key == null) {
        Log.w(TAG, "Couldn't get push key for posts")
        return
    }

    val post = Post(userId, username, title, body)
    val postValues = post.toMap()

    val childUpdates = HashMap<String, Any>()
    childUpdates["/posts/$key"] = postValues
    childUpdates["/user-posts/$userId/$key"] = postValues

    database.updateChildren(childUpdates)
}
NewPostActivity.kt

此示例使用 push() 在包含所有用户博文的节点 (/posts/$postid) 创建了一篇博文，同时使用 getKey() 检索相应键。接着，该键被用于在用户的博文列表 (/user-posts/$userid/$postid) 中创建第二个条目。

通过使用这些路径，只需调用 updateChildren() 一次即可同时更新 JSON 树中的多个位置，此示例就使用了这种方式在两个位置同时创建新博文。通过这种方式进行同时更新属于原子操作：所有更新要么全部成功，要么全部失败。

添加完成回调函数

若想知道数据是何时提交的，可以添加一个完成侦听器。setValue() 和 updateChildren() 均支持完成侦听器（您可视需要添加），当写入的数据被成功提交到数据库后，系统就会调用该完成侦听器。如果调用失败，则系统将向该侦听器传递一个错误对象，说明失败的原因。

Java

mDatabase.child("users").child(userId).setValue(user)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                // Write was successful!
                // ...
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // Write failed
                // ...
            }
        });
ReadAndWriteSnippets.java

Kotlin+KTX

database.child("users").child(userId).setValue(user)
        .addOnSuccessListener {
            // Write was successful!
            // ...
        }
        .addOnFailureListener {
            // Write failed
            // ...
        }
ReadAndWriteSnippets.kt

删除数据

删除数据最简单的方法是对数据所在位置的引用调用 removeValue()。

您也可以指定 null 作为另一个写入操作（如 setValue() 或 updateChildren()）的值来进行删除。您可以将此方法与 updateChildren() 结合使用，在一次 API 调用中删除多个子节点。

分离侦听器

通过对 Firebase 数据库引用调用 removeEventListener() 方法即可移除回调函数。

如果多次将一个侦听器添加到某一数据位置，则每次发生事件时，系统都会多次调用该侦听器，您必须执行相同次数的分离操作才能将其完全移除。

对父节点侦听器调用 removeEventListener() 时不会自动移除在其子节点上注册的侦听器；您还必须对所有子侦听器调用 removeEventListener() 才能移除回调函数。

将数据另存为事务

处理可能因并发修改而损坏的数据（例如，增量计数器）时，您可以使用事务操作。 您需要为此操作提供两个参数：更新函数和可选的完成回调函数。更新函数接受数据的当前状态作为参数，并返回您要写入的新目标状态。如果另一个客户端在您成功写入新值前向该位置写入数据，则系统会使用新的当前值再次调用更新函数，然后重新尝试执行写入操作。

例如，在示例社交博客应用中，您可以允许用户对博文加星和取消加星，并跟踪博文获得的星数，如下所示：

Java

private void onStarClicked(DatabaseReference postRef) {
    postRef.runTransaction(new Transaction.Handler() {
        @Override
        public Transaction.Result doTransaction(MutableData mutableData) {
            Post p = mutableData.getValue(Post.class);
            if (p == null) {
                return Transaction.success(mutableData);
            }

            if (p.stars.containsKey(getUid())) {
                // Unstar the post and remove self from stars
                p.starCount = p.starCount - 1;
                p.stars.remove(getUid());
            } else {
                // Star the post and add self to stars
                p.starCount = p.starCount + 1;
                p.stars.put(getUid(), true);
            }

            // Set value and report transaction success
            mutableData.setValue(p);
            return Transaction.success(mutableData);
        }

        @Override
        public void onComplete(DatabaseError databaseError, boolean committed,
                               DataSnapshot currentData) {
            // Transaction completed
            Log.d(TAG, "postTransaction:onComplete:" + databaseError);
        }
    });
}
PostListFragment.java

Kotlin+KTX

private fun onStarClicked(postRef: DatabaseReference) {
    postRef.runTransaction(object : Transaction.Handler {
        override fun doTransaction(mutableData: MutableData): Transaction.Result {
            val p = mutableData.getValue(Post::class.java)
                    ?: return Transaction.success(mutableData)

            if (p.stars.containsKey(uid)) {
                // Unstar the post and remove self from stars
                p.starCount = p.starCount - 1
                p.stars.remove(uid)
            } else {
                // Star the post and add self to stars
                p.starCount = p.starCount + 1
                p.stars[uid] = true
            }

            // Set value and report transaction success
            mutableData.value = p
            return Transaction.success(mutableData)
        }

        override fun onComplete(
            databaseError: DatabaseError?,
            committed: Boolean,
            currentData: DataSnapshot?
        ) {
            // Transaction completed
            Log.d(TAG, "postTransaction:onComplete:" + databaseError!!)
        }
    })
}
PostListFragment.kt

如果多个用户同时对同一博文加星或客户端存在过时数据，使用事务可防止加星计数出错。如果事务遭拒绝，则服务器会将当前值返回到客户端，然后客户端会使用更新后的值再次运行事务。此过程将反复进行，直到事务被接受或尝试次数过多为止。

注意：doTransaction() 会被多次调用，因此它必须能够处理 null 数据。即使远程数据库中已有数据，这些数据也可能不会在事务函数运行时缓存到本地，因而导致初始值为 null。

离线写入数据

如果客户端的网络连接中断，您的应用将继续正常运行。

对于所有有效数据，连接到 Firebase 数据库的每个客户端均维护着各自的内部版本。数据在写入时，首先会写入这一本地版本。然后，Firebase 客户端会尽可能将这些数据与远程数据库服务器以及其他客户端同步。

因此，对数据库执行的所有写入操作会立即触发本地事件，然后数据才会写入服务器。这意味着应用仍将保持随时响应的状态，无论网络延迟或连接状况如何。

连接重新建立之后，您的应用将收到一系列相应的事件，以便客户端与当前服务器状态进行同步，您并不需要编写任何自定义代码。

后续步骤

• 处理数据列表
• 了解如何设计数据结构