ORMLite के साथ Android पर ORM

फिलहाल, एंड्रॉइड प्लेटफॉर्म के लिए कई समाधान हैं जो डेटाबेस के साथ काम करने के लिए ओआरएम दृष्टिकोण को लागू करने की अनुमति देते हैं, लेकिन दो मुख्य हैं। ये ORMLite और GreenDAO हैं ।

शुरुआती लोगों के लिए, यह ओआरएम क्या है, यह बताने और बताने के लिए उपयुक्त है। ORM - ऑब्जेक्ट-रेशनल मैपिंग। ऑब्जेक्ट-रिलेशनल मैपिंग का मतलब है कि प्रोग्रामर के लिए ऑब्जेक्ट्स के साथ काम करना अधिक सुविधाजनक है जो वह अपने एप्लिकेशन में उपयोग होने वाले टेबल की तुलना में रिलेशनल डेटाबेस में डेटा स्टोर करता है। ORM प्रौद्योगिकियों का उपयोग अनुप्रयोग ऑब्जेक्ट मॉडल के साथ संबंधपरक DBMS को जोड़ने के लिए किया जाता है। इसलिए एंड्रॉइड में ऑब्जेक्ट-रिलेशनल मैपिंग की समस्याओं को हल करने के लिए, थर्ड-पार्टी फ्रेमवर्क में से एक का उपयोग करें। GreenDAO और ORMLite ओपन सोर्स लाइब्रेरी हैं।

GreenDAO

जर्मन डेवलपर्स से रूपरेखा, जो वे अपने अनुप्रयोगों में उपयोग करते हैं।

फायदे:

काम करने के लिए प्रतिबिंब का उपयोग नहीं करता है
Android ORM के लिए अधिकतम प्रदर्शन
न्यूनतम स्मृति उपयोग
लाइब्रेरी के छोटे आकार का एंड्रॉइड प्रोजेक्ट पर अधिक प्रभाव नहीं पड़ता है।

नुकसान:

• स्कीमा को अद्यतन करते समय डेटा स्थानांतरित करने के लिए कोई तंत्र नहीं है।
• एनोटेटिंग कक्षाओं की असंभवता, और नई संस्थाओं के निर्माण के लिए एक एल्गोरिदम का वर्णन करने की आवश्यकता है।

ORMLite

Android के लिए एक अनुकूलित संस्करण के साथ एक लोकप्रिय जावा फ्रेमवर्क।

फायदे:

• शक्तिशाली अभी तक सरल एनोटेशन
• समृद्ध कार्यक्षमता
• सहित कई डेटाबेस के लिए समर्थन SQLite
• KISS के सिद्धांत के अनुसार वास्तुकला

नुकसान:

... हम्म ... मैंने उन्हें नहीं पाया) असंभव लगने वाली हर चीज को गोदी के गहन अध्ययन से महसूस किया जाता है।

मैं कई परियोजनाओं में ऑरमलाइट का उपयोग करता हूं, और मैं इससे काफी करीब से परिचित हूं। इसलिए, मैं उसके बारे में बस बैठूंगा।

सरल वर्ग एनोटेशन

प्रत्येक वर्ग, डेटाबेस के लिए मैपिंग (डेटाबेस को सहेजना) जिसमें हम बनाना चाहते हैं, एनोटेट होना चाहिए। (आप वर्ग-विन्यास का उपयोग कर सकते हैं, लेकिन यह एक पूरी तरह से अलग कहानी है) यह ध्यान देने योग्य है कि कक्षा में आवश्यक रूप से कोई तर्क के साथ एक निर्माता होना चाहिए। एनोटेशन उदाहरण:

@DatabaseTable(tableName = "goals") public class Goal{ public final static String GOAL_NAME_FIELD_NAME = "name"; @DatabaseField(generatedId = true) private int Id; @DatabaseField(canBeNull = false, dataType = DataType.STRING, columnName = GOAL_NAME_FIELD_NAME) private String name; @DatabaseField(dataType = DataType.DATE) private Date lastEditDate; @DatabaseField() private String notes; public Goal(){ scheduleList = new ArrayList<Shedule>(); priorities = new ArrayList<PrioritySchedule>(); } } 

पहला एनोटेशन @DatabaseTable(tableName = "goals") तालिका नाम @DatabaseTable(tableName = "goals") तालिका के नाम को इंगित करता है जहां इस वर्ग की वस्तुओं को प्रदर्शित किया जाएगा।
प्रत्येक क्षेत्र में विभिन्न तर्कों के साथ @DatabaseField एनोटेशन होना चाहिए। (आप तर्कों को छोड़ भी सकते हैं - सब कुछ डिफ़ॉल्ट रूप से सेट किया जाएगा, और तालिका में स्तंभ नाम फ़ील्ड नाम से मेल खाएगा)। नाम फ़ील्ड में तीन तर्क हैं। canBeNull = false मतलब है कि यह कॉलम तालिका में खाली नहीं हो सकता है। dataType = DataType.STRING आपको स्तंभ प्रकार को String लाने के लिए String । (उपलब्ध प्रकार यहां पाए जा सकते हैं )। columnName = GOAL_NAME_FIELD_NAME - डेटाबेस से डेटा पुनर्प्राप्त करने के लिए चुनिंदा क्वेरीज़ का निर्माण करते समय तालिका में कॉलम नाम को मजबूर करने से हमें भविष्य में मदद मिलेगी।
प्राथमिक कुंजी कोई भी फ़ील्ड हो सकती है - बस इसके लिए id = true निर्दिष्ट करें, लेकिन यह एक id- generatedId = true id मान बनाने और इसे generatedId = true करने के लिए अनुशंसित है generatedId = true । ORMLite खुद उसे एक अद्वितीय नंबर सौंपेगा।
डेटाबेस में एक कॉलम को इंडेक्स करने के लिए, index = true
सभी उपलब्ध फ़ील्ड एनोटेशन तर्कों का पूरा विवरण यहां पाया जा सकता है।
इसके अलावा, ORMLite एनोटेशन के अलावा, आप सामान्य javax.persistence एनोटेशन का उपयोग कर सकते हैं

Android पर SQLite से कनेक्ट करें

Android में ORMLite का उपयोग करके डेटाबेस डेटा तक पहुंचने के कई तरीके हैं। आप ORMLiteBaseActivity से हर गतिविधि को विरासत में प्राप्त कर सकते हैं और फिर हमें डेटाबेस से जुड़ने के जीवन चक्र का पालन नहीं करना होगा, लेकिन हम अन्य वर्गों से पहुँच प्राप्त नहीं कर सकते। ( उदाहरण देखें )
नीचे चर्चा की गई दृष्टिकोण अधिक बेहतर है।

आपको एक ऐसा वर्ग बनाने की आवश्यकता है जो डेटाबेस के साथ काम करने और काम करने में एक सहायक को तुरंत कर देगा:

 public class HelperFactory{ private static DatabaseHelper databaseHelper; public static DatabaseHelper getHelper(){ return databaseHelper; } public static void setHelper(Context context){ databaseHelper = OpenHelperManager.getHelper(context, DatabaseHelper.class); } public static void releaseHelper(){ OpenHelperManager.releaseHelper(); databaseHelper = null; } } 

आवेदन के जीवन की शुरुआत और अंत के दौरान इस तक पहुंच होगी:
यह एक खुले डेटाबेस कनेक्शन के कारण मेमोरी लीक को रोक देगा।

 public class MyApplication extends Application{ @Override public void onCreate() { super.onCreate(); HelperFactory.setHelper(getApplicationContext()); } @Override public void onTerminate() { HelperFactory.releaseHelper(); super.onTerminate(); } } 

इसके अलावा, प्रकट में हमारे उत्तराधिकारी वर्ग का वर्णन करना न भूलें:

  <application android:name=".MyApplication" android:icon="@drawable/ic_launcher" android:label="@string/app_name" > 

चलिए DataBaseHelper क्लास बनाते हैं, जो डेटाबेस बनाने और DAO के लिंक प्राप्त करने के लिए जिम्मेदार होगा:

 public class DatabaseHelper extends OrmLiteSqliteOpenHelper{ private static final String TAG = DatabaseHelper.class.getSimpleName(); //        /data/data/APPNAME/DATABASE_NAME.db private static final String DATABASE_NAME ="myappname.db"; //   ,            onUpgrade(); private static final int DATABASE_VERSION = 1; //  DAO  ,    private GoalDAO goalDao = null; private RoleDAO roleDao = null; public DatabaseHelper(Context context){ super(context,DATABASE_NAME, null, DATABASE_VERSION); } //,         @Override public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource){ try { TableUtils.createTable(connectionSource, Goal.class); TableUtils.createTable(connectionSource, Role.class); } catch (SQLException e){ Log.e(TAG, "error creating DB " + DATABASE_NAME); throw new RuntimeException(e); } } //,        @Override public void onUpgrade(SQLiteDatabase db, ConnectionSource connectionSource, int oldVer, int newVer){ try{ //  ,         TableUtils.dropTable(connectionSource, Goal.class, true); TableUtils.dropTable(connectionSource, Role.class, true); onCreate(db, connectionSource); } catch (SQLException e){ Log.e(TAG,"error upgrading db "+DATABASE_NAME+"from ver "+oldVer); throw new RuntimeException(e); } } //  GoalDAO public GoalDAO getGoalDAO() throws SQLException{ if(goalDao == null){ goalDao = new GoalDAO(getConnectionSource(), Goal.class); } return goalDao; } /  RoleDAO public RoleDAO getRoleDAO() throws SQLException{ if(roleDao == null){ roleDao = new RoleDAO(getConnectionSource(), Role.class); } return roleDao; } //    @Override public void close(){ super.close(); goalDao = null; roleDao = null; } } 

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

डीएओ

सबसे सरल कार्यान्वयन निम्नलिखित वर्ग है

 public class RoleDAO extends BaseDaoImpl<Role, Integer>{ protected RoleDAO(ConnectionSource connectionSource, Class<Role> dataClass) throws SQLException{ super(connectionSource, dataClass); } public List<Role> getAllRoles() throws SQLException{ return this.queryForAll(); } } 

यहाँ हमने भूमिका वर्ग की सभी वस्तुओं का संग्रह प्राप्त करने के लिए केवल एक अतिरिक्त विधि बनाई है।
BaseDaoImpl के पूर्वज में मुख्य विधियाँ निर्मित, अद्यतन, नष्ट की गई हैं।
किसी भी एप्लिकेशन क्लास में रोलडॉ क्लास की विधि का उपयोग करने के लिए, आपको बस फ़ैक्टरी क्लास की ओर रुख करना होगा:
RoleDAO roleDao = HelperFactory.GetHelper().getRoleDAO();

क्वेरी बनाएँ

विशिष्ट प्रश्नों के निर्माण के लिए, आप DAO वर्ग में अपनी विधियाँ बना सकते हैं।

 public List<Goal> getGoalByName(String name) throws SQLException{ QueryBuilder<Goal, String> queryBuilder = queryBuilder(); queryBuilder.where().eq(Goal.GOAL_NAME_FIELD_NAME, "First goal"); PreparedQuery<Goal> preparedQuery = queryBuilder.prepare(); List<Goal> goalList =query(preparedQuery); return goalList; } 

जैसा कि आप देख सकते हैं, संबंधित नाम फ़ील्ड वाली वस्तुओं की तलाश थी।
जब eq (जिसका अर्थ बराबर होता है) के अतिरिक्त और अधिक जटिल प्रश्नों का निर्माण करते हैं, तो gt (अधिक), ge (अधिक से अधिक और समान) और मानक के अनुरूप बाकी हैं जहाँ SQL (पूर्ण सूची यहाँ है )
एक जटिल क्वेरी बनाने के लिए, आप जोड़ सकते हैं and :
queryBuilder.where().eq(Goal.GOAL_NAME_FIELD_NAME, "First goal").and().eq(Goal.GOAL_NOTES_NAME_FIELD_NAME,”aaa”);

तदनुसार, डेटाबेस से प्रश्नों के अलावा, एक समान तरीके से तालिकाओं को हटाना और अपडेट करना संभव है।

नेस्टेड संस्थाओं के साथ काम करें

एक-से-एक संबंधों पर विचार करें। मान लीजिए कि किसी लक्ष्य वस्तु में भूमिका की ओर संकेत किया गया है।
तदनुसार, लक्ष्य वर्ग में, फ़ील्ड को एनोटेट किया जाना चाहिए।

 @DatabaseField(foreign = true) private Role role; public void setRole(Role value){ this.role = value; } public Role getRole(){ return role; } 

अब हम डेटाबेस में अपनी वस्तुओं को सहेज सकते हैं

  Goal g = new Goal(); g.setName(“asd”); Role r = new Role(); g.setRole(r); HelperFactory.getHelper.getRoleDAO().create(r); HelperFactory.getHelper.getGoalDAO().create(g); 

लक्ष्य वर्ग की एक वस्तु तक पहुँचने के लिए जो कि लक्ष्य प्रकार से जुड़ी होती है:

  Goal g = HelperFactory.getHelper.getRoleDAO().getGoalByName(“asd”); Role r = g.getRole(); HelperFactory.getHelper.getRolelDAO().refresh(g); 

refresh() जाना चाहिए ताकि r इस ऑब्जेक्ट के अनुरूप डेटाबेस से सभी फ़ील्ड प्राप्त करें।

संग्रह संदर्भ संग्रहीत करते समय, दृष्टिकोण थोड़ा अलग होता है:

लक्ष्य वर्ग में:

  @ForeignCollectionField(eager = true) private Collection<Role> roleList; public addRole(Role value){ value.setGoal(this); HelperFactory.GetHelper().getRoleDAO().create(value); roleList.add(value); } public void removeRole(Role value){ roleList.remove(value); HelperFactory.GetHelper().getRoleDAO().delete(value); } 

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

  @DatabaseField(foreign = true, foreignAutoRefresh = true) private Goal goal; 

यदि आप eager=true , तो आलसी-आरंभीकरण किया जाएगा, अर्थात्। जब लक्ष्य ऑब्जेक्ट का अनुरोध किया जाता है, तो संबंधित रोलिस्ट संग्रह की वस्तुओं को पुनर्प्राप्त नहीं किया जाएगा। उन्हें निकालने के लिए, आपको उन्हें पुन: व्यवस्थित करने की आवश्यकता होगी:

  Iterator<Role> iter = state.goal.getRoleList().iterator(); while (iter.hasNext()) { Role r = iter.next(); } 

लाइब्रेरी से लिंक करें ।
ट्यूटोरियल के लिए लिंक ।