एंड्रॉइड पर डेटा पढ़ें और लिखें

यह दस्तावेज़ फायरबेस डेटा को पढ़ने और लिखने की मूल बातें शामिल करता है।

फायरबेस डेटा को FirebaseDatabase संदर्भ में लिखा जाता है और संदर्भ में एक एसिंक्रोनस श्रोता को जोड़कर पुनर्प्राप्त किया जाता है। श्रोता को डेटा की प्रारंभिक स्थिति के लिए एक बार ट्रिगर किया जाता है और फिर जब भी डेटा बदलता है।

(वैकल्पिक) फायरबेस लोकल एमुलेटर सूट के साथ प्रोटोटाइप और परीक्षण

इस बारे में बात करने से पहले कि आपका ऐप रीयलटाइम डेटाबेस को कैसे पढ़ता और लिखता है, आइए टूल का एक सेट पेश करें जिसका उपयोग आप रीयलटाइम डेटाबेस कार्यक्षमता को प्रोटोटाइप और परीक्षण करने के लिए कर सकते हैं: फायरबेस लोकल एमुलेटर सूट। यदि आप अलग-अलग डेटा मॉडल आज़मा रहे हैं, अपने सुरक्षा नियमों को अनुकूलित कर रहे हैं, या बैक-एंड के साथ बातचीत करने का सबसे लागत प्रभावी तरीका ढूंढने के लिए काम कर रहे हैं, तो लाइव सेवाओं को तैनात किए बिना स्थानीय स्तर पर काम करने में सक्षम होना एक अच्छा विचार हो सकता है।

रीयलटाइम डेटाबेस एमुलेटर स्थानीय एमुलेटर सूट का हिस्सा है, जो आपके ऐप को आपके अनुकरणित डेटाबेस सामग्री और कॉन्फ़िगरेशन के साथ-साथ वैकल्पिक रूप से आपके अनुकरणीय प्रोजेक्ट संसाधनों (फ़ंक्शन, अन्य डेटाबेस और सुरक्षा नियमों) के साथ इंटरैक्ट करने में सक्षम बनाता है।

रीयलटाइम डेटाबेस एमुलेटर का उपयोग करने में बस कुछ ही चरण शामिल हैं:

  1. एम्यूलेटर से कनेक्ट करने के लिए अपने ऐप के परीक्षण कॉन्फ़िगरेशन में कोड की एक पंक्ति जोड़ना।
  2. आपकी स्थानीय प्रोजेक्ट निर्देशिका के मूल से, firebase emulators:start
  3. हमेशा की तरह रीयलटाइम डेटाबेस प्लेटफ़ॉर्म SDK का उपयोग करके, या रीयलटाइम डेटाबेस REST API का उपयोग करके अपने ऐप के प्रोटोटाइप कोड से कॉल करना।

रीयलटाइम डेटाबेस और क्लाउड फ़ंक्शंस से संबंधित एक विस्तृत पूर्वाभ्यास उपलब्ध है। आपको स्थानीय एमुलेटर सुइट परिचय पर भी एक नज़र डालनी चाहिए।

एक डेटाबेस संदर्भ प्राप्त करें

डेटाबेस से डेटा पढ़ने या लिखने के लिए, आपको 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>
  • एक कस्टम जावा ऑब्जेक्ट पास करें, यदि इसे परिभाषित करने वाले वर्ग में एक डिफ़ॉल्ट कंस्ट्रक्टर है जो कोई तर्क नहीं लेता है और असाइन किए जाने वाले गुणों के लिए सार्वजनिक गेटर्स हैं।

यदि आप जावा ऑब्जेक्ट का उपयोग करते हैं, तो आपके ऑब्जेक्ट की सामग्री स्वचालित रूप से नेस्टेड तरीके से चाइल्ड स्थानों पर मैप की जाती है। जावा ऑब्जेक्ट का उपयोग आमतौर पर आपके कोड को अधिक पठनीय और बनाए रखने में आसान बनाता है। उदाहरण के लिए, यदि आपके पास मूल उपयोगकर्ता प्रोफ़ाइल वाला कोई ऐप है, तो आपका 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);

डेटा पढ़ें

लगातार श्रोताओं के साथ डेटा पढ़ें

किसी पथ पर डेटा पढ़ने और परिवर्तनों को सुनने के लिए, DatabaseReference में एक ValueEventListener जोड़ने के लिए addValueEventListener() विधि का उपयोग करें।

श्रोता इवेंट कॉलबैक विशिष्ट उपयोग
ValueEventListener onDataChange() किसी पथ की संपूर्ण सामग्री में परिवर्तन पढ़ें और सुनें।

आप किसी दिए गए पथ पर सामग्री के स्थिर स्नैपशॉट को पढ़ने के लिए onDataChange() विधि का उपयोग कर सकते हैं, क्योंकि वे घटना के समय मौजूद थे। जब श्रोता जुड़ा होता है तो यह विधि एक बार चालू हो जाती है और हर बार बच्चों सहित डेटा बदल जाता है। इवेंट कॉलबैक में एक स्नैपशॉट भेजा जाता है जिसमें चाइल्ड डेटा सहित उस स्थान का सारा डेटा होता है। यदि कोई डेटा नहीं है, तो जब आप exists() पर कॉल करते हैं तो स्नैपशॉट false लौट आएगा और जब आप getValue() पर कॉल करेंगे तो वह null

निम्नलिखित उदाहरण एक सामाजिक ब्लॉगिंग एप्लिकेशन को डेटाबेस से किसी पोस्ट का विवरण पुनर्प्राप्त करते हुए दर्शाता है:

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() कॉल करने से डेटा का जावा ऑब्जेक्ट प्रतिनिधित्व वापस आ जाता है। यदि स्थान पर कोई डेटा मौजूद नहीं है, तो getValue() कॉल करने से null वापस आ जाता है।

इस उदाहरण में, ValueEventListener onCancelled() विधि को भी परिभाषित करता है जिसे रीड रद्द होने पर कहा जाता है। उदाहरण के लिए, यदि क्लाइंट के पास फायरबेस डेटाबेस स्थान से पढ़ने की अनुमति नहीं है तो रीड को रद्द किया जा सकता है। इस विधि में एक DatabaseError ऑब्जेक्ट पास किया जाता है जो बताता है कि विफलता क्यों हुई।

एक बार डेटा पढ़ें

get() का उपयोग करके एक बार पढ़ें

एसडीके को डेटाबेस सर्वर के साथ इंटरैक्शन प्रबंधित करने के लिए डिज़ाइन किया गया है, चाहे आपका ऐप ऑनलाइन हो या ऑफलाइन।

आम तौर पर, आपको बैकएंड से डेटा के अपडेट की सूचना प्राप्त करने के लिए डेटा को पढ़ने के लिए ऊपर वर्णित ValueEventListener तकनीकों का उपयोग करना चाहिए। श्रोता तकनीकें आपके उपयोग और बिलिंग को कम करती हैं, और आपके उपयोगकर्ताओं को ऑनलाइन और ऑफलाइन होने पर सर्वोत्तम अनुभव देने के लिए अनुकूलित की जाती हैं।

यदि आपको केवल एक बार डेटा की आवश्यकता है, तो आप डेटाबेस से डेटा का स्नैपशॉट प्राप्त करने के लिए 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);
}

यह उदाहरण /posts/$postid पर सभी उपयोगकर्ताओं के लिए पोस्ट युक्त नोड में एक पोस्ट बनाने के लिए push() उपयोग करता है और साथ ही getKey() के साथ कुंजी पुनर्प्राप्त करता है। कुंजी का उपयोग उपयोगकर्ता की पोस्ट में /user-posts/$userid/$postid पर दूसरी प्रविष्टि बनाने के लिए किया जा सकता है।

इन पथों का उपयोग करके, आप updateChildren() पर एक ही कॉल के साथ JSON ट्री में कई स्थानों पर एक साथ अपडेट कर सकते हैं, जैसे कि यह उदाहरण दोनों स्थानों में नई पोस्ट कैसे बनाता है। इस तरह से किए गए एक साथ किए गए अपडेट परमाणु होते हैं: या तो सभी अपडेट सफल होते हैं या सभी अपडेट विफल हो जाते हैं।

एक पूर्ण कॉलबैक जोड़ें

यदि आप जानना चाहते हैं कि आपका डेटा कब प्रतिबद्ध किया गया है, तो आप एक पूर्ण श्रोता जोड़ सकते हैं। setValue() और updateChildren() दोनों एक वैकल्पिक समापन श्रोता लेते हैं जिसे तब बुलाया जाता है जब लेखन सफलतापूर्वक डेटाबेस के लिए प्रतिबद्ध हो जाता है। यदि कॉल असफल होती है, तो श्रोता को एक त्रुटि ऑब्जेक्ट भेजा जाता है जो बताता है कि विफलता क्यों हुई।

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() कॉल करना है।

आप किसी अन्य लेखन ऑपरेशन जैसे setValue() या updateChildren() के मान के रूप में null निर्दिष्ट करके भी हटा सकते हैं। आप एक ही एपीआई कॉल में एकाधिक बच्चों को हटाने के लिए updateChildren() के साथ इस तकनीक का उपयोग कर सकते हैं।

श्रोताओं को अलग करें

आपके फायरबेस डेटाबेस संदर्भ पर removeEventListener() विधि को कॉल करके कॉलबैक हटा दिए जाते हैं।

यदि किसी श्रोता को डेटा स्थान पर कई बार जोड़ा गया है, तो उसे प्रत्येक ईवेंट के लिए कई बार कॉल किया जाता है, और आपको इसे पूरी तरह से हटाने के लिए इसे समान संख्या में अलग करना होगा।

पैरेंट श्रोता पर removeEventListener() कॉल करने से उसके चाइल्ड नोड्स पर पंजीकृत श्रोता स्वचालित रूप से नहीं हटते हैं; कॉलबैक को हटाने के लिए किसी भी चाइल्ड श्रोता पर removeEventListener() भी कॉल किया जाना चाहिए।

लेनदेन के रूप में डेटा सहेजें

डेटा के साथ काम करते समय जो समवर्ती संशोधनों, जैसे वृद्धिशील काउंटरों द्वारा दूषित हो सकता है, आप लेनदेन ऑपरेशन का उपयोग कर सकते हैं। आप इस ऑपरेशन को दो तर्क देते हैं: एक अद्यतन फ़ंक्शन और एक वैकल्पिक पूर्णता कॉलबैक। अद्यतन फ़ंक्शन डेटा की वर्तमान स्थिति को एक तर्क के रूप में लेता है और वह नई वांछित स्थिति लौटाता है जिसे आप लिखना चाहते हैं। यदि कोई अन्य क्लाइंट आपके नए मान के सफलतापूर्वक लिखे जाने से पहले स्थान पर लिखता है, तो आपके अपडेट फ़ंक्शन को नए वर्तमान मान के साथ फिर से कॉल किया जाता है, और लिखने का पुनः प्रयास किया जाता है।

उदाहरण के लिए, उदाहरण के सोशल ब्लॉगिंग ऐप में, आप उपयोगकर्ताओं को पोस्ट को स्टार और अनस्टार करने की अनुमति दे सकते हैं और इस प्रकार ट्रैक कर सकते हैं कि किसी पोस्ट को कितने स्टार मिले हैं:

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

यदि कई उपयोगकर्ता एक ही समय में एक ही पोस्ट को स्टार करते हैं या क्लाइंट के पास पुराना डेटा है तो लेनदेन का उपयोग करने से स्टार काउंट गलत होने से बच जाता है। यदि लेनदेन अस्वीकार कर दिया जाता है, तो सर्वर क्लाइंट को वर्तमान मूल्य लौटाता है, जो अद्यतन मूल्य के साथ लेनदेन को फिर से चलाता है। यह तब तक दोहराया जाता है जब तक कि लेनदेन स्वीकार नहीं हो जाता या बहुत अधिक प्रयास नहीं किए जाते।

परमाणु सर्वर-साइड वृद्धि

उपरोक्त उपयोग के मामले में हम डेटाबेस में दो मान लिख रहे हैं: उस उपयोगकर्ता की आईडी जो पोस्ट को स्टार/अनस्टार करता है, और बढ़ी हुई स्टार गिनती। यदि हम पहले से ही जानते हैं कि उपयोगकर्ता पोस्ट को अभिनीत कर रहा है, तो हम लेनदेन के बजाय परमाणु वृद्धि ऑपरेशन का उपयोग कर सकते हैं।

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

यह कोड लेन-देन ऑपरेशन का उपयोग नहीं करता है, इसलिए यदि कोई विरोधाभासी अद्यतन होता है तो यह स्वचालित रूप से दोबारा नहीं चलता है। हालाँकि, चूंकि वेतन वृद्धि कार्रवाई सीधे डेटाबेस सर्वर पर होती है, इसलिए विरोध की कोई संभावना नहीं है।

यदि आप एप्लिकेशन-विशिष्ट विरोधों का पता लगाना और उन्हें अस्वीकार करना चाहते हैं, जैसे कि किसी उपयोगकर्ता द्वारा किसी पोस्ट को तारांकित करना जिसे उन्होंने पहले ही तारांकित कर दिया है, तो आपको उस उपयोग के मामले के लिए कस्टम सुरक्षा नियम लिखना चाहिए।

डेटा के साथ ऑफ़लाइन कार्य करें

यदि कोई क्लाइंट अपना नेटवर्क कनेक्शन खो देता है, तो आपका ऐप सही ढंग से काम करता रहेगा।

फायरबेस डेटाबेस से जुड़ा प्रत्येक क्लाइंट किसी भी डेटा का अपना आंतरिक संस्करण रखता है जिस पर श्रोताओं का उपयोग किया जा रहा है या जिसे सर्वर के साथ सिंक में रखने के लिए ध्वजांकित किया गया है। जब डेटा को पढ़ा या लिखा जाता है, तो सबसे पहले डेटा के इस स्थानीय संस्करण का उपयोग किया जाता है। फ़ायरबेस क्लाइंट तब उस डेटा को दूरस्थ डेटाबेस सर्वर और अन्य क्लाइंट के साथ "सर्वोत्तम प्रयास" के आधार पर सिंक्रनाइज़ करता है।

परिणामस्वरूप, सर्वर के साथ किसी भी इंटरेक्शन से पहले, डेटाबेस पर लिखे गए सभी लेख तुरंत स्थानीय घटनाओं को ट्रिगर करते हैं। इसका मतलब है कि आपका ऐप नेटवर्क विलंबता या कनेक्टिविटी की परवाह किए बिना प्रतिक्रियाशील बना रहता है।

एक बार कनेक्टिविटी पुनः स्थापित हो जाने पर, आपके ऐप को ईवेंट का उचित सेट प्राप्त होता है ताकि क्लाइंट बिना कोई कस्टम कोड लिखे वर्तमान सर्वर स्थिति के साथ समन्वयित हो सके।

हम ऑनलाइन और ऑफ़लाइन क्षमताओं के बारे में और जानें में ऑफ़लाइन व्यवहार के बारे में अधिक बात करेंगे।

अगले कदम