หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

อ่านและเขียนข้อมูลบน Android

เอกสารนี้ครอบคลุมพื้นฐานของการอ่านและการเขียนข้อมูล Firebase

ข้อมูล Firebase ถูกเขียนไปยังการอ้างอิง FirebaseDatabase และดึงข้อมูลโดยการแนบผู้ฟังแบบอะซิงโครนัสกับการอ้างอิง ฟังจะถูกเรียกหนึ่งครั้งสำหรับสถานะเริ่มต้นของข้อมูลและอีกครั้งทุกครั้งที่มีการเปลี่ยนแปลงข้อมูล

รับ DatabaseReference

หากต้องการอ่านหรือเขียนข้อมูลจากฐานข้อมูลคุณต้องใช้อินสแตนซ์ของ DatabaseReference :

ชวา

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

Kotlin + KTX

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

อ่านและเขียนข้อมูล

การดำเนินการเขียนขั้นพื้นฐาน

สำหรับการดำเนินการเขียนขั้นพื้นฐานคุณสามารถใช้ setValue() เพื่อบันทึกข้อมูลเป็นข้อมูลอ้างอิงที่ระบุแทนที่ข้อมูลที่มีอยู่ที่พา ธ นั้น คุณสามารถใช้วิธีนี้เพื่อ:

  • ประเภท Pass ที่สอดคล้องกับประเภท JSON ที่มีอยู่ดังต่อไปนี้:
    • String
    • Long
    • Double
    • Boolean
    • Map<String, Object>
    • List<Object>
  • ส่งผ่านออบเจ็กต์ 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;
    }

}

Kotlin + KTX

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

คุณสามารถเพิ่มผู้ใช้ด้วย setValue() ดังต่อไปนี้:

ชวา

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

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

Kotlin + KTX

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

Kotlin + KTX

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

ฟังเหตุการณ์ที่มีคุณค่า

หากต้องการอ่านข้อมูลที่พา ธ และรับฟังการเปลี่ยนแปลงให้ใช้วิธีการ addValueEventListener() หรือ addListenerForSingleValueEvent() เพื่อเพิ่ม ValueEventListener ให้กับ DatabaseReference

ผู้ฟัง โทรกลับเหตุการณ์ การใช้งานทั่วไป
ValueEventListener onDataChange() อ่านและฟังการเปลี่ยนแปลงเนื้อหาทั้งหมดของพา ธ

คุณสามารถใช้ onDataChange() เพื่ออ่านสแนปชอตแบบสแตติกของเนื้อหาในพา ธ ที่กำหนดเนื่องจากมีอยู่ในเวลาของเหตุการณ์ วิธีการนี้จะถูกทริกเกอร์หนึ่งครั้งเมื่อผู้ฟังถูกแนบและอีกครั้งทุกครั้งที่ข้อมูลรวมถึงลูก ๆ เปลี่ยนแปลง การเรียกกลับเหตุการณ์ถูกส่งผ่านสแน็ปช็อตที่มีข้อมูลทั้งหมดในตำแหน่งนั้นรวมถึงข้อมูลลูก หากไม่มีข้อมูลสแนปชอตจะส่งคืนค่า false เมื่อคุณโทรหา exists() และเป็น null เมื่อคุณเรียกใช้ getValue()

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงแอปพลิเคชันบล็อกโซเชียลที่ดึงรายละเอียดของโพสต์จากฐานข้อมูล:

ชวา

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

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)

ผู้ฟังได้รับ DataSnapshot ที่มีข้อมูล ณ ตำแหน่งที่ระบุในฐานข้อมูล ณ เวลาที่เกิดเหตุการณ์ การเรียกใช้ getValue() บนสแน็ปช็อตจะส่งคืนการแทนค่าวัตถุ Java ของข้อมูล หากไม่มีข้อมูลอยู่ที่ตำแหน่งการเรียก getValue() จะส่งกลับ null

ในตัวอย่างนี้ ValueEventListener ยังกำหนด onCancelled() ที่เรียกว่าหากการอ่านถูกยกเลิก ตัวอย่างเช่นการอ่านสามารถถูกยกเลิกได้หากไคลเอ็นต์ไม่มีสิทธิ์อ่านจากตำแหน่งฐานข้อมูล Firebase วิธีการนี้ถูกส่งผ่านวัตถุ DatabaseError ระบุว่าทำไมความล้มเหลวเกิดขึ้น

อ่านข้อมูลหนึ่งครั้ง

ในบางกรณีคุณอาจต้องการให้มีการโทรกลับหนึ่งครั้งแล้วลบออกทันทีเช่นเมื่อเริ่มต้นองค์ประกอบ UI ที่คุณไม่คาดหวังว่าจะเปลี่ยนแปลง คุณสามารถใช้เมธอด addListenerForSingleValueEvent() เพื่อทำให้สถานการณ์นี้ง่ายขึ้น: ทริกเกอร์หนึ่งครั้งจากนั้นจะไม่ทริกเกอร์อีกครั้ง

สิ่งนี้มีประโยชน์สำหรับข้อมูลที่ต้องโหลดเพียงครั้งเดียวและไม่คาดว่าจะเปลี่ยนบ่อยหรือต้องการการฟังที่ใช้งานอยู่ ตัวอย่างเช่นแอปบล็อกในตัวอย่างก่อนหน้านี้ใช้วิธีนี้เพื่อโหลดโปรไฟล์ของผู้ใช้เมื่อพวกเขาเริ่มเขียนโพสต์ใหม่:

อัปเดตหรือลบข้อมูล

อัปเดตฟิลด์เฉพาะ

หากต้องการเขียนไปยังชายด์เฉพาะของโหนดพร้อมกันโดยไม่เขียนทับโหนดชายน์อื่นให้ใช้ updateChildren()

เมื่อเรียกใช้ updateChildren() คุณสามารถอัปเดตค่าระดับล่างโดยระบุพา ธ สำหรับคีย์ หากข้อมูลถูกจัดเก็บในหลายตำแหน่งเพื่อขยายขนาดให้ดีขึ้นคุณสามารถอัปเดตอินสแตนซ์ทั้งหมดของข้อมูลนั้นโดยใช้การ ส่งข้อมูลออก ตัวอย่างเช่นแอพบล็อกทางสังคมอาจมีคลาส 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;
    }

}

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

ในการสร้างโพสต์และอัปเดตไปยังฟีดกิจกรรมล่าสุดและฟีดกิจกรรมของผู้ใช้ที่โพสต์พร้อมกันแอปพลิเคชันบล็อกใช้รหัสเช่นนี้:

ชวา

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

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

ตัวอย่างนี้ใช้ push() เพื่อสร้างโพสต์ในโหนดที่มีการโพสต์สำหรับผู้ใช้ทั้งหมดที่ /posts/$postid และดึงกุญแจพร้อมกันด้วย getKey() คีย์สามารถใช้เพื่อสร้างรายการที่สองในโพสต์ของผู้ใช้ที่ /user-posts/$userid/$postid

เมื่อใช้พา ธ เหล่านี้คุณสามารถทำการอัปเดตหลาย ๆ ตำแหน่งพร้อมกันใน updateChildren() JSON ด้วยการโทรครั้งเดียวเพื่อ updateChildren() เช่นวิธีที่ตัวอย่างนี้สร้างโพสต์ใหม่ในทั้งสองตำแหน่ง การอัปเดตพร้อมกันที่ทำในลักษณะนี้เป็น atomic: การอัพเดตทั้งหมดสำเร็จหรือการอัปเดตทั้งหมดล้มเหลว

เพิ่มการติดต่อกลับให้เสร็จสมบูรณ์

หากคุณต้องการทราบว่าข้อมูลของคุณถูกส่งไปเมื่อใดคุณสามารถเพิ่ม listener ที่สมบูรณ์ได้ ทั้ง 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
                // ...
            }
        });

Kotlin + KTX

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

ลบข้อมูล

วิธีที่ง่ายที่สุดในการลบข้อมูลคือการเรียก removeValue() จากการอ้างอิงไปยังตำแหน่งของข้อมูลนั้น

คุณยังสามารถลบได้โดยระบุ null เป็นค่าสำหรับการดำเนินการเขียนอื่นเช่น setValue() หรือ updateChildren() คุณสามารถใช้เทคนิคนี้กับ updateChildren() เพื่อลบชายด์หลายคนในการเรียก API เดียว

แยกผู้ฟัง

การเรียกกลับจะถูกลบออกโดยการเรียกเมธอด removeEventListener() ในการอ้างอิงฐานข้อมูล Firebase ของคุณ

หากมีการเพิ่มผู้ฟังหลาย ๆ ครั้งไปยังตำแหน่งข้อมูลจะมีการเรียกหลาย ๆ ครั้งสำหรับแต่ละเหตุการณ์และคุณต้องแยกจำนวนครั้งเท่ากันเพื่อลบออกทั้งหมด

การเรียก removeEventListener() บน parent listener จะไม่ลบ listeners ที่รีจิสเตอร์บนโหนดชายด์โดยอัตโนมัติ removeEventListener() ต้องถูกเรียกใช้บน child listeners ใด ๆ เพื่อลบการเรียกกลับ

บันทึกข้อมูลเป็นธุรกรรม

เมื่อทำงานกับข้อมูลที่อาจเกิดความเสียหายจากการปรับเปลี่ยนที่เกิดขึ้นพร้อมกันเช่นเคาน์เตอร์แบบเพิ่มหน่วยคุณสามารถใช้การ ทำธุรกรรม คุณให้ข้อโต้แย้งสองข้อกับการดำเนินการนี้: ฟังก์ชันอัปเดตและการโทรกลับเสร็จสิ้นที่เป็นตัวเลือก ฟังก์ชั่นอัพเดทใช้สถานะปัจจุบันของข้อมูลเป็นอาร์กิวเมนต์และส่งคืนสถานะที่ต้องการใหม่ที่คุณต้องการเขียน หากไคลเอ็นต์อื่นเขียนไปยังตำแหน่งก่อนที่จะเขียนค่าใหม่ของคุณสำเร็จฟังก์ชั่นอัพเดทของคุณจะถูกเรียกอีกครั้งด้วยค่าปัจจุบันใหม่และการเขียนจะลองใหม่

ตัวอย่างเช่นในตัวอย่างแอปบล็อกทางสังคมคุณสามารถอนุญาตให้ผู้ใช้ติดดาวและไม่ติดดาวโพสต์และติดตามจำนวนดาวที่โพสต์ได้รับดังนี้

ชวา

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

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

การใช้ธุรกรรมป้องกันการนับดาวไม่ถูกต้องหากผู้ใช้หลายคนติดดาวโพสต์เดียวกันในเวลาเดียวกันหรือลูกค้ามีข้อมูลเก่า หากการทำธุรกรรมถูกปฏิเสธเซิร์ฟเวอร์จะส่งคืนมูลค่าปัจจุบันให้กับลูกค้าซึ่งจะเรียกใช้การทำธุรกรรมอีกครั้งด้วยค่าที่อัพเดท สิ่งนี้จะทำซ้ำจนกว่าจะยอมรับการทำธุรกรรมหรือมีการพยายามมากเกินไป

เขียนข้อมูลออฟไลน์

หากลูกค้าสูญเสียการเชื่อมต่อเครือข่ายแอปของคุณจะทำงานได้อย่างถูกต้อง

ไคลเอนต์ทุกคนที่เชื่อมต่อกับฐานข้อมูล Firebase รักษาข้อมูลภายในของตัวเองทุกรุ่น เมื่อมีการเขียนข้อมูลมันจะถูกเขียนเป็นเวอร์ชันท้องถิ่นก่อน จากนั้นไคลเอ็นต์ Firebase จะซิงโครไนซ์ข้อมูลนั้นกับเซิร์ฟเวอร์ฐานข้อมูลระยะไกลและกับไคลเอนต์อื่น ๆ บนพื้นฐานของ "ความพยายามอย่างดีที่สุด"

เป็นผลให้ทุกการเขียนไปยังฐานข้อมูลทริกเกอร์เหตุการณ์ท้องถิ่นทันทีก่อนที่ข้อมูลใด ๆ จะถูกเขียนไปยังเซิร์ฟเวอร์ ซึ่งหมายความว่าแอปของคุณยังคงตอบสนองโดยไม่คำนึงถึงเวลาแฝงของเครือข่ายหรือการเชื่อมต่อ

เมื่อสร้างการเชื่อมต่อใหม่แอปของคุณจะได้รับชุดเหตุการณ์ที่เหมาะสมเพื่อให้ลูกค้าซิงค์กับสถานะเซิร์ฟเวอร์ปัจจุบันโดยไม่ต้องเขียนโค้ดที่กำหนดเองใด ๆ

ขั้นตอนถัดไป