कक्ष का उपयोग करने के लिए 7 उपयोगी टिप्स

कमरा SQLite के ऊपर एक अमूर्त परत है जो भंडारण को सरल करता है। यदि आप कक्ष में नए हैं, तो इस परिचयात्मक लेख को देखें:

कक्ष का उपयोग करने के लिए 7 कदम। अपने आवेदन को कमरे में स्थानांतरित करने के लिए वॉकथ्रू

और इस लेख में मैं कुछ युक्तियों को साझा करना चाहूंगा कि कमरे को यथासंभव कुशलता से कैसे उपयोग किया जाए।

1. डेटाबेस को प्री-पॉप्युलेट करना

क्या आपको इसके निर्माण के तुरंत बाद या इसके पहले उपयोग के समय अपने डेटाबेस में डिफ़ॉल्ट डेटा जोड़ने की आवश्यकता है? RoomDatabase # Callback का उपयोग करें। अपना डेटाबेस बनाते समय AddCallback विधि को कॉल करें और onCreate या onOpen को ओवरराइड करें।

जब डेटाबेस पहली बार बनाया जाता है, तो onCreate को कॉल किया जाएगा। जब डेटाबेस खोला जाता है तो onOpen को कहा जाता है। चूंकि इन तरीकों के पूरा होने के बाद ही DAO तक पहुंच संभव है, हम एक नई स्ट्रीम बनाते हैं जिसमें हमें डेटाबेस का लिंक मिलता है, फिर हम DAO प्राप्त करते हैं और आवश्यक डेटा डालते हैं।

 Room.databaseBuilder(context.applicationContext, DataDatabase::class.java, "Sample.db") // prepopulate the database after onCreate was called .addCallback(object : Callback() { override fun onCreate(db: SupportSQLiteDatabase) { super.onCreate(db) // moving to a new thread ioThread { getInstance(context).dataDao() .insert(PREPOPULATE_DATA) } } }) .build() 

पूरा उदाहरण यहां देखें।

नोट: यदि आप ioThread दृष्टिकोण का उपयोग करते हैं और एप्लिकेशन पहली बार शुरू होता है, तो डेटाबेस बनाने और सम्मिलित करने के बीच, डेटा कभी भी सम्मिलित नहीं होगा।

2. DAO वंशानुक्रम क्षमताओं का उपयोग करना

क्या आपके डेटाबेस में कई टेबल हैं और एक ही इंसर्ट , अपडेट और डिलीट करने के तरीकों को कॉपी करते हैं? BaseDao<T> विरासत का समर्थन करते हैं, इसलिए एक BaseDao<T> क्लास @Update और @Delete अपने सामान्य तरीकों @Insert , @Update और @Delete को परिभाषित करें। प्रत्येक डीएओ को BaseDao विस्तार करने BaseDao और उनमें से प्रत्येक के लिए विशिष्ट तरीके जोड़ें।

 interface BaseDao<T> { @Insert fun insert(vararg obj: T) } @Dao abstract class DataDao : BaseDao<Data>() { @Query("SELECT * FROM Data") abstract fun getData(): List<Data> } 

यहां देखें विवरण

DAO का इंटरफेस या अमूर्त वर्ग होना चाहिए क्योंकि कक्ष संकलन समय पर उनके कार्यान्वयन को उत्पन्न करता है, जिसमें BaseDao तरीके शामिल हैं।

3. बॉयलरप्लेट कोड के बिना लेनदेन में प्रश्नों का निष्पादन

@Transaction का उपयोग करते हुए एक विधि का उल्लेख करना सुनिश्चित करता है कि इस पद्धति में आपके द्वारा निष्पादित सभी डेटाबेस ऑपरेशन एक ही लेनदेन के भीतर निष्पादित किए जाते हैं। विधि बॉडी में अपवाद होने पर लेन-देन निष्पादित नहीं किया जाएगा।

 @Dao abstract class UserDao { @Transaction open fun updateData(users: List<User>) { deleteAllUsers() insertAll(users) } @Insert abstract fun insertAll(users: List<User>) @Query("DELETE FROM Users") abstract fun deleteAllUsers() } 

आप मामलों में select कथन select उपयोग करने वाले @Transaction तरीकों के लिए @Transaction एनोटेशन का उपयोग करना चाह सकते हैं:

• जब क्वेरी परिणाम काफी बड़ा होता है। एक लेन-देन में अनुरोध करने से, आप गारंटी देते हैं कि यदि अनुरोध का परिणाम कर्सर के एक "हिस्से" में फिट नहीं होता है, तो यह कर्सर के क्रमपरिवर्तन के बीच डेटाबेस में परिवर्तन के कारण क्षतिग्रस्त नहीं होगा।
• जब क्वेरी परिणाम @Relation फ़ील्ड के साथ एक POJO है। प्रत्येक क्षेत्र अपने आप में एक अनुरोध है, इसलिए उन्हें एक लेनदेन में चलाने से अनुरोधों के बीच लगातार परिणाम सुनिश्चित होते हैं।

@Delete , @Update और @Insert , जिसमें कई पैरामीटर हैं, स्वचालित रूप से लेन-देन के अंदर लॉन्च किए जाते हैं।

4. केवल वही पढ़ना जो आपको चाहिए

जब आप डेटाबेस से अनुरोध करते हैं, तो क्या आप उन सभी क्षेत्रों का उपयोग करते हैं जो आपको प्रतिक्रिया में मिलते हैं? अपने एप्लिकेशन द्वारा उपयोग की जाने वाली मेमोरी की मात्रा का ध्यान रखें, और केवल उन फ़ील्ड्स को डाउनलोड करें जिन्हें आप अंततः उपयोग करेंगे। यह I / O की लागत को कम करके आपके अनुरोधों की गति भी बढ़ाएगा। कक्ष आपके लिए कॉलम और ऑब्जेक्ट के बीच मैपिंग करेगा।

इस जटिल User ऑब्जेक्ट पर विचार करें:

 @Entity(tableName = "users") data class User(@PrimaryKey val id: String, val userName: String, val firstName: String, val lastName: String, val email: String, val dateOfBirth: Date, val registrationDate: Date) 

कुछ स्क्रीन पर हमें यह सब जानकारी प्रदर्शित करने की आवश्यकता नहीं है। इस प्रकार, इसके बजाय, हम एक UserMinimal ऑब्जेक्ट बना सकते हैं जिसमें केवल आवश्यक डेटा होता है।

 data class UserMinimal(val userId: String, val firstName: String, val lastName: String) 

DAO वर्ग में, हम क्वेरी को परिभाषित करते हैं और users तालिका से सही कॉलम का चयन करते हैं।

 @Dao interface UserDao { @Query(“SELECT userId, firstName, lastName FROM Users) fun getUsersMinimal(): List<UserMinimal> } 

5. विदेशी चाबियों के साथ संस्थाओं के बीच निर्भरता का नियंत्रण

भले ही कक्ष संस्थाओं के बीच संबंधों का सीधे समर्थन नहीं करता है, यह आपको विदेशी कुंजियों का उपयोग करने वाली वस्तुओं के बीच निर्भरता को परिभाषित करने की अनुमति देता है।

कमरे में @ForeignKey एनोटेशन है, जो @Entity एनोटेशन का हिस्सा है। कार्यक्षमता में, यह SQLite में विदेशी कुंजी के समान है। जब डेटाबेस में परिवर्तन किए जाते हैं तो यह संस्थाओं के बीच संबंधों के संरक्षण की गारंटी देता है। इसे जोड़ने के लिए, संदर्भित ऑब्जेक्ट को परिभाषित करें, साथ ही वर्तमान ऑब्जेक्ट में कॉलम और जिस वॉल्यूम को आप संदर्भित कर रहे हैं।

वर्ग User और Pet पर विचार करें। Pet पास एक मालिक है - विदेशी कुंजी द्वारा संदर्भित उपयोगकर्ता आईडी।

 @Entity(tableName = "pets", foreignKeys = arrayOf( ForeignKey(entity = User::class, parentColumns = arrayOf("userId"), childColumns = arrayOf("owner")))) data class Pet(@PrimaryKey val petId: String, val name: String, val owner: String) 

यदि आप चाहें, तो आप यह निर्धारित कर सकते हैं कि माता-पिता को हटाए जाने या डेटाबेस में अपडेट किए जाने पर क्या कार्रवाई की जाए। आप निम्न विकल्पों में से एक चुन सकते हैं: NO_ACTION , RESTRICT , SET_NULL , SET_DEFAULT या CASCADE , जो SQLite के समान व्यवहार करते हैं।

नोट: कक्ष में, SET_DEFAULT तरह काम करता है, क्योंकि कक्ष आपको अभी तक कॉलम के लिए डिफ़ॉल्ट मान सेट करने की अनुमति नहीं देता है।

6. @Relation के साथ एक से कई प्रश्नों को सरल बनाएं

पिछले User - Pet उदाहरण में, हम कह सकते हैं कि एक-से-कई संबंध हैं: उपयोगकर्ता के पास कई पालतू जानवर हो सकते हैं। मान लें कि हम अपने पालतू जानवरों के साथ उपयोगकर्ताओं की एक सूची प्राप्त करना चाहते हैं: List<UserAndAllPets> ।

 data class UserAndAllPets (val user: User, val pets: List<Pet> = ArrayList()) 

मैन्युअल रूप से ऐसा करने के लिए, हमें 2 प्रश्नों की आवश्यकता है: एक सभी उपयोगकर्ताओं की सूची प्राप्त करने के लिए और दूसरा उपयोगकर्ता आईडी के आधार पर पालतू जानवरों की सूची प्राप्त करने के लिए।

 @Query(“SELECT * FROM Users”) public List<User> getUsers(); @Query(“SELECT * FROM Pets where owner = :userId”) public List<Pet> getPetsForUser(String userId); 

फिर हम उपयोगकर्ताओं की सूची पर पुनरावृति करेंगे और हर बार Pets टेबल तक Pets ।

@Relation एनोटेशन हमारे जीवन को आसान बना देगा: यह स्वचालित रूप से संबंधित वस्तुओं का अनुरोध करेगा। @Relation List Set List या Set लागू की जा सकती है। UserAndAllPets वर्ग को अपडेट करें:

 class UserAndAllPets { @Embedded var user: User? = null @Relation(parentColumn = “userId”, entityColumn = “owner”) var pets: List<Pet> = ArrayList() } 

DAO में, हम एक क्वेरी को परिभाषित करते हैं, और कक्ष Users और Pets तालिकाओं को क्वेरी करेगा और वस्तुओं को अपने आप से मैप करेगा।

 @Transaction @Query(“SELECT * FROM Users”) List<UserAndAllPets> getUsers(); 

7. अवलोकन योग्य अनुरोधों के लिए झूठी सूचनाओं से बचना

मान लें कि आप किसी उपयोगकर्ता को उसके पहचानकर्ता द्वारा एक अवलोकनीय अनुरोध का उपयोग करके प्राप्त करना चाहते हैं:

 @Query(“SELECT * FROM Users WHERE userId = :id) fun getUserById(id: String): LiveData<User> // or @Query(“SELECT * FROM Users WHERE userId = :id) fun getUserById(id: String): Flowable<User> 

हर बार अपडेट होने के बाद आपको एक नया User ऑब्जेक्ट प्राप्त होगा। लेकिन यह ऑब्जेक्ट आपको तब भी प्राप्त होगा जब Users तालिका (हटाए गए, अपडेट, या आवेषण) में अन्य परिवर्तन होते हैं, जिसका आपके द्वारा रुचि रखने वाले उपयोगकर्ता से कोई लेना-देना नहीं है, जिससे गलत सूचनाएं आएंगी। इसके अलावा, यदि आपकी क्वेरी में कई तालिकाएँ शामिल हैं, तो आप नए संदेश प्राप्त करेंगे जब भी उनमें से किसी में कुछ परिवर्तन होगा।

यहां जानिए पर्दे के पीछे क्या होता है:

1. जब भी DELETE , UPDATE या INSERT एक तालिका में होता है UPDATE तो SQLite उस आग को ट्रिगर करता है।
2. कक्ष एक Inv अमान्यationTracker बनाता है जो Observers का उपयोग करता है जो अवलोकन किए गए तालिकाओं में सभी परिवर्तनों को ट्रैक करता है।
3. LiveData और Flowable दोनों अनुरोध InvalidationTracker.Observer # onInvalidated सूचना पर निर्भर करते हैं। जब यह प्राप्त होता है, तो एक दोहराया अनुरोध होता है।

कमरा केवल यह जानता है कि तालिका बदल दी गई है, लेकिन यह नहीं जानता कि क्यों और क्या बदल गया है। इसलिए, एक दूसरे अनुरोध के बाद, अनुरोध का परिणाम LiveData या Flowable का उपयोग करके प्रसारित किया Flowable । क्योंकि कक्ष स्मृति में कोई डेटा संग्रहीत नहीं करता है, यह निर्धारित नहीं कर सकता है कि यह समान डेटा है या नहीं।

आपको यह सुनिश्चित करना होगा कि आपका DAO अनुरोधों को फ़िल्टर करता है और केवल आवश्यक वस्तुओं पर प्रतिक्रिया करता है।

यदि Flowables क्वेरी का उपयोग करके अवलोकन योग्य क्वेरी लागू की Flowables , तो फ़्लोएबल # diverUntilChanged का उपयोग करें।

 @Dao abstract class UserDao : BaseDao<User>() { /** * Get a user by id. * @return the user from the table with a specific id. */ @Query(“SELECT * FROM Users WHERE userid = :id”) protected abstract fun getUserById(id: String): Flowable<User> fun getDistinctUserById(id: String): Flowable<User> = getUserById(id) .distinctUntilChanged() } 

यदि आपकी क्वेरी LiveData , तो आप LiveData उपयोग कर सकते हैं, जो स्रोत से केवल वांछित ऑब्जेक्ट प्राप्त करेगा।

 fun <T> LiveData<T>.getDistinct(): LiveData<T> { val distinctLiveData = MediatorLiveData<T>() distinctLiveData.addSource(this, object : Observer<T> { private var initialized = false private var lastObj: T? = null override fun onChanged(obj: T?) { if (!initialized) { initialized = true lastObj = obj distinctLiveData.postValue(lastObj) } else if ((obj == null && lastObj != null) || obj != lastObj) { lastObj = obj distinctLiveData.postValue(lastObj) } } }) return distinctLiveData } 

आपके LiveData में, LiveData को लौटाने वाली विधि public , और वह विधि जो डेटाबेस पर सवाल LiveData है protected ।

 @Dao abstract class UserDao : BaseDao<User>() { @Query(“SELECT * FROM Users WHERE userid = :id”) protected abstract fun getUserById(id: String): LiveData<User> fun getDistinctUserById(id: String): LiveData<User> = getUserById(id).getDistinct() } 

यहां पूरा कोड उदाहरण देखें।

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

यह भी देखें: कक्ष का उपयोग करने के लिए 7 कदम अपने आवेदन को कमरे में स्थानांतरित करने के लिए पूर्वाभ्यास