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 प्लैटफ़ॉर्म के एसडीके टूल का इस्तेमाल करके, अपने ऐप्लिकेशन के प्रोटोटाइप कोड से कॉल करना या Realtime Database REST API का इस्तेमाल करना.

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

DatabaseReference पाना

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

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

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

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

डेटा में बदलाव करने की बुनियादी कार्रवाइयां

डेटा को सेव करने के लिए, setValue() का इस्तेमाल किया जा सकता है. इससे डेटा, दिए गए रेफ़रंस में सेव हो जाता है और उस पाथ पर मौजूद मौजूदा डेटा को बदल देता है. इस तरीके का इस्तेमाल करके:

• पास के टाइप, जो उपलब्ध JSON टाइप से मेल खाते हैं:
  • String
  • Long
  • Double
  • Boolean
  • Map<String, Object>
  • List<Object>
• अगर इसे तय करने वाली क्लास में कोई डिफ़ॉल्ट कंस्ट्रक्टर है, तो कस्टम Java ऑब्जेक्ट पास करें. इस कंस्ट्रक्टर में कोई आर्ग्युमेंट नहीं होना चाहिए और असाइन की जाने वाली प्रॉपर्टी के लिए, सार्वजनिक गेटर होने चाहिए.

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

@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

@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() का इस्तेमाल करके, किसी उपयोगकर्ता को इस तरह जोड़ा जा सकता है:

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

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

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

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

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

डेटा पढ़ने की अनुमति दें

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

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

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

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

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

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() का इस्तेमाल करके एक बार पढ़ना

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

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

अगर आपको डेटा सिर्फ़ एक बार चाहिए, तो डेटाबेस से डेटा का स्नैपशॉट पाने के लिए, get() का इस्तेमाल करें. अगर किसी वजह से get(), सर्वर की वैल्यू नहीं दिखा पाता है, तो क्लाइंट लोकल स्टोरेज कैश मेमोरी की जांच करेगा. अगर वैल्यू अब भी नहीं मिलती है, तो गड़बड़ी का मैसेज दिखाएगा.

get() का बेवजह इस्तेमाल करने से, बैंडविड्थ का इस्तेमाल बढ़ सकता है. साथ ही, परफ़ॉर्मेंस में गिरावट आ सकती है. इसे रोकने के लिए, रीयलटाइम लिसनर का इस्तेमाल किया जा सकता है, जैसा कि ऊपर दिखाया गया है.

mDatabase.child("users").child(userId).get().addOnSuccessListener {
    Log.i("firebase", "Got value ${it.value}")
}.addOnFailureListener{
    Log.e("firebase", "Error getting data", it)
}

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 क्लास हो सकती है:

@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

@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

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

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

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() को एक बार कॉल करना होगा. उदाहरण के लिए, इस उदाहरण में दोनों जगहों पर नई पोस्ट बनाई गई है. इस तरह से एक साथ किए गए अपडेट, ऐटॉमिक होते हैं: या तो सभी अपडेट सफल होते हैं या सभी अपडेट फ़ेल हो जाते हैं.

Add a Completion Callback

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

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

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() के साथ इस तकनीक का इस्तेमाल किया जा सकता है.

लिसनर को अलग करना

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

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

पैरंट लिसनर पर removeEventListener() को कॉल करने से, उसके चाइल्ड नोड पर रजिस्टर किए गए लिसनर अपने-आप नहीं हटते. कॉलबैक को हटाने के लिए, किसी भी चाइल्ड लिसनर पर removeEventListener() को भी कॉल करना ज़रूरी है.

डेटा को लेन-देन के तौर पर सेव करना

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

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

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

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

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

सर्वर-साइड पर होने वाली बढ़ोतरी

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

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

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 क्लाइंट उस डेटा को रिमोट डेटाबेस सर्वर और अन्य क्लाइंट के साथ सिंक करता है. इसके लिए, वह "सबसे सही" तरीका अपनाता है.

इस वजह से, डेटाबेस में कुछ भी लिखने पर, सर्वर से इंटरैक्ट करने से पहले ही लोकल इवेंट ट्रिगर हो जाते हैं. इसका मतलब है कि आपका ऐप्लिकेशन, नेटवर्क की लेटेंसी या कनेक्टिविटी की परवाह किए बिना, रिस्पॉन्सिव बना रहता है.

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

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

अगले चरण

• डेटा की सूचियों के साथ काम करना
• डेटा को स्ट्रक्चर करने का तरीका जानें
• ऑनलाइन और ऑफ़लाइन सुविधाओं के बारे में ज़्यादा जानें