(ไม่บังคับ) สร้างต้นแบบและทดสอบด้วย Firebase Emulator Suite
ก่อนที่จะพูดถึงวิธีที่แอปของคุณอ่านและเขียนไปยังฐานข้อมูลแบบเรียลไทม์ เรามาแนะนำชุดเครื่องมือที่คุณสามารถใช้เพื่อสร้างต้นแบบและทดสอบฟังก์ชันการทำงานของฐานข้อมูลแบบเรียลไทม์: Firebase Emulator Suite หากคุณกำลังทดลองใช้โมเดลข้อมูลต่างๆ เพิ่มประสิทธิภาพกฎความปลอดภัยของคุณ หรือทำงานเพื่อค้นหาวิธีที่คุ้มค่าที่สุดในการโต้ตอบกับแบ็คเอนด์ ความสามารถในการทำงานในพื้นที่โดยไม่ต้องปรับใช้บริการสดอาจเป็นแนวคิดที่ดี
โปรแกรมจำลองฐานข้อมูลเรียลไทม์เป็นส่วนหนึ่งของ Emulator Suite ซึ่งช่วยให้แอปของคุณสามารถโต้ตอบกับเนื้อหาและการกำหนดค่าฐานข้อมูลที่จำลองของคุณ รวมถึงทรัพยากรโปรเจ็กต์ที่จำลอง (ฟังก์ชัน ฐานข้อมูลอื่น และกฎความปลอดภัย) ที่คุณเลือกได้) emulator_suite_short
การใช้โปรแกรมจำลองฐานข้อมูลเรียลไทม์มีเพียงไม่กี่ขั้นตอน:
- การเพิ่มบรรทัดโค้ดลงในการกำหนดค่าทดสอบของแอปเพื่อเชื่อมต่อกับโปรแกรมจำลอง
- จากรูทของไดเร็กทอรีโปรเจ็กต์ในเครื่องของคุณ ให้รัน
firebase emulators:start
- โทรออกจากโค้ดต้นแบบของแอปโดยใช้ Realtime Database Platform SDK ตามปกติ หรือใช้ Realtime Database REST API
มี คำแนะนำโดยละเอียดเกี่ยวกับฐานข้อมูลเรียลไทม์และฟังก์ชันคลาวด์ ให้บริการ คุณควรดู การแนะนำ Emulator Suite ด้วย
รับการอ้างอิงฐานข้อมูล
หากต้องการอ่านหรือเขียนข้อมูลจากฐานข้อมูล คุณต้องมีอินสแตนซ์ของ DatabaseReference
:
DatabaseReference ref = FirebaseDatabase.instance.ref();
เขียนข้อมูล
เอกสารนี้ครอบคลุมพื้นฐานการอ่านและการเขียนข้อมูล Firebase
ข้อมูล Firebase ถูกเขียนไปยัง DatabaseReference
และดึงข้อมูลโดยการรอหรือฟังเหตุการณ์ที่ปล่อยออกมาจากการอ้างอิง เหตุการณ์ต่างๆ จะถูกปล่อยออกมาหนึ่งครั้งสำหรับสถานะเริ่มต้นของข้อมูล และอีกครั้งทุกครั้งที่ข้อมูลมีการเปลี่ยนแปลง
การดำเนินการเขียนขั้นพื้นฐาน
สำหรับการดำเนินการเขียนขั้นพื้นฐาน คุณสามารถใช้ set()
เพื่อบันทึกข้อมูลลงในการอ้างอิงที่ระบุ โดยแทนที่ข้อมูลที่มีอยู่ในเส้นทางนั้น คุณสามารถตั้งค่าการอ้างอิงเป็นประเภทต่อไปนี้: String
, boolean
, int
, double
, Map
, List
ตัวอย่างเช่น คุณสามารถเพิ่มผู้ใช้ด้วย set()
ดังนี้:
DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");
await ref.set({
"name": "John",
"age": 18,
"address": {
"line1": "100 Mountain View"
}
});
การใช้ set()
ในลักษณะนี้จะเขียนทับข้อมูลที่ตำแหน่งที่ระบุ รวมถึงโหนดลูกด้วย อย่างไรก็ตาม คุณยังคงสามารถอัปเดตรายการย่อยได้โดยไม่ต้องเขียนออบเจ็กต์ใหม่ทั้งหมด หากคุณต้องการอนุญาตให้ผู้ใช้อัปเดตโปรไฟล์ของตน คุณสามารถอัปเดตชื่อผู้ใช้ได้ดังนี้:
DatabaseReference ref = FirebaseDatabase.instance.ref("users/123");
// Only update the name, leave the age and address!
await ref.update({
"age": 19,
});
เมธอด update()
ยอมรับพาธย่อยไปยังโหนด ซึ่งช่วยให้คุณสามารถอัปเดตหลายโหนดในฐานข้อมูลได้ในคราวเดียว:
DatabaseReference ref = FirebaseDatabase.instance.ref("users");
await ref.update({
"123/age": 19,
"123/address/line1": "1 Mountain View",
});
อ่านข้อมูล
อ่านข้อมูลโดยการฟังเหตุการณ์คุณค่า
หากต้องการอ่านข้อมูลที่เส้นทางและฟังการเปลี่ยนแปลง ให้ใช้คุณสมบัติ onValue
ของ DatabaseReference
เพื่อฟัง DatabaseEvent
คุณสามารถใช้ DatabaseEvent
เพื่ออ่านข้อมูลในเส้นทางที่กำหนดตามที่มีอยู่ ณ เวลาที่เกิดเหตุการณ์ เหตุการณ์นี้จะถูกทริกเกอร์หนึ่งครั้งเมื่อมีการแนบ Listener และจะเกิดขึ้นอีกครั้งทุกครั้งที่ข้อมูล รวมถึงรายการลูกๆ มีการเปลี่ยนแปลง กิจกรรมมีคุณสมบัติ snapshot
ที่มีข้อมูลทั้งหมดในตำแหน่งนั้น รวมถึงข้อมูลลูกด้วย หากไม่มีข้อมูล คุณสมบัติ exists
ของสแน็ปช็อตจะเป็น false
และคุณสมบัติ value
จะเป็นโมฆะ
ตัวอย่างต่อไปนี้สาธิตแอปพลิเคชันบล็อกโซเชียลที่ดึงรายละเอียดของโพสต์จากฐานข้อมูล:
DatabaseReference starCountRef =
FirebaseDatabase.instance.ref('posts/$postId/starCount');
starCountRef.onValue.listen((DatabaseEvent event) {
final data = event.snapshot.value;
updateStarCount(data);
});
ผู้ฟังได้รับ DataSnapshot
ที่มีข้อมูล ณ ตำแหน่งที่ระบุในฐานข้อมูล ณ เวลาที่เกิดเหตุการณ์ในคุณสมบัติ value
อ่านข้อมูลครั้งเดียว
อ่านครั้งเดียวโดยใช้ get()
SDK ได้รับการออกแบบมาเพื่อจัดการการโต้ตอบกับเซิร์ฟเวอร์ฐานข้อมูล ไม่ว่าแอปของคุณจะออนไลน์หรือออฟไลน์
โดยทั่วไป คุณควรใช้เทคนิคเหตุการณ์คุณค่าที่อธิบายไว้ข้างต้นเพื่ออ่านข้อมูลเพื่อรับการแจ้งเตือนการอัปเดตข้อมูลจากแบ็กเอนด์ เทคนิคเหล่านี้ช่วยลดการใช้งานและการเรียกเก็บเงินของคุณ และได้รับการปรับปรุงเพื่อให้ผู้ใช้ของคุณได้รับประสบการณ์ที่ดีที่สุดขณะออนไลน์และออฟไลน์
หากคุณต้องการข้อมูลเพียงครั้งเดียว คุณสามารถใช้ get()
เพื่อรับสแน็ปช็อตข้อมูลจากฐานข้อมูล หาก get()
ไม่สามารถส่งคืนค่าเซิร์ฟเวอร์ไม่ว่าด้วยเหตุผลใดก็ตาม ไคลเอนต์จะตรวจสอบแคชที่เก็บข้อมูลในเครื่องและส่งกลับข้อผิดพลาดหากยังคงไม่พบค่า
ตัวอย่างต่อไปนี้สาธิตการเรียกชื่อผู้ใช้ที่เปิดเผยต่อสาธารณะของผู้ใช้ในครั้งเดียวจากฐานข้อมูล:
final ref = FirebaseDatabase.instance.ref();
final snapshot = await ref.child('users/$userId').get();
if (snapshot.exists) {
print(snapshot.value);
} else {
print('No data available.');
}
การใช้ get()
โดยไม่จำเป็นสามารถเพิ่มการใช้แบนด์วิดท์และทำให้ประสิทธิภาพลดลง ซึ่งสามารถป้องกันได้โดยใช้ตัวฟังแบบเรียลไทม์ดังที่แสดงไว้ด้านบน
อ่านข้อมูลครั้งเดียวด้วย Once()
ในบางกรณี คุณอาจต้องการให้ค่าจากแคชในเครื่องส่งคืนทันที แทนที่จะตรวจสอบค่าที่อัปเดตบนเซิร์ฟเวอร์ ในกรณีดังกล่าว คุณสามารถใช้ once()
เพื่อรับข้อมูลจากแคชในดิสก์ในเครื่องได้ทันที
สิ่งนี้มีประโยชน์สำหรับข้อมูลที่จำเป็นต้องโหลดเพียงครั้งเดียวและไม่คาดว่าจะเปลี่ยนแปลงบ่อยหรือต้องมีการฟังอย่างต่อเนื่อง ตัวอย่างเช่น แอปบล็อกในตัวอย่างก่อนหน้านี้ใช้วิธีนี้ในการโหลดโปรไฟล์ของผู้ใช้เมื่อพวกเขาเริ่มเขียนโพสต์ใหม่:
final event = await ref.once(DatabaseEventType.value);
final username = event.snapshot.value?.username ?? 'Anonymous';
การอัปเดตหรือการลบข้อมูล
อัปเดตฟิลด์เฉพาะ
หากต้องการเขียนไปยังโหนดย่อยเฉพาะของโหนดพร้อมกันโดยไม่ต้องเขียนทับโหนดย่อยอื่น ๆ ให้ใช้เมธอด update()
เมื่อเรียก update()
คุณสามารถอัปเดตค่าลูกระดับล่างได้โดยการระบุเส้นทางสำหรับคีย์ หากข้อมูลถูกจัดเก็บไว้ในหลายตำแหน่งเพื่อให้ปรับขนาดได้ดีขึ้น คุณสามารถอัปเดต อินสแตนซ์ทั้งหมดของข้อมูลนั้นได้โดยใช้การกระจายข้อมูล ตัวอย่างเช่น แอปบล็อกโซเชียลอาจต้องการสร้างโพสต์และอัปเดตเป็นฟีดกิจกรรมล่าสุดและฟีดกิจกรรมของผู้ใช้ที่โพสต์ไปพร้อมๆ กัน เมื่อต้องการทำเช่นนี้ แอปพลิเคชันบล็อกจะใช้โค้ดดังนี้:
void writeNewPost(String uid, String username, String picture, String title,
String body) async {
// A post entry.
final postData = {
'author': username,
'uid': uid,
'body': body,
'title': title,
'starCount': 0,
'authorPic': picture,
};
// Get a key for a new Post.
final newPostKey =
FirebaseDatabase.instance.ref().child('posts').push().key;
// Write the new post's data simultaneously in the posts list and the
// user's post list.
final Map<String, Map> updates = {};
updates['/posts/$newPostKey'] = postData;
updates['/user-posts/$uid/$newPostKey'] = postData;
return FirebaseDatabase.instance.ref().update(updates);
}
ตัวอย่างนี้ใช้ push()
เพื่อสร้างโพสต์ในโหนดที่มีโพสต์สำหรับผู้ใช้ทุกคนที่ /posts/$postid
และดึงข้อมูลคีย์พร้อม ๆ กันด้วย key
จากนั้นคีย์จะสามารถนำมาใช้เพื่อสร้างรายการที่สองในโพสต์ของผู้ใช้ที่ /user-posts/$userid/$postid
เมื่อใช้เส้นทางเหล่านี้ คุณสามารถอัปเดตสถานที่หลายแห่งในแผนผัง JSON ได้พร้อมกันด้วยการเรียก update()
เพียงครั้งเดียว เช่น วิธีสร้างโพสต์ใหม่ในตัวอย่างนี้ในทั้งสองสถานที่ การอัปเดตพร้อมกันที่ทำในลักษณะนี้เป็นแบบอะตอมมิก: การอัปเดตทั้งหมดสำเร็จหรือการอัปเดตทั้งหมดล้มเหลว
เพิ่มการโทรกลับที่เสร็จสมบูรณ์
หากคุณต้องการทราบว่าข้อมูลของคุณได้รับการยืนยันเมื่อใด คุณสามารถลงทะเบียนการเรียกกลับที่เสร็จสมบูรณ์ได้ ทั้ง set()
และ update()
ส่งคืน Future
s ซึ่งคุณสามารถแนบการเรียกกลับที่สำเร็จและข้อผิดพลาดที่จะถูกเรียกเมื่อการเขียนถูกส่งไปยังฐานข้อมูลและเมื่อการโทรไม่สำเร็จ
FirebaseDatabase.instance
.ref('users/$userId/email')
.set(emailAddress)
.then((_) {
// Data saved successfully!
})
.catchError((error) {
// The write failed...
});
ลบข้อมูล
วิธีที่ง่ายที่สุดในการลบข้อมูลคือการเรียก remove()
เพื่ออ้างอิงตำแหน่งของข้อมูลนั้น
คุณยังสามารถลบได้โดยการระบุค่า null เป็นค่าสำหรับการดำเนินการเขียนอื่น เช่น set()
หรือ update()
คุณสามารถใช้เทคนิคนี้ร่วมกับ update()
เพื่อลบลูกหลายคนในการเรียก API ครั้งเดียว
บันทึกข้อมูลเป็นธุรกรรม
เมื่อทำงานกับข้อมูลที่อาจเสียหายจากการแก้ไขที่เกิดขึ้นพร้อมกัน เช่น ตัวนับส่วนเพิ่ม คุณสามารถใช้ธุรกรรมได้โดยส่งตัวจัดการธุรกรรมไปที่ runTransaction()
ตัวจัดการธุรกรรมใช้สถานะปัจจุบันของข้อมูลเป็นอาร์กิวเมนต์และส่งกลับสถานะใหม่ที่คุณต้องการเขียน หากไคลเอนต์อื่นเขียนไปยังตำแหน่งก่อนที่จะเขียนค่าใหม่ของคุณสำเร็จ ฟังก์ชันอัปเดตของคุณจะถูกเรียกอีกครั้งด้วยค่าปัจจุบันใหม่ และลองเขียนอีกครั้ง
ตัวอย่างเช่น ในแอปบล็อกโซเชียลตัวอย่าง คุณสามารถอนุญาตให้ผู้ใช้ติดดาวและเลิกติดดาวโพสต์ และติดตามจำนวนดาวที่โพสต์ได้รับดังนี้:
void toggleStar(String uid) async {
DatabaseReference postRef =
FirebaseDatabase.instance.ref("posts/foo-bar-123");
TransactionResult result = await postRef.runTransaction((Object? post) {
// Ensure a post at the ref exists.
if (post == null) {
return Transaction.abort();
}
Map<String, dynamic> _post = Map<String, dynamic>.from(post as Map);
if (_post["stars"] is Map && _post["stars"][uid] != null) {
_post["starCount"] = (_post["starCount"] ?? 1) - 1;
_post["stars"][uid] = null;
} else {
_post["starCount"] = (_post["starCount"] ?? 0) + 1;
if (!_post.containsKey("stars")) {
_post["stars"] = {};
}
_post["stars"][uid] = true;
}
// Return the new data.
return Transaction.success(_post);
});
}
ตามค่าเริ่มต้น เหตุการณ์จะถูกยกขึ้นทุกครั้งที่ฟังก์ชันอัพเดตธุรกรรมทำงาน ดังนั้นคุณจึงเรียกใช้ฟังก์ชันหลายครั้ง คุณอาจเห็นสถานะระดับกลาง คุณสามารถตั้ง applyLocally
เป็น false
เพื่อระงับสถานะระดับกลางเหล่านี้ และรอจนกว่าธุรกรรมจะเสร็จสมบูรณ์ก่อนที่เหตุการณ์จะเกิดขึ้น:
await ref.runTransaction((Object? post) {
// ...
}, applyLocally: false);
ผลลัพธ์ของธุรกรรมคือ TransactionResult
ซึ่งมีข้อมูล เช่น การทำธุรกรรมเกิดขึ้นหรือไม่ และสแน็ปช็อตใหม่:
DatabaseReference ref = FirebaseDatabase.instance.ref("posts/123");
TransactionResult result = await ref.runTransaction((Object? post) {
// ...
});
print('Committed? ${result.committed}'); // true / false
print('Snapshot? ${result.snapshot}'); // DataSnapshot
การยกเลิกธุรกรรม
หากคุณต้องการยกเลิกธุรกรรมอย่างปลอดภัย ให้โทร Transaction.abort()
เพื่อส่ง AbortTransactionException
:
TransactionResult result = await ref.runTransaction((Object? user) {
if (user !== null) {
return Transaction.abort();
}
// ...
});
print(result.committed); // false
การเพิ่มขึ้นฝั่งเซิร์ฟเวอร์แบบอะตอมมิก
ในกรณีการใช้งานข้างต้น เรากำลังเขียนค่าสองค่าลงในฐานข้อมูล ได้แก่ ID ของผู้ใช้ที่ติดดาว/ไม่ติดดาวโพสต์ และจำนวนดาวที่เพิ่มขึ้น หากเรารู้อยู่แล้วว่าผู้ใช้กำลังแสดงโพสต์ เราสามารถใช้การดำเนินการเพิ่มแบบอะตอมมิกแทนธุรกรรมได้
void addStar(uid, key) async {
Map<String, Object?> updates = {};
updates["posts/$key/stars/$uid"] = true;
updates["posts/$key/starCount"] = ServerValue.increment(1);
updates["user-posts/$key/stars/$uid"] = true;
updates["user-posts/$key/starCount"] = ServerValue.increment(1);
return FirebaseDatabase.instance.ref().update(updates);
}
รหัสนี้ไม่ได้ใช้การดำเนินการธุรกรรม ดังนั้นจึงไม่ได้รับการรันใหม่โดยอัตโนมัติหากมีการอัปเดตที่ขัดแย้งกัน อย่างไรก็ตาม เนื่องจากการดำเนินการเพิ่มเกิดขึ้นโดยตรงบนเซิร์ฟเวอร์ฐานข้อมูล จึงไม่มีโอกาสที่จะเกิดข้อขัดแย้ง
หากคุณต้องการตรวจจับและปฏิเสธข้อขัดแย้งเฉพาะแอปพลิเคชัน เช่น ผู้ใช้ที่นำแสดงโดยโพสต์ที่พวกเขาติดดาวไว้ก่อนหน้านี้ คุณควรเขียนกฎความปลอดภัยที่กำหนดเองสำหรับกรณีการใช้งานนั้น
ทำงานกับข้อมูลแบบออฟไลน์
หากไคลเอ็นต์ขาดการเชื่อมต่อเครือข่าย แอปของคุณจะทำงานต่อไปได้อย่างถูกต้อง
ไคลเอนต์ทุกตัวที่เชื่อมต่อกับฐานข้อมูล Firebase จะรักษาเวอร์ชันภายในของข้อมูลที่ใช้งานอยู่ เมื่อมีการเขียนข้อมูล ข้อมูลจะถูกเขียนลงในเวอร์ชันท้องถิ่นนี้ก่อน จากนั้นไคลเอนต์ Firebase จะซิงโครไนซ์ข้อมูลนั้นกับเซิร์ฟเวอร์ฐานข้อมูลระยะไกลและกับไคลเอนต์อื่น ๆ ตาม "ความพยายามอย่างดีที่สุด"
ด้วยเหตุนี้ การเขียนทั้งหมดไปยังฐานข้อมูลจะทริกเกอร์เหตุการณ์ภายในเครื่องทันที ก่อนที่ข้อมูลใดๆ จะถูกเขียนไปยังเซิร์ฟเวอร์ ซึ่งหมายความว่าแอปของคุณยังคงตอบสนองโดยไม่คำนึงถึงเวลาแฝงของเครือข่ายหรือการเชื่อมต่อ
เมื่อสร้างการเชื่อมต่ออีกครั้ง แอปของคุณจะได้รับชุดเหตุการณ์ที่เหมาะสมเพื่อให้ไคลเอ็นต์ซิงค์กับสถานะเซิร์ฟเวอร์ปัจจุบัน โดยไม่ต้องเขียนโค้ดที่กำหนดเองใดๆ
เราจะพูดคุยเพิ่มเติมเกี่ยวกับพฤติกรรมออฟไลน์ใน เรียนรู้เพิ่มเติมเกี่ยวกับความสามารถออนไลน์และออฟไลน์