Android पर डेटा पढ़ें और लिखें

इस दस्तावेज़ में Firebase डेटा को पढ़ने और लिखने से जुड़ी बुनियादी जानकारी दी गई है.

Firebase डेटा को FirebaseDatabase रेफ़रंस में लिखा जाता है और इसे रेफ़रंस के साथ एसिंक्रोनस लिसनर अटैच करना. लिसनर ट्रिगर हो गया है एक बार डेटा की शुरुआती स्थिति के लिए और फिर कभी भी डेटा में बदलाव होता है.

(ज़रूरी नहीं) प्रोटोटाइप बनाना और Firebase Local Emulator Suite की मदद से टेस्ट करना

आपका ऐप्लिकेशन Realtime Database पर किस तरह से डेटा पढ़ता है और उसे कैसे लिखा जाता है, इस बारे में बात करने से पहले, चलिए, कुछ ऐसे टूल के बारे में जानते हैं जिनका इस्तेमाल Realtime Database को प्रोटोटाइप करने और उनकी जांच करने के लिए किया जा सकता है फ़ंक्शन: Firebase Local Emulator Suite. अगर आपको कोई दूसरा डेटा आज़माना है, मॉडल, आपके सुरक्षा नियमों को ऑप्टिमाइज़ करके या सबसे सटीक तरीके से बैक-एंड से इंटरैक्ट करने का किफ़ायती तरीका, स्थानीय तौर पर काम करना काम हो सकता है. यह काम, लाइव सेवाओं को डिप्लॉय किए बिना किया जा सकता है.

एक Realtime Database एम्युलेटर, Local Emulator Suite का हिस्सा है, जो इससे आपका ऐप्लिकेशन, आपके डेटाबेस के एम्युलेट किए गए कॉन्टेंट और कॉन्फ़िगरेशन से इंटरैक्ट कर सकता है. जैसे: विकल्प के तौर पर, आपके एम्युलेट किए गए प्रोजेक्ट रिसोर्स (फ़ंक्शन, अन्य डेटाबेस, और सुरक्षा के नियम शामिल हैं).

Realtime Database एम्युलेटर को इस्तेमाल करने के लिए, आपको कुछ ही चरण पूरे करने होंगे:

  1. एम्युलेटर से कनेक्ट करने के लिए, अपने ऐप्लिकेशन के टेस्ट कॉन्फ़िगरेशन में कोड की एक लाइन जोड़ना.
  2. आपकी लोकल प्रोजेक्ट डायरेक्ट्री के रूट से, firebase emulators:start पर चल रहा है.
  3. Realtime Database प्लैटफ़ॉर्म का इस्तेमाल करके, अपने ऐप्लिकेशन के प्रोटोटाइप कोड से कॉल करना हमेशा की तरह SDK टूल या Realtime Database REST API का इस्तेमाल करके इंस्टॉल करें.

Realtime Database और Cloud Functions से जुड़े सिलसिलेवार निर्देश उपलब्ध हैं. आपको Local Emulator Suite के बारे में जानकारी भी देखनी चाहिए.

DatabaseReference पाएं

डेटाबेस से डेटा पढ़ने या उसमें बदलाव करने के लिए, आपको के इंस्टेंस की ज़रूरत होगी DatabaseReference:

Kotlin+KTX

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

Java

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

डेटा सेव करने की अनुमति दें

लिखने से जुड़ी बुनियादी कार्रवाइयां

लिखने के बुनियादी काम करने के लिए, 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.
}
User.kt

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

}
User.java

setValue() वाले उपयोगकर्ता को इस तरह जोड़ा जा सकता है:

Kotlin+KTX 

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

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

Java 

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

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

setValue() का इस तरह इस्तेमाल करने से, बताई गई जगह के डेटा को ओवरराइट कर दिया जाता है, इसमें सभी चाइल्ड नोड शामिल हैं. हालांकि, बच्चे के खाते को इनके बिना भी अपडेट किया जा सकता है पूरे ऑब्जेक्ट को फिर से लिखना. अगर आपको उपयोगकर्ताओं को उनकी प्रोफ़ाइल अपडेट करने की अनुमति देनी है तो आप उपयोगकर्ता नाम को इस प्रकार अपडेट कर सकते हैं:

Kotlin+KTX 

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

Java 

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

डेटा पढ़ें

स्थायी लिसनर के साथ डेटा पढ़ें

पाथ पर डेटा पढ़ने और बदलावों को सुनने के लिए, addValueEventListener() का इस्तेमाल करें DatabaseReference में ValueEventListener जोड़ने का तरीका.

श्रोता इवेंट कॉलबैक आम तौर पर इस्तेमाल
ValueEventListener onDataChange() पाथ के पूरे कॉन्टेंट में हुए बदलावों को पढ़ और सुन सकता है.

का स्टैटिक स्नैपशॉट पढ़ने के लिए, onDataChange() तरीके का इस्तेमाल किया जा सकता है दिए गए पाथ पर कॉन्टेंट, जैसा कि वे इवेंट के समय मौजूद थे. यह तरीका यह तब ट्रिगर होता है, जब लिसनर जुड़ा होता है. इसके बाद, डेटा के हर बार ट्रिगर होने पर, जिसमें बच्चों को भी शामिल किया गया है. इवेंट कॉलबैक को एक स्नैपशॉट पास किया जाता है, जिसमें यह शामिल होता है उस जगह का पूरा डेटा. इसमें चाइल्ड डेटा भी शामिल है. अगर कोई डेटा मौजूद नहीं है, तो जब आप exists() को कॉल करेंगे, तो स्नैपशॉट में false दिखेगा. साथ ही, कॉल करने पर 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)
ReadAndWriteSnippets.kt

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);
ReadAndWriteSnippets.java

सुनने वाले को एक DataSnapshot मिलता है, जिसमें तय किए गए इवेंट के समय, डेटाबेस में मौजूद जगह की जानकारी. getValue() को इस पर कॉल किया जाएगा: स्नैपशॉट, डेटा को Java ऑब्जेक्ट दिखाने के लिए दिखाता है. अगर कोई डेटा मौजूद नहीं है जगह है, तो getValue() को कॉल करने पर null वापस आएगा.

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

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

get() का इस्तेमाल करके एक बार पढ़ें

SDK टूल को डेटाबेस सर्वर के साथ इंटरैक्शन को मैनेज करने के लिए डिज़ाइन किया गया है. इससे कोई फ़र्क़ नहीं पड़ता कि ऐप ऑनलाइन है या ऑफ़लाइन.

आम तौर पर, आपको ऊपर बताई गई 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,
        )
    }
}
Post.kt

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;
    }
}
Post.java

पोस्ट बनाने और इसके साथ-साथ हाल की गतिविधि में अपडेट करने के लिए और पोस्ट करने वाले उपयोगकर्ता की गतिविधि फ़ीड है, तो ब्लॉगिंग ऐप्लिकेशन इन विज्ञापनों का इस तरह कोड दें:

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)
}
ReadAndWriteSnippets.kt

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

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

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

पूरा होने पर कॉलबैक जोड़ें

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

Kotlin+KTX 

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

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

डेटा मिटाना

डेटा हटाने का सबसे आसान तरीका removeValue() को की जगह पर हो सकता है.

किसी अन्य डेटा लिखने के लिए null को वैल्यू के तौर पर बताकर भी, डेटा को मिटाया जा सकता है setValue() या updateChildren() जैसी कार्रवाई. इस तकनीक का इस्तेमाल करके, updateChildren() का इस्तेमाल करके, एक एपीआई कॉल में कई बच्चों के नाम मिटाएं.

लिसनर को अलग करें

आपके नंबर पर removeEventListener() तरीके को कॉल करने पर, कॉलबैक हट जाते हैं Firebase डेटाबेस का रेफ़रंस.

अगर लिसनर को डेटा लोकेशन में कई बार जोड़ा गया है, तो प्रत्येक इवेंट के लिए कई बार कॉल किया जाता है, और आपको उसे पिछले बार-बार क्लिक करना होगा.

पैरंट लिसनर पर, 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!!)
        }
    })
}
ReadAndWriteSnippets.kt

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

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

ऐटमिक सर्वर-साइड इंक्रीमेंट

ऊपर दिए गए इस्तेमाल के उदाहरण में, हम डेटाबेस में दो वैल्यू लिख रहे हैं: आईडी पोस्ट पर स्टार का निशान लगाने/अनस्टार का निशान लगाने वाले उपयोगकर्ता और बढ़ते हुए स्टार काउंट के बारे में जानकारी. अगर हम अगर उपयोगकर्ता पोस्ट पर स्टार का निशान लगा रहा है, तो हम ऐटोमिक इंक्रीमेंट का इस्तेमाल कर सकते हैं लेन-देन के बजाय कार्रवाई करता है.

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)
}
ReadAndWriteSnippets.kt

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

यह कोड किसी लेन-देन की कार्रवाई का इस्तेमाल नहीं करता है, इसलिए यह अपने-आप नहीं मिलता है यदि कोई विरोधात्मक अपडेट है तो फिर से चलाएं. हालांकि, बढ़ोतरी के बाद वाली कार्रवाई डेटाबेस सर्वर पर सीधे किया जाता है, तो किसी तरह के टकराव की संभावना नहीं होती.

अगर आपको ऐप्लिकेशन से जुड़े खास विवादों का पता लगाना और उन्हें अस्वीकार करना है, जैसे कि कोई उपयोगकर्ता जिस पोस्ट को वे पहले ही तारांकित कर चुके हैं, तो आपको अपने के सुरक्षा नियमों को लागू कर दिया है.

डेटा के साथ ऑफ़लाइन काम करना

अगर किसी क्लाइंट का इंटरनेट कनेक्शन बंद हो जाता है, तो आपका ऐप्लिकेशन काम करता रहेगा सही तरीके से.

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

इस वजह से, डेटाबेस में मौजूद सभी कॉलम, लोकल इवेंट को ट्रिगर करते हैं की अनुमति है. इसका मतलब है कि आपका ऐप्लिकेशन रिस्पॉन्सिव बना रहेगा इससे कोई फ़र्क़ नहीं पड़ता कि नेटवर्क कितना इंतज़ार कर रहा है या कनेक्टिविटी कैसी है.

कनेक्टिविटी वापस आने के बाद, आपके ऐप्लिकेशन को ज़रूरत के मुताबिक इवेंट दिखाए जाते हैं, ताकि क्लाइंट बिना किसी परेशानी के सर्वर की मौजूदा स्थिति के साथ सिंक हो जाए कोई कस्टम कोड लिखें.

हम ऑफ़लाइन व्यवहार के बारे में ऑनलाइन और ऑफ़लाइन सुविधाओं के बारे में ज़्यादा जानें.

अगले चरण