在 Android 上讀取和寫入數據

本文檔涵蓋了讀取和寫入 Firebase 數據的基礎知識。

Firebase 數據被寫入FirebaseDatabase引用,並通過將異步偵聽器附加到引用來檢索。偵聽器會針對數據的初始狀態觸發一次,並在數據更改時再次觸發。

(可選)使用 Firebase 本地模擬器套件進行原型設計和測試

在討論您的應用如何讀取和寫入實時數據庫之前,讓我們介紹一組可用於原型化和測試實時數據庫功能的工具:Firebase Local Emulator Suite。如果您正在嘗試不同的數據模型,優化您的安全規則,或努力尋找與後端交互的最具成本效益的方式,那麼無需部署實時服務即可在本地工作可能是一個好主意。

實時數據庫模擬器是本地模擬器套件的一部分,它使您的應用程序能夠與您的模擬數據庫內容和配置以及您的模擬項目資源(函數、其他數據庫和安全規則)進行交互。

使用實時數據庫模擬器只需幾個步驟:

  1. 在應用程序的測試配置中添加一行代碼以連接到模擬器。
  2. 從本地項目目錄的根目錄運行firebase emulators:start
  3. 像往常一樣使用實時數據庫平台 SDK 或使用實時數據庫 REST API 從應用程序的原型代碼進行調用。

提供了涉及實時數據庫和雲函數的詳細演練。您還應該查看Local Emulator Suite 介紹

獲取數據庫引用

要從數據庫讀取或寫入數據,您需要一個DatabaseReference實例:

爪哇

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

科特林+KTX

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

寫入數據

基本寫操作

對於基本的寫入操作,您可以使用setValue()將數據保存到指定的引用,替換該路徑中的任何現有數據。您可以使用此方法:

  • 傳遞與可用 JSON 類型相對應的類型,如下所示:
    • String
    • Long
    • Double
    • Boolean
    • Map<String, Object>
    • List<Object>
  • 如果定義它的類具有不帶參數的默認構造函數並且具有用於分配屬性的公共 getter,則傳遞自定義 Java 對象。

如果使用 Java 對象,則對象的內容會自動以嵌套方式映射到子位置。使用 Java 對象通常還可以使您的代碼更具可讀性和更易於維護。例如,如果您有一個具有基本用戶配置文件的應用程序,您的User對象可能如下所示:

爪哇

@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;
    }

}

科特林+KTX

@IgnoreExtraProperties
data class User(val username: String? = null, val email: String? = null) {
    // Null default values create a no-argument default constructor, which is needed
    // for deserialization from a DataSnapshot.
}

您可以使用setValue()添加用戶,如下所示:

爪哇

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

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

科特林+KTX

fun writeNewUser(userId: String, name: String, email: String) {
    val user = User(name, email)

    database.child("users").child(userId).setValue(user)
}

以這種方式使用setValue()會覆蓋指定位置的數據,包括任何子節點。但是,您仍然可以在不重寫整個對象的情況下更新子對象。如果您想允許用戶更新他們的個人資料,您可以按如下方式更新用戶名:

爪哇

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

科特林+KTX

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

讀取數據

使用持久監聽器讀取數據

要讀取路徑中的數據並偵聽更改,請使用addValueEventListener()方法將ValueEventListener添加到DatabaseReference

聽眾事件回調典型用法
ValueEventListener onDataChange()閱讀並監聽路徑全部內容的變化。

您可以使用onDataChange()方法讀取給定路徑中內容的靜態快照,因為它們在事件發生時就存在。此方法在附加偵聽器時觸發一次,並且在每次數據(包括子項)發生更改時再次觸發。事件回調被傳遞一個快照,其中包含該位置的所有數據,包括子數據。如果沒有數據,則調用exists()時快照將返回false ,調用getValue()時返回null

以下示例演示了一個社交博客應用程序從數據庫中檢索帖子的詳細信息:

爪哇

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);

科特林+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)

偵聽器收到一個DataSnapshot ,其中包含事件發生時數據庫中指定位置的數據。對快照調用getValue()會返回數據的 Java 對象表示。如果該位置不存在數據,則調用getValue()將返回null

在此示例中, ValueEventListener還定義了在取消讀取時調用的 onCancelled onCancelled()方法。例如,如果客戶端無權從 Firebase 數據庫位置讀取,則可以取消讀取。此方法傳遞一個DatabaseError對象,指示失敗發生的原因。

讀取數據一次

使用 get() 讀取一次

SDK 旨在管理與數據庫服務器的交互,無論您的應用程序是在線還是離線。

通常,您應該使用上述ValueEventListener技術來讀取數據,以便從後端獲取數據更新的通知。偵聽器技術可減少您的使用量和計費,並經過優化以在您的用戶在線和離線時為他們提供最佳體驗。

如果您只需要一次數據,您可以使用get()從數據庫中獲取數據的快照。如果由於任何原因get()無法返回服務器值,客戶端將探測本地存儲緩存,如果仍未找到該值,則返回錯誤。

不必要地使用get()會增加帶寬的使用並導致性能損失,這可以通過使用實時偵聽器來防止,如上所示。

爪哇

mDatabase.child("users").child(userId).get().addOnCompleteListener(new OnCompleteListener<DataSnapshot>() {
    @Override
    public void onComplete(@NonNull Task<DataSnapshot> task) {
        if (!task.isSuccessful()) {
            Log.e("firebase", "Error getting data", task.getException());
        }
        else {
            Log.d("firebase", String.valueOf(task.getResult().getValue()));
        }
    }
});

科特林+KTX

mDatabase.child("users").child(userId).get().addOnSuccessListener {
    Log.i("firebase", "Got value ${it.value}")
}.addOnFailureListener{
    Log.e("firebase", "Error getting data", it)
}

使用監聽器讀取一次

在某些情況下,您可能希望立即返回本地緩存中的值,而不是檢查服務器上的更新值。在這些情況下,您可以使用addListenerForSingleValueEvent立即從本地磁盤緩存中獲取數據。

這對於只需要加載一次並且預計不會頻繁更改或需要主動偵聽的數據很有用。例如,前面示例中的博客應用程序使用此方法在用戶開始創作新帖子時加載他們的個人資料。

更新或刪除數據

更新特定字段

要同時寫入節點的特定子節點而不覆蓋其他子節點,請使用updateChildren()方法。

調用updateChildren()時,您可以通過指定鍵的路徑來更新較低級別的子值。如果數據存儲在多個位置以更好地擴展,您可以使用data fan-out更新該數據的所有實例。例如,一個社交博客應用程序可能有一個Post類,如下所示:

爪哇

@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;
    }
}

科特林+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
        )
    }
}

要創建帖子並同時將其更新為最近的活動提要和發布用戶的活動提要,博客應用程序使用如下代碼:

爪哇

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);
}

科特林+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 = hashMapOf<String, Any>(
            "/posts/$key" to postValues,
            "/user-posts/$userId/$key" to postValues
    )

    database.updateChildren(childUpdates)
}

此示例使用push()在包含/posts/$postid的所有用戶的帖子的節點中創建帖子,並同時使用getKey()檢索密鑰。然後可以使用該密鑰在/user-posts/$userid/$postid的用戶帖子中創建第二個條目。

使用這些路徑,您可以通過一次調用updateChildren()來同時更新 JSON 樹中的多個位置,例如此示例如何在兩個位置創建新帖子。以這種方式進行的同時更新是原子的:要么所有更新都成功,要么所有更新都失敗。

添加完成回調

如果您想知道您的數據何時提交,您可以添加一個完成偵聽器。 setValue()updateChildren()都採用一個可選的完成偵聽器,當寫入成功提交到數據庫時調用該偵聽器。如果調用不成功,則向偵聽器傳遞一個指示失敗原因的錯誤對象。

爪哇

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
                // ...
            }
        });

科特林+KTX

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

刪除數據

刪除數據的最簡單方法是在對該數據位置的引用上調用removeValue()

您還可以通過將null指定為另一個寫入操作(例如setValue()updateChildren()的值來刪除。您可以將此技術與updateChildren()一起使用,以在單個 API 調用中刪除多個子項。

分離監聽器

通過在 Firebase 數據庫引用上調用removeEventListener()方法來刪除回調。

如果已將偵聽器多次添加到數據位置,則每個事件都會多次調用它,並且您必須將其分離相同的次數才能將其完全刪除。

在父偵聽器上調用removeEventListener()不會自動刪除在其子節點上註冊的偵聽器;還必須在任何子偵聽器上調用removeEventListener()以刪除回調。

將數據保存為事務

當處理可能被並發修改破壞的數據時,例如增量計數器,您可以使用事務操作。你給這個操作兩個參數:一個更新函數和一個可選的完成回調。更新函數將數據的當前狀態作為參數,並返回您想要寫入的新狀態。如果另一個客戶端在您的新值成功寫入之前寫入該位置,則使用新的當前值再次調用您的更新函數,並重試寫入。

例如,在示例社交博客應用程序中,您可以允許用戶為帖子加註星標和取消加註星標,並跟踪帖子獲得的星數,如下所示:

爪哇

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);
        }
    });
}

科特林+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!!)
        }
    })
}

如果多個用戶同時為同一個帖子加註星標或客戶端的數據過時,使用事務可以防止星標計數不正確。如果事務被拒絕,服務器將當前值返回給客戶端,客戶端使用更新後的值再次運行事務。這會重複,直到交易被接受或進行了太多嘗試。

原子服務器端增量

在上面的用例中,我們將兩個值寫入數據庫:為帖子加星/取消星標的用戶的 ID,以及增加的星數。如果我們已經知道用戶正在為帖子加註星標,我們可以使用原子增量操作而不是事務。

爪哇

private void onStarClicked(String uid, String key) {
    Map<String, Object> updates = new HashMap<>();
    updates.put("posts/"+key+"/stars/"+uid, true);
    updates.put("posts/"+key+"/starCount", ServerValue.increment(1));
    updates.put("user-posts/"+uid+"/"+key+"/stars/"+uid, true);
    updates.put("user-posts/"+uid+"/"+key+"/starCount", ServerValue.increment(1));
    mDatabase.updateChildren(updates);
}

科特林+KTX

private fun onStarClicked(uid: String, key: String) {
    val updates: MutableMap<String, Any> = HashMap()
    updates["posts/$key/stars/$uid"] = true
    updates["posts/$key/starCount"] = ServerValue.increment(1)
    updates["user-posts/$uid/$key/stars/$uid"] = true
    updates["user-posts/$uid/$key/starCount"] = ServerValue.increment(1)
    database.updateChildren(updates)
}

此代碼不使用事務操作,因此如果存在衝突更新,它不會自動重新運行。但是,由於增量操作直接發生在數據庫服務器上,因此不會發生衝突。

如果您想檢測和拒絕特定於應用程序的衝突,例如用戶為他們之前已加註星標的帖子加註星標,您應該為該用例編寫自定義安全規則。

離線處理數據

如果客戶端失去其網絡連接,您的應用程序將繼續正常運行。

每個連接到 Firebase 數據庫的客戶端都維護自己的內部版本,其中包含正在使用偵聽器或標記為與服務器保持同步的任何數據。讀取或寫入數據時,首先使用該數據的本地版本。然後,Firebase 客戶端會在“盡力而為”的基礎上將該數據與遠程數據庫服務器和其他客戶端同步。

因此,在與服務器進行任何交互之前,對數據庫的所有寫入都會立即觸發本地事件。這意味著無論網絡延遲或連接如何,您的應用都會保持響應。

重新建立連接後,您的應用程序會收到一組適當的事件,以便客戶端與當前服務器狀態同步,而無需編寫任何自定義代碼。

我們將在了解有關在線和離線功能的更多信息中詳細討論離線行為。

下一步