เอกสารนี้ครอบคลุมพื้นฐานการอ่านและการเขียนข้อมูล Firebase
ข้อมูล Firebase ถูกเขียนไปยังการอ้างอิง FirebaseDatabase
และดึงข้อมูลโดยการแนบ Listener แบบอะซิงโครนัสเข้ากับการอ้างอิง Listener จะถูกทริกเกอร์หนึ่งครั้งสำหรับสถานะเริ่มต้นของข้อมูล และอีกครั้งทุกครั้งที่ข้อมูลมีการเปลี่ยนแปลง
(ไม่บังคับ) สร้างต้นแบบและทดสอบด้วย Firebase Local Emulator Suite
ก่อนที่จะพูดถึงวิธีที่แอปของคุณอ่านและเขียนไปยังฐานข้อมูลเรียลไทม์ เรามาแนะนำชุดเครื่องมือที่คุณสามารถใช้เพื่อสร้างต้นแบบและทดสอบฟังก์ชันการทำงานของฐานข้อมูลเรียลไทม์: Firebase Local Emulator Suite หากคุณกำลังทดลองใช้โมเดลข้อมูลต่างๆ เพิ่มประสิทธิภาพกฎความปลอดภัยของคุณ หรือทำงานเพื่อค้นหาวิธีที่คุ้มค่าที่สุดในการโต้ตอบกับแบ็คเอนด์ ความสามารถในการทำงานในพื้นที่โดยไม่ต้องปรับใช้บริการสดอาจเป็นแนวคิดที่ดี
โปรแกรมจำลองฐานข้อมูลแบบเรียลไทม์เป็นส่วนหนึ่งของ Local Emulator Suite ซึ่งช่วยให้แอปของคุณโต้ตอบกับเนื้อหาและการกำหนดค่าฐานข้อมูลที่จำลองได้ รวมถึงทรัพยากรโปรเจ็กต์ที่จำลอง (ฟังก์ชัน ฐานข้อมูลอื่นๆ และกฎความปลอดภัย)
การใช้โปรแกรมจำลองฐานข้อมูลเรียลไทม์มีเพียงไม่กี่ขั้นตอน:
- การเพิ่มบรรทัดโค้ดลงในการกำหนดค่าทดสอบของแอปเพื่อเชื่อมต่อกับโปรแกรมจำลอง
- จากรากของไดเร็กทอรีโปรเจ็กต์ในเครื่องของคุณ ให้รัน
firebase emulators:start
- โทรออกจากโค้ดต้นแบบของแอปโดยใช้ Realtime Database Platform SDK ตามปกติ หรือใช้ Realtime Database REST API
มี คำแนะนำโดยละเอียดเกี่ยวกับฐานข้อมูลเรียลไทม์และฟังก์ชันคลาวด์ ให้บริการ คุณควรดู การแนะนำ Local Emulator Suite ด้วย
รับการอ้างอิงฐานข้อมูล
หากต้องการอ่านหรือเขียนข้อมูลจากฐานข้อมูล คุณต้องมีอินสแตนซ์ของ DatabaseReference
:
Kotlin+KTX
private lateinit var database: DatabaseReference // ... database = Firebase.database.reference
Java
private DatabaseReference mDatabase; // ... mDatabase = FirebaseDatabase.getInstance().getReference();
เขียนข้อมูล
การดำเนินการเขียนขั้นพื้นฐาน
สำหรับการดำเนินการเขียนขั้นพื้นฐาน คุณสามารถใช้ setValue()
เพื่อบันทึกข้อมูลลงในการอ้างอิงที่ระบุ โดยแทนที่ข้อมูลใดๆ ที่มีอยู่ในเส้นทางนั้น คุณสามารถใช้วิธีนี้เพื่อ:
- ประเภทรหัสผ่านที่สอดคล้องกับประเภท JSON ที่มีอยู่ดังต่อไปนี้:
-
String
-
Long
-
Double
-
Boolean
-
Map<String, Object>
-
List<Object>
-
- ส่งผ่านอ็อบเจ็กต์ Java แบบกำหนดเอง หากคลาสที่กำหนดมีคอนสตรัคเตอร์ดีฟอลต์ที่รับอาร์กิวเมนต์และมีตัวรับสาธารณะสำหรับคุณสมบัติที่จะกำหนด
หากคุณใช้ออบเจ็กต์ Java เนื้อหาของออบเจ็กต์ของคุณจะถูกแมปกับตำแหน่งลูกโดยอัตโนมัติในลักษณะที่ซ้อนกัน โดยทั่วไปแล้วการใช้อ็อบเจ็กต์ Java จะทำให้โค้ดของคุณสามารถอ่านได้ง่ายขึ้นและดูแลรักษาได้ง่ายขึ้น ตัวอย่างเช่น หากคุณมีแอพที่มีโปรไฟล์ผู้ใช้พื้นฐาน ออบเจ็กต์ User
ของคุณอาจมีลักษณะดังนี้:
Kotlin+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. }
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; } }
คุณสามารถเพิ่มผู้ใช้ด้วย setValue()
ได้ดังนี้:
Kotlin+KTX
fun writeNewUser(userId: String, name: String, email: String) { val user = User(name, email) database.child("users").child(userId).setValue(user) }
Java
public void writeNewUser(String userId, String name, String email) { User user = new User(name, email); mDatabase.child("users").child(userId).setValue(user); }
การใช้ setValue()
ในลักษณะนี้จะเขียนทับข้อมูลที่ตำแหน่งที่ระบุ รวมถึงโหนดย่อยด้วย อย่างไรก็ตาม คุณยังคงสามารถอัปเดตรายการย่อยได้โดยไม่ต้องเขียนออบเจ็กต์ใหม่ทั้งหมด หากคุณต้องการอนุญาตให้ผู้ใช้อัปเดตโปรไฟล์ของตน คุณสามารถอัปเดตชื่อผู้ใช้ได้ดังนี้:
Kotlin+KTX
database.child("users").child(userId).child("username").setValue(name)
Java
mDatabase.child("users").child(userId).child("username").setValue(name);
อ่านข้อมูล
อ่านข้อมูลกับผู้ฟังอย่างต่อเนื่อง
หากต้องการอ่านข้อมูลที่เส้นทางและรับฟังการเปลี่ยนแปลง ให้ใช้เมธอด addValueEventListener()
เพื่อเพิ่ม ValueEventListener
ให้กับ DatabaseReference
ผู้ฟัง | โทรกลับเหตุการณ์ | การใช้งานทั่วไป |
---|---|---|
ValueEventListener | onDataChange() | อ่านและฟังการเปลี่ยนแปลงเนื้อหาทั้งหมดของเส้นทาง |
คุณสามารถใช้เมธอด onDataChange()
เพื่ออ่านสแน็ปช็อตแบบคงที่ของเนื้อหาในเส้นทางที่กำหนด ตามที่มีอยู่ ณ เวลาที่เกิดเหตุการณ์ วิธีการนี้จะถูกทริกเกอร์หนึ่งครั้งเมื่อมีการแนบ Listener และอีกครั้งทุกครั้งที่ข้อมูล รวมถึงลูกๆ มีการเปลี่ยนแปลง การเรียกกลับเหตุการณ์จะถูกส่งผ่านสแน็ปช็อตที่มีข้อมูลทั้งหมด ณ ตำแหน่งนั้น รวมถึงข้อมูลลูกด้วย หากไม่มีข้อมูล สแน็ปช็อตจะส่งคืน false
เมื่อคุณเรียกใช้ exists()
และ null
เมื่อคุณเรียกใช้ getValue()
ตัวอย่างต่อไปนี้สาธิตแอปพลิเคชันบล็อกโซเชียลที่ดึงรายละเอียดของโพสต์จากฐานข้อมูล:
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)
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);
ผู้ฟังจะได้รับ DataSnapshot
ที่มีข้อมูลในตำแหน่งที่ระบุในฐานข้อมูล ณ เวลาที่เกิดเหตุการณ์ การเรียก getValue()
บนสแน็ปช็อตจะส่งคืนการแสดงอ็อบเจ็กต์ Java ของข้อมูล หากไม่มีข้อมูลอยู่ที่ตำแหน่งนั้น การเรียก getValue()
จะส่งคืน null
ในตัวอย่างนี้ ValueEventListener
ยังกำหนดเมธอด onCancelled()
ที่ถูกเรียกหากการอ่านถูกยกเลิก ตัวอย่างเช่น คุณสามารถยกเลิกการอ่านได้หากไคลเอ็นต์ไม่มีสิทธิ์อ่านจากตำแหน่งฐานข้อมูล Firebase วิธีการนี้ถูกส่งผ่านวัตถุ DatabaseError
บ่งชี้ว่าเหตุใดจึงเกิดความล้มเหลว
อ่านข้อมูลครั้งเดียว
อ่านครั้งเดียวโดยใช้ get()
SDK ได้รับการออกแบบมาเพื่อจัดการการโต้ตอบกับเซิร์ฟเวอร์ฐานข้อมูล ไม่ว่าแอปของคุณจะออนไลน์หรือออฟไลน์
โดยทั่วไป คุณควรใช้เทคนิค ValueEventListener
ที่อธิบายไว้ข้างต้นเพื่ออ่านข้อมูลเพื่อรับการแจ้งเตือนการอัปเดตข้อมูลจากแบ็กเอนด์ เทคนิค Listener ช่วยลดการใช้งานและการเรียกเก็บเงินของคุณ และได้รับการปรับปรุงเพื่อให้ผู้ใช้ของคุณได้รับประสบการณ์ที่ดีที่สุดขณะออนไลน์และออฟไลน์
หากคุณต้องการข้อมูลเพียงครั้งเดียว คุณสามารถใช้ get()
เพื่อรับสแน็ปช็อตข้อมูลจากฐานข้อมูล หาก get()
ไม่สามารถส่งคืนค่าเซิร์ฟเวอร์ไม่ว่าด้วยเหตุผลใดก็ตาม ไคลเอนต์จะตรวจสอบแคชที่เก็บข้อมูลในเครื่องและส่งกลับข้อผิดพลาดหากยังคงไม่พบค่า
การใช้ get()
โดยไม่จำเป็นสามารถเพิ่มการใช้แบนด์วิดท์และทำให้ประสิทธิภาพลดลง ซึ่งสามารถป้องกันได้โดยใช้ตัวฟังแบบเรียลไทม์ดังที่แสดงไว้ด้านบน
Kotlin+KTX
mDatabase.child("users").child(userId).get().addOnSuccessListener {
Log.i("firebase", "Got value ${it.value}")
}.addOnFailureListener{
Log.e("firebase", "Error getting data", it)
}
Java
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()));
}
}
});
อ่านครั้งเดียวโดยใช้ผู้ฟัง
ในบางกรณี คุณอาจต้องการให้ค่าจากแคชในเครื่องส่งคืนทันที แทนที่จะตรวจสอบค่าที่อัปเดตบนเซิร์ฟเวอร์ ในกรณีดังกล่าว คุณสามารถใช้ addListenerForSingleValueEvent
เพื่อรับข้อมูลจากแคชในดิสก์ในเครื่องได้ทันที
สิ่งนี้มีประโยชน์สำหรับข้อมูลที่จำเป็นต้องโหลดเพียงครั้งเดียวและไม่คาดว่าจะเปลี่ยนแปลงบ่อยหรือต้องมีการฟังอย่างต่อเนื่อง ตัวอย่างเช่น แอปบล็อกในตัวอย่างก่อนหน้านี้ใช้วิธีนี้ในการโหลดโปรไฟล์ของผู้ใช้เมื่อพวกเขาเริ่มเขียนโพสต์ใหม่
การอัปเดตหรือการลบข้อมูล
อัปเดตฟิลด์เฉพาะ
หากต้องการเขียนไปยังโหนดย่อยที่ระบุพร้อมกันโดยไม่ต้องเขียนทับโหนดย่อยอื่นๆ ให้ใช้เมธอด updateChildren()
เมื่อเรียก updateChildren()
คุณสามารถอัปเดตค่าลูกระดับล่างได้โดยการระบุเส้นทางสำหรับคีย์ หากข้อมูลถูกจัดเก็บไว้ในหลายตำแหน่งเพื่อให้ปรับขนาดได้ดีขึ้น คุณสามารถอัปเดต อินสแตนซ์ทั้งหมดของข้อมูลนั้นได้โดยใช้การกระจายข้อมูล ตัวอย่างเช่น แอปบล็อกโซเชียลอาจมีคลาส Post
ในลักษณะนี้:
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, ) } }
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; } }
หากต้องการสร้างโพสต์และอัปเดตเป็นฟีดกิจกรรมล่าสุดและฟีดกิจกรรมของผู้ใช้ที่โพสต์ไปพร้อมกัน แอปพลิเคชันบล็อกจะใช้โค้ดดังนี้:
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 = hashMapOf<String, Any>( "/posts/$key" to postValues, "/user-posts/$userId/$key" to postValues, ) database.updateChildren(childUpdates) }
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); }
ตัวอย่างนี้ใช้ push()
เพื่อสร้างโพสต์ในโหนดที่มีโพสต์สำหรับผู้ใช้ทุกคนที่ /posts/$postid
และดึงข้อมูลคีย์พร้อมกันด้วย getKey()
จากนั้นคีย์จะสามารถนำมาใช้เพื่อสร้างรายการที่สองในโพสต์ของผู้ใช้ที่ /user-posts/$userid/$postid
เมื่อใช้เส้นทางเหล่านี้ คุณจะอัปเดตสถานที่หลายแห่งในแผนผัง JSON พร้อมกันได้ด้วยการเรียก updateChildren()
เพียงครั้งเดียว เช่น วิธีสร้างโพสต์ใหม่ในตัวอย่างนี้ในทั้งสองสถานที่ การอัปเดตพร้อมกันที่ทำในลักษณะนี้เป็นแบบอะตอมมิก: การอัปเดตทั้งหมดสำเร็จหรือการอัปเดตทั้งหมดล้มเหลว
เพิ่มการโทรกลับที่เสร็จสมบูรณ์
หากคุณต้องการทราบว่าข้อมูลของคุณได้รับการยืนยันเมื่อใด คุณสามารถเพิ่ม Listener ที่สมบูรณ์ได้ ทั้ง setValue()
และ updateChildren()
ใช้ Listener การเติมคำสั่งเสริมซึ่งจะถูกเรียกเมื่อมีการคอมมิตการเขียนไปยังฐานข้อมูลสำเร็จแล้ว หากการโทรไม่สำเร็จ ผู้ฟังจะถูกส่งผ่านอ็อบเจ็กต์ข้อผิดพลาดซึ่งระบุว่าเหตุใดจึงเกิดความล้มเหลว
Kotlin+KTX
database.child("users").child(userId).setValue(user) .addOnSuccessListener { // Write was successful! // ... } .addOnFailureListener { // Write failed // ... }
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 // ... } });
ลบข้อมูล
วิธีที่ง่ายที่สุดในการลบข้อมูลคือการเรียก removeValue()
เพื่ออ้างอิงตำแหน่งของข้อมูลนั้น
คุณยังสามารถลบได้โดยระบุ null
เป็นค่าสำหรับการดำเนินการเขียนอื่น เช่น setValue()
หรือ updateChildren()
คุณสามารถใช้เทคนิคนี้กับ updateChildren()
เพื่อลบชายด์หลายคนในการเรียก API ครั้งเดียว
แยกผู้ฟังออก
การเรียกกลับจะถูกลบออกโดยการเรียกเมธอด removeEventListener()
ในการอ้างอิงฐานข้อมูล Firebase ของคุณ
หากมีการเพิ่ม Listener หลายครั้งในตำแหน่งข้อมูล ระบบจะเรียกหลายครั้งสำหรับแต่ละเหตุการณ์ และคุณต้องแยกออกในจำนวนเท่าเดิมจึงจะลบออกทั้งหมดได้
การเรียก removeEventListener()
บน Listener หลักจะไม่ลบ Listener ที่ลงทะเบียนบนโหนดลูกโดยอัตโนมัติ นอกจากนี้ จะต้องเรียกใช้ removeEventListener()
บน Listener ระดับย่อยเพื่อลบการโทรกลับ
บันทึกข้อมูลเป็นธุรกรรม
เมื่อทำงานกับข้อมูลที่อาจเสียหายจากการแก้ไขที่เกิดขึ้นพร้อมกัน เช่น ตัวนับส่วนเพิ่ม คุณสามารถใช้ การดำเนินการธุรกรรม ได้ คุณให้การดำเนินการนี้สองอาร์กิวเมนต์: ฟังก์ชันอัปเดตและตัวเลือกการโทรกลับให้เสร็จสิ้น ฟังก์ชั่นอัพเดตใช้สถานะปัจจุบันของข้อมูลเป็นอาร์กิวเมนต์และส่งกลับสถานะใหม่ที่คุณต้องการเขียน หากไคลเอนต์อื่นเขียนไปยังตำแหน่งก่อนที่จะเขียนค่าใหม่ของคุณสำเร็จ ฟังก์ชันอัปเดตของคุณจะถูกเรียกอีกครั้งด้วยค่าปัจจุบันใหม่ และลองเขียนอีกครั้ง
ตัวอย่างเช่น ในแอปบล็อกโซเชียลตัวอย่าง คุณสามารถอนุญาตให้ผู้ใช้ติดดาวและเลิกติดดาวโพสต์ และติดตามจำนวนดาวที่โพสต์ได้รับดังนี้:
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!!) } }) }
Java
private void onStarClicked(DatabaseReference postRef) { postRef.runTransaction(new Transaction.Handler() { @NonNull @Override public Transaction.Result doTransaction(@NonNull 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); } }); }
การใช้ธุรกรรมจะป้องกันไม่ให้การนับดาวไม่ถูกต้อง หากผู้ใช้หลายรายติดดาวโพสต์เดียวกันในเวลาเดียวกัน หรือลูกค้ามีข้อมูลเก่า หากธุรกรรมถูกปฏิเสธ เซิร์ฟเวอร์จะส่งคืนค่าปัจจุบันไปยังไคลเอนต์ ซึ่งจะดำเนินการธุรกรรมอีกครั้งด้วยมูลค่าที่อัปเดต สิ่งนี้จะเกิดขึ้นซ้ำจนกว่าธุรกรรมจะได้รับการยอมรับหรือมีความพยายามมากเกินไป
การเพิ่มขึ้นฝั่งเซิร์ฟเวอร์แบบอะตอมมิก
ในกรณีการใช้งานข้างต้น เรากำลังเขียนค่าสองค่าลงในฐานข้อมูล ได้แก่ ID ของผู้ใช้ที่ติดดาว/ไม่ติดดาวโพสต์ และจำนวนดาวที่เพิ่มขึ้น หากเรารู้อยู่แล้วว่าผู้ใช้กำลังแสดงโพสต์ เราสามารถใช้การดำเนินการเพิ่มแบบอะตอมมิกแทนธุรกรรมได้
Kotlin+KTX
private fun onStarClicked(uid: String, key: String) { val updates: MutableMap<String, Any> = hashMapOf( "posts/$key/stars/$uid" to true, "posts/$key/starCount" to ServerValue.increment(1), "user-posts/$uid/$key/stars/$uid" to true, "user-posts/$uid/$key/starCount" to ServerValue.increment(1), ) database.updateChildren(updates) }
Java
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); }
รหัสนี้ไม่ได้ใช้การดำเนินการธุรกรรม ดังนั้นจึงไม่ได้รับการรันใหม่โดยอัตโนมัติหากมีการอัปเดตที่ขัดแย้งกัน อย่างไรก็ตาม เนื่องจากการดำเนินการเพิ่มเกิดขึ้นโดยตรงบนเซิร์ฟเวอร์ฐานข้อมูล จึงไม่มีโอกาสที่จะเกิดข้อขัดแย้ง
หากคุณต้องการตรวจจับและปฏิเสธข้อขัดแย้งเฉพาะแอปพลิเคชัน เช่น ผู้ใช้ที่นำแสดงโดยโพสต์ที่พวกเขาติดดาวไว้ก่อนหน้านี้ คุณควรเขียนกฎความปลอดภัยที่กำหนดเองสำหรับกรณีการใช้งานนั้น
ทำงานกับข้อมูลแบบออฟไลน์
หากไคลเอ็นต์ขาดการเชื่อมต่อเครือข่าย แอปของคุณจะทำงานต่อไปได้อย่างถูกต้อง
ไคลเอนต์ทุกตัวที่เชื่อมต่อกับฐานข้อมูล Firebase จะรักษาเวอร์ชันภายในของข้อมูลใด ๆ ที่ Listener ถูกใช้หรือถูกตั้งค่าสถานะเพื่อให้ซิงค์กับเซิร์ฟเวอร์ เมื่ออ่านหรือเขียนข้อมูล ระบบจะใช้ข้อมูลเวอร์ชันภายในเครื่องนี้ก่อน จากนั้นไคลเอนต์ Firebase จะซิงโครไนซ์ข้อมูลนั้นกับเซิร์ฟเวอร์ฐานข้อมูลระยะไกลและกับไคลเอนต์อื่น ๆ ตาม "ความพยายามอย่างดีที่สุด"
ด้วยเหตุนี้ การเขียนทั้งหมดไปยังฐานข้อมูลจะทริกเกอร์เหตุการณ์ภายในเครื่องทันที ก่อนที่จะโต้ตอบกับเซิร์ฟเวอร์ ซึ่งหมายความว่าแอปของคุณยังคงตอบสนองโดยไม่คำนึงถึงเวลาแฝงของเครือข่ายหรือการเชื่อมต่อ
เมื่อสร้างการเชื่อมต่ออีกครั้ง แอปของคุณจะได้รับชุดเหตุการณ์ที่เหมาะสมเพื่อให้ไคลเอนต์ซิงค์กับสถานะเซิร์ฟเวอร์ปัจจุบัน โดยไม่ต้องเขียนโค้ดที่กำหนดเองใดๆ
เราจะพูดคุยเพิ่มเติมเกี่ยวกับพฤติกรรมออฟไลน์ใน เรียนรู้เพิ่มเติมเกี่ยวกับความสามารถออนไลน์และออฟไลน์