Android SharedPreferences ऑब्जेक्ट को कैसे सहेजते / सहेजते हैं


216

हमें कई स्थानों पर उपयोगकर्ता ऑब्जेक्ट प्राप्त करने की आवश्यकता है, जिसमें कई फ़ील्ड शामिल हैं। लॉगिन करने के बाद, मैं इन यूजर ऑब्जेक्ट्स को सेव / स्टोर करना चाहता हूं। हम इस तरह के परिदृश्य को कैसे लागू कर सकते हैं?

मैं इसे इस तरह स्टोर नहीं कर सकता:

SharedPreferences.Editor prefsEditor = myPrefs.edit();
prefsEditor.putString("BusinessUnit", strBusinessUnit);

आप किस प्रकार का डेटा स्टोर करना चाहते हैं?
इलंगो जे


"~ और कार्यकारी वस्तु " से आपका क्या तात्पर्य था ? StackOverflow पर पोस्ट करने से पहले कृपया अपना व्याकरण जांचें।
इगोरगानपोलस्की

आप इस लाइब्रेरी का उपयोग कर सकते हैं जिसमें कई विशेषताएं हैं ... github.com/moinkhan-in/PreferenceSpider
मोइनखान

जवाबों:


548

आप क्लास ऑब्जेक्ट्स को SharedPreferences में संग्रहीत करने के लिए gson.jar का उपयोग कर सकते हैं । आप इस जार को google-gson से डाउनलोड कर सकते हैं

या अपनी ग्रेड फ़ाइल में GSON निर्भरता जोड़ें:

implementation 'com.google.code.gson:gson:2.8.5'

एक साझा प्राथमिकता बनाना:

SharedPreferences  mPrefs = getPreferences(MODE_PRIVATE);

बचाना:

MyObject myObject = new MyObject;
//set variables of 'myObject', etc.

Editor prefsEditor = mPrefs.edit();
Gson gson = new Gson();
String json = gson.toJson(myObject);
prefsEditor.putString("MyObject", json);
prefsEditor.commit();

वापस पाने के लिए:

Gson gson = new Gson();
String json = mPrefs.getString("MyObject", "");
MyObject obj = gson.fromJson(json, MyObject.class);

9
धन्यवाद दोस्त! लेकिन आप सहेजें भाग (पंक्ति 3) में गलत हैं, सही कोड है: स्ट्रिंग json = gson.toJson (myObject);
सीजेरफ्रेरा

क्या आपको सभी 3 जार की आवश्यकता है? उस लिंक में उनमें से 3 हैं। । ।
coolcool1994

3
जार को डाउनलोड करने के लिए सही URL है: search.maven.org/...
Shajeel अफजल

2
यह परिपत्र संदर्भ के साथ एक समस्या है जो StackOverFlowException xD की ओर ले जाती है और पढ़ें यहाँ stackoverflow.com/questions/10209959/…
phuwin

1
@rozina हाँ Gson बेहतर है। क्रमबद्ध का उपयोग करने के लिए सबसे पहले, वस्तु और उसके अंदर की प्रत्येक वस्तु को क्रमबद्ध इंटरफ़ेस को लागू करने की आवश्यकता है। यह gson के लिए आवश्यक नहीं है। जब आपकी वस्तु वस्तुओं की सूची में हो, तो gson भी बढ़िया काम करता है।
नेविल नाजानेन

36

@ मुहम्मदअमराली के उत्तर में जोड़ने के लिए, आप वस्तुओं की सूची को सहेजने और पुनः प्राप्त करने के लिए Gson का उपयोग कर सकते हैं

उपयोगकर्ता-परिभाषित ऑब्जेक्ट्स की सूची को SharedPreferences पर सहेजें

public static final String KEY_CONNECTIONS = "KEY_CONNECTIONS";
SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();

User entity = new User();
// ... set entity fields

List<Connection> connections = entity.getConnections();
// convert java object to JSON format,
// and returned as JSON formatted string
String connectionsJSONString = new Gson().toJson(connections);
editor.putString(KEY_CONNECTIONS, connectionsJSONString);
editor.commit();

SharedPreferences से उपयोगकर्ता-परिभाषित ऑब्जेक्ट्स की सूची प्राप्त करें

String connectionsJSONString = getPreferences(MODE_PRIVATE).getString(KEY_CONNECTIONS, null);
Type type = new TypeToken < List < Connection >> () {}.getType();
List < Connection > connections = new Gson().fromJson(connectionsJSONString, type);

3
वहां "टाइप" क्या है? (गेट लिस्ट में, दूसरी पंक्ति)।
गैंगधरस

15

मुझे पता है कि यह धागा थोड़ा पुराना है। लेकिन मैं यह पोस्ट करने जा रहा हूँ वैसे भी उम्मीद है कि यह किसी की मदद कर सकता है। हम स्ट्रिंग को ऑब्जेक्ट को क्रमबद्ध करके साझा प्राथमिकता के लिए किसी भी ऑब्जेक्ट के फ़ील्ड को स्टोर कर सकते हैं । यहाँ मैंने किसी भी वस्तु को साझा प्राथमिकता पर संग्रहीत करने के लिए उपयोग किया है ।GSON

पसंद को ऑब्जेक्ट सहेजें:

public static void saveObjectToSharedPreference(Context context, String preferenceFileName, String serializedObjectKey, Object object) {
    SharedPreferences sharedPreferences = context.getSharedPreferences(preferenceFileName, 0);
    SharedPreferences.Editor sharedPreferencesEditor = sharedPreferences.edit();
    final Gson gson = new Gson();
    String serializedObject = gson.toJson(object);
    sharedPreferencesEditor.putString(serializedObjectKey, serializedObject);
    sharedPreferencesEditor.apply();
}

वरीयता से प्राप्त वस्तु:

public static <GenericClass> GenericClass getSavedObjectFromPreference(Context context, String preferenceFileName, String preferenceKey, Class<GenericClass> classType) {
    SharedPreferences sharedPreferences = context.getSharedPreferences(preferenceFileName, 0);
    if (sharedPreferences.contains(preferenceKey)) {
        final Gson gson = new Gson();
        return gson.fromJson(sharedPreferences.getString(preferenceKey, ""), classType);
    }
    return null;
}

ध्यान दें :

जोड़ने का ध्यान रखें compile 'com.google.code.gson:gson:2.6.2'करने के लिए dependenciesअपने Gradle में।

उदाहरण :

//assume SampleClass exists
SampleClass mObject = new SampleObject();

//to store an object
saveObjectToSharedPreference(context, "mPreference", "mObjectKey", mObject);

//to retrive object stored in preference
mObject = getSavedObjectFromPreference(context, "mPreference", "mObjectKey", SampleClass.class);

अपडेट करें:

जैसा कि @Sharp_Edge ने टिप्पणियों में बताया है, उपरोक्त समाधान के साथ काम नहीं करता है List

के हस्ताक्षर करने के लिए एक मामूली संशोधन getSavedObjectFromPreference()- से Class<GenericClass> classTypeकरने के लिए Type classTypeइस समाधान सामान्यीकृत कर देगा। संशोधित फ़ंक्शन हस्ताक्षर,

public static <GenericClass> GenericClass getSavedObjectFromPreference(Context context, String preferenceFileName, String preferenceKey, Type classType)

आह्वान के लिए,

getSavedObjectFromPreference(context, "mPreference", "mObjectKey", (Type) SampleClass.class)

हैप्पी कोडिंग!


1
यह वास्तव में धन्यवाद था। यहाँ किसी के लिए कि टिप्पणी करने की परवाह है ... मैं onSaveInstanceState में saveObjectToSaredPreference पर कॉल करना चाहिए? मेरे पास अभी onSaveInstanceState है, लेकिन, मेरा ऐप हर 10 सेकंड में वास्तविक समय का डेटा एकत्र कर रहा है, मुझे हर एक समय में एक बार हिचकी आती है और जिस ऑब्जेक्ट को मैं saveObjectToSadedPreprebe से सेव कर रहा हूं, वह कुछ रीडिंग खो देता है। सभी विचारों का स्वागत है।
फ्रैंक ज़प्पा

हे @FrankZappa, मुझे पूरी तरह से अपनी समस्या को समझने के लिए माफ नहीं, लेकिन यहाँ तुम जाओ, के commitबजाय का उपयोग करने का प्रयास करें apply। यह आपकी मदद कर सकता है।
tpk

धन्यवाद। मुझे समझाने का प्रयास करने दें। मेरा एंड्रॉइड ऐप लगभग हर 10 सेकंड में वास्तविक समय में डेटा एकत्र करता है। इस डेटा संग्रह में वस्तुओं का उपयोग नहीं किया गया है, सिर्फ वैश्विक चर और तर्क। फिर डेटा को संक्षेप में और जावा ऑब्जेक्ट में संग्रहीत किया जाता है। मैं अपनी जावा ऑब्जेक्ट को स्टोर करने और / साझा करने के लिए साझा करने के लिए ऊपर अपनी विधि का उपयोग करता हूं क्योंकि a) मेरी जानकारी में मैं ऑब्जेक्ट्स को onSavedInstanceState और b) में संग्रहीत नहीं कर सकता जब स्क्रीन घूमती है तो मेरी वस्तु नष्ट हो जाती है और फिर से बनती है। इसलिए, मैं आपके SharedPrefs दृष्टिकोण का उपयोग कर रहा हूं, जब स्क्रीन को घुमाया जाता है तो मेरी वस्तु खो जाती है यह मान नहीं खोता है। (cont ..)
फ्रैंक ज़प्पा

मैंने आपके सेवऑब्जेक्टटाउडशेयरिंग की दिनचर्या OnSaveInstanceState में रखी। मैंने onRestoreInstanceState में आपका getSavedObjectFromPreference नियमित रखा। हालाँकि, मैंने परीक्षण किया और अभी भी स्क्रीन रोटेशन के कारण मिस्ड ऑब्जेक्ट अपडेट का एक सेट मिला। इसलिए, क्या मुझे अपने वास्तविक तर्क के करीब saveObjectToSaredPreferences पर कॉल को स्थानांतरित करना चाहिए? अन्त में किस विधि से संबंधित है और क्या लागू होता है?
फ्रैंक ज़प्पा

1
@ 2943 आपको समाधान बहुत अच्छा लग रहा है, लेकिन अगर मेरे पास उदाहरण के लिए सूची है तो मुझे यह List<CustomClass>कैसे करना चाहिए? getSavedObjectFromPreference(context, "mPreference", "mObjectKey", SampleClass.class)स्वीकार नहीं कर रहा है List<CustomClass>.class:(
तेज धार

6

बेहतर है कि Constantsडेटा को लाने या सहेजने के लिए कुंजी या चर को बचाने के लिए एक वैश्विक वर्ग बनाएं ।

डेटा को बचाने के लिए हर जगह से डेटा को बचाने के लिए इस पद्धति को कॉल करें।

public static void saveData(Context con, String variable, String data)
{
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(con);
    prefs.edit().putString(variable, data).commit();
}

डेटा प्राप्त करने के लिए इसका उपयोग करें।

public static String getData(Context con, String variable, String defaultValue)
{
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(con);
    String data = prefs.getString(variable, defaultValue);
    return data;
}

और एक विधि कुछ इस तरह से चाल चलेंगे

public static User getUserInfo(Context con)
{
    String id =  getData(con, Constants.USER_ID, null);
    String name =  getData(con, Constants.USER_NAME, null);
    if(id != null && name != null)
    {
            User user = new User(); //Hope you will have a user Object.
            user.setId(id);
            user.setName(name);
            //Here set other credentials.
            return user;
    }
    else
    return null;
}

डेटा वापस पाने के लिए, मुझे 'वैरिएबल' और 'डिफॉल्ट वेल्यू' के रूप में क्या पास करना चाहिए?
एलेक्स

कभी भी एक कॉन्स्टेंट क्लास नहीं बनाएं। यह आपके कोड को एक ही समय में अत्यधिक युग्मित और बिखरा हुआ बनाता है।
Miha_x64

5

इस सर्वोत्तम तरीके का प्रयास करें:

PreferenceConnector.java

import android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;

public class PreferenceConnector {
    public static final String PREF_NAME = "ENUMERATOR_PREFERENCES";
    public static final String PREF_NAME_REMEMBER = "ENUMERATOR_REMEMBER";
    public static final int MODE = Context.MODE_PRIVATE;


    public static final String name = "name";


    public static void writeBoolean(Context context, String key, boolean value) {
        getEditor(context).putBoolean(key, value).commit();
    }

    public static boolean readBoolean(Context context, String key,
            boolean defValue) {
        return getPreferences(context).getBoolean(key, defValue);
    }

    public static void writeInteger(Context context, String key, int value) {
        getEditor(context).putInt(key, value).commit();

    }

    public static int readInteger(Context context, String key, int defValue) {
        return getPreferences(context).getInt(key, defValue);
    }

    public static void writeString(Context context, String key, String value) {
        getEditor(context).putString(key, value).commit();

    }

    public static String readString(Context context, String key, String defValue) {
        return getPreferences(context).getString(key, defValue);
    }

    public static void writeLong(Context context, String key, long value) {
        getEditor(context).putLong(key, value).commit();
    }

    public static long readLong(Context context, String key, long defValue) {
        return getPreferences(context).getLong(key, defValue);
    }

    public static SharedPreferences getPreferences(Context context) {
        return context.getSharedPreferences(PREF_NAME, MODE);
    }

    public static Editor getEditor(Context context) {
        return getPreferences(context).edit();
    }

}

मान लिखें:

PreferenceConnector.writeString(this, PreferenceConnector.name,"Girish");

और उपयोग मूल्य प्राप्त करें:

String name= PreferenceConnector.readString(this, PreferenceConnector.name, "");

2
एंड्रॉइड पर शेयर्डप्रिफरेंस में किसी ऑब्जेक्ट को सेव करने के लिए इसका क्या करना है?
इगोरगानपोलस्की

Sharedpreferences के साथ काम करने के बारे में अधिक जानकारी stackoverflow.com/a/2614771/1815624 पर ध्यान दें जो आप return PreferenceManager.getDefaultSharedPreferences(context);इसके बजाय इस्तेमाल करना चाहते हैंreturn context.getSharedPreferences(PREF_NAME, MODE);
CrandellWS

3

आपने यह नहीं बताया कि आप इसके prefsEditorबाद वस्तु के साथ क्या करते हैं , लेकिन वरीयता डेटा को बनाए रखने के लिए, आपको उपयोग करने की भी आवश्यकता है:

prefsEditor.commit();

2

यहाँ देखें, यह आपकी मदद कर सकता है:

public static boolean setObject(Context context, Object o) {
        Field[] fields = o.getClass().getFields();
        SharedPreferences sp = context.getSharedPreferences(o.getClass()
                .getName(), Context.MODE_PRIVATE);
        Editor editor = sp.edit();
        for (int i = 0; i < fields.length; i++) {
            Class<?> type = fields[i].getType();
            if (isSingle(type)) {
                try {
                    final String name = fields[i].getName();
                    if (type == Character.TYPE || type.equals(String.class)) {
                        Object value = fields[i].get(o);
                        if (null != value)
                            editor.putString(name, value.toString());
                    } else if (type.equals(int.class)
                            || type.equals(Short.class))
                        editor.putInt(name, fields[i].getInt(o));
                    else if (type.equals(double.class))
                        editor.putFloat(name, (float) fields[i].getDouble(o));
                    else if (type.equals(float.class))
                        editor.putFloat(name, fields[i].getFloat(o));
                    else if (type.equals(long.class))
                        editor.putLong(name, fields[i].getLong(o));
                    else if (type.equals(Boolean.class))
                        editor.putBoolean(name, fields[i].getBoolean(o));

                } catch (IllegalAccessException e) {
                    LogUtils.e(TAG, e);
                } catch (IllegalArgumentException e) {
                    LogUtils.e(TAG, e);
                }
            } else {
                // FIXME 是对象则不写入
            }
        }

        return editor.commit();
    }

https://github.com/AltasT/PreferenceVObjectFile/blob/master/PreferenceVObjectFile/src/com/altas/lib/PreferenceUtils.java


2
क्या आप कोड को थोड़ा और समझा सकते हैं क्योंकि यह वर्तमान में "कोड का एक गुच्छा" दर्शाता है।
वर्नर

1

जोंस प्रारूप का उपयोग किए बिना किसी ऑब्जेक्ट को एंड्रॉइड के साझाकरण से बचाने और पुनर्स्थापित करने का दूसरा तरीका

private static ExampleObject getObject(Context c,String db_name){
            SharedPreferences sharedPreferences = c.getSharedPreferences(db_name, Context.MODE_PRIVATE);
            ExampleObject o = new ExampleObject();
            Field[] fields = o.getClass().getFields();
            try {
                for (Field field : fields) {
                    Class<?> type = field.getType();
                    try {
                        final String name = field.getName();
                        if (type == Character.TYPE || type.equals(String.class)) {
                            field.set(o,sharedPreferences.getString(name, ""));
                        } else if (type.equals(int.class) || type.equals(Short.class))
                            field.setInt(o,sharedPreferences.getInt(name, 0));
                        else if (type.equals(double.class))
                            field.setDouble(o,sharedPreferences.getFloat(name, 0));
                        else if (type.equals(float.class))
                            field.setFloat(o,sharedPreferences.getFloat(name, 0));
                        else if (type.equals(long.class))
                            field.setLong(o,sharedPreferences.getLong(name, 0));
                        else if (type.equals(Boolean.class))
                            field.setBoolean(o,sharedPreferences.getBoolean(name, false));
                        else if (type.equals(UUID.class))
                            field.set(
                                    o,
                                    UUID.fromString(
                                            sharedPreferences.getString(
                                                    name,
                                                    UUID.nameUUIDFromBytes("".getBytes()).toString()
                                            )
                                    )
                            );

                    } catch (IllegalAccessException e) {
                        Log.e(StaticConfig.app_name, "IllegalAccessException", e);
                    } catch (IllegalArgumentException e) {
                        Log.e(StaticConfig.app_name, "IllegalArgumentException", e);
                    }
                }
            } catch (Exception e) {
                System.out.println("Exception: " + e);
            }
            return o;
        }
        private static void setObject(Context context, Object o, String db_name) {
            Field[] fields = o.getClass().getFields();
            SharedPreferences sp = context.getSharedPreferences(db_name, Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sp.edit();
            for (Field field : fields) {
                Class<?> type = field.getType();
                try {
                    final String name = field.getName();
                    if (type == Character.TYPE || type.equals(String.class)) {
                        Object value = field.get(o);
                        if (value != null)
                            editor.putString(name, value.toString());
                    } else if (type.equals(int.class) || type.equals(Short.class))
                        editor.putInt(name, field.getInt(o));
                    else if (type.equals(double.class))
                        editor.putFloat(name, (float) field.getDouble(o));
                    else if (type.equals(float.class))
                        editor.putFloat(name, field.getFloat(o));
                    else if (type.equals(long.class))
                        editor.putLong(name, field.getLong(o));
                    else if (type.equals(Boolean.class))
                        editor.putBoolean(name, field.getBoolean(o));
                    else if (type.equals(UUID.class))
                        editor.putString(name, field.get(o).toString());

                } catch (IllegalAccessException e) {
                    Log.e(StaticConfig.app_name, "IllegalAccessException", e);
                } catch (IllegalArgumentException e) {
                    Log.e(StaticConfig.app_name, "IllegalArgumentException", e);
                }
            }

            editor.apply();
        }

1

आप किसी भी पुस्तकालय का उपयोग किए बिना प्राथमिकताओं में ऑब्जेक्ट को बचा सकते हैं, सबसे पहले आपके ऑब्जेक्ट क्लास को सीरियल योग्य लागू करना होगा:

public class callModel implements Serializable {

private long pointTime;
private boolean callisConnected;

public callModel(boolean callisConnected,  long pointTime) {
    this.callisConnected = callisConnected;
    this.pointTime = pointTime;
}
public boolean isCallisConnected() {
    return callisConnected;
}
public long getPointTime() {
    return pointTime;
}

}

फिर आप ऑब्जेक्ट को स्ट्रिंग और स्ट्रिंग को ऑब्जेक्ट में बदलने के लिए आसानी से इन दो तरीकों का उपयोग कर सकते हैं:

 public static <T extends Serializable> T stringToObjectS(String string) {
    byte[] bytes = Base64.decode(string, 0);
    T object = null;
    try {
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(bytes));
        object = (T) objectInputStream.readObject();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return object;
}

 public static String objectToString(Parcelable object) {
    String encoded = null;
    try {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(object);
        objectOutputStream.close();
        encoded = new String(Base64.encodeToString(byteArrayOutputStream.toByteArray(), 0));
    } catch (IOException e) {
        e.printStackTrace();
    }
    return encoded;
}

बचाना:

SharedPreferences  mPrefs = getPreferences(MODE_PRIVATE);
Editor prefsEditor = mPrefs.edit();
prefsEditor.putString("MyObject", objectToString(callModelObject));
prefsEditor.commit();

पढ़ने के लिए

String value= mPrefs.getString("MyObject", "");
MyObject obj = stringToObjectS(value);

आप इन बाइट्स को एक अलग फाइल में लिखकर बेस 64 एनकोडिंग और एक्सएमएल से बच सकते हैं।
Miha_x64

1

चरण 1: अपनी जावा फ़ाइल में इन दो कार्यों को कॉपी पेस्ट करें।

 public void setDefaults(String key, String value, Context context) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        SharedPreferences.Editor editor = preferences.edit();
        editor.putString(key, value);
        editor.commit();
    }


    public static String getDefaults(String key, Context context) {
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        return preferences.getString(key, null);
    }

चरण 2: उपयोग को बचाने के लिए:

 setDefaults("key","value",this);

उपयोग पुनः प्राप्त करने के लिए:

String retrieve= getDefaults("key",this);

आप विभिन्न प्रमुख नामों का उपयोग करके विभिन्न साझा प्राथमिकताएँ सेट कर सकते हैं जैसे:

setDefaults("key1","xyz",this);

setDefaults("key2","abc",this);

setDefaults("key3","pqr",this);

1

यदि आप उस संपूर्ण ऑब्जेक्ट को संग्रहीत करना चाहते हैं जो आपको प्रतिक्रिया में मिलता है, तो यह कुछ ऐसा करके प्राप्त कर सकता है,

पहले एक विधि बनाएं जो आपके JSON को नीचे दिए गए उपयोग वर्ग में एक स्ट्रिंग में परिवर्तित करता है।

 public static <T> T fromJson(String jsonString, Class<T> theClass) {
    return new Gson().fromJson(jsonString, theClass);
}

फिर साझा प्राथमिकता वर्ग में कुछ ऐसा करें,

 public void storeLoginResponse(yourResponseClass objName) {

    String loginJSON = UtilClass.toJson(customer);
    if (!TextUtils.isEmpty(customerJSON)) {
        editor.putString(AppConst.PREF_CUSTOMER, customerJSON);
        editor.commit();
    }
}

और फिर getPreferences के लिए एक विधि बनाएं

public Customer getCustomerDetails() {
    String customerDetail = pref.getString(AppConst.PREF_CUSTOMER, null);
    if (!TextUtils.isEmpty(customerDetail)) {
        return GSONConverter.fromJson(customerDetail, Customer.class);
    } else {
        return new Customer();
    }
}

तब बस पहली विधि को कॉल करें जब आपको प्रतिक्रिया मिलती है और दूसरी जब आपको शेयर प्राथमिकताएं जैसे डेटा प्राप्त करने की आवश्यकता होती है

String token = SharedPrefHelper.get().getCustomerDetails().getAccessToken();

बस इतना ही।

आशा है इससे आपकी मदद होगी।

Happy Coding();


1

मुझे संपूर्ण गतिविधियों में साझा वरीयता डेटा तक पहुंचने के लिए स्वीकृत उत्तर का उपयोग करने में परेशानी हुई। इन चरणों में, आप इसे एक्सेस करने के लिए एक नाम getSaringPreferences देते हैं।

ग्रेडल स्क्रिप्स के तहत build.gradel (मॉड्यूल: ऐप) फ़ाइल में निम्न निर्भरता जोड़ें:

implementation 'com.google.code.gson:gson:2.8.5'

बचाना:

MyObject myObject = new MyObject;
//set variables of 'myObject', etc.

SharedPreferences mPrefs = getSharedPreferences("Name", Context.MODE_PRIVATE);

Editor prefsEditor = mPrefs.edit();
Gson gson = new Gson();
String json = gson.toJson(myObject);
prefsEditor.putString("Key", json);
prefsEditor.commit();

एक अलग गतिविधि में पुनः प्राप्त करने के लिए:

SharedPreferences mPrefs = getSharedPreferences("Name", Context.MODE_PRIVATE);

Gson gson = new Gson();
String json = mPrefs.getString("Key", "");
MyObject obj = gson.fromJson(json, MyObject.class);

1
// SharedPrefHelper is a class contains the get and save sharedPrefernce data
public class SharedPrefHelper {

    // save data in sharedPrefences
    public static void setSharedOBJECT(Context context, String key, 
                                           Object value) {

        SharedPreferences sharedPreferences =  context.getSharedPreferences(
                context.getPackageName(), Context.MODE_PRIVATE);

        SharedPreferences.Editor prefsEditor = sharedPreferences.edit();
        Gson gson = new Gson();
        String json = gson.toJson(value);
        prefsEditor.putString(key, json);
        prefsEditor.apply();
    }

    // get data from sharedPrefences 
    public static Object getSharedOBJECT(Context context, String key) {

         SharedPreferences sharedPreferences = context.getSharedPreferences(
                           context.getPackageName(), Context.MODE_PRIVATE);

        Gson gson = new Gson();
        String json = sharedPreferences.getString(key, "");
        Object obj = gson.fromJson(json, Object.class);
        User objData = new Gson().fromJson(obj.toString(), User.class);
        return objData;
    }
}
// save data in your activity

User user = new User("Hussein","h@h.com","3107310890983");        
SharedPrefHelper.setSharedOBJECT(this,"your_key",user);        
User data = (User) SharedPrefHelper.getSharedOBJECT(this,"your_key");

Toast.makeText(this,data.getName()+"\n"+data.getEmail()+"\n"+data.getPhone(),Toast.LENGTH_LONG).show();
// User is the class you want to save its objects

public class User {

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    private String name,email,phone;
    public User(String name,String email,String phone){
          this.name=name;
          this.email=email;
          this.phone=phone;
    }
}
// put this in gradle

compile 'com.google.code.gson:gson:2.7'

उम्मीद है कि यह आपकी मदद करता है :)


1

यहाँ पर कोटलिन डेलीगेटेड प्रॉपर्टीज़ का उपयोग किया गया है, जिन्हें मैंने यहाँ से उठाया था है, लेकिन पर विस्तार किया है और हो रही है / SharedPreference गुण स्थापित करने के लिए एक सरल तंत्र के लिए अनुमति देता है।

के लिए String, Int, Long, Floatया Boolean, यह मानक SharePreference गेटर (रों) और सेटर (रों) उपयोग करता है। हालाँकि, अन्य सभी डेटा वर्गों के लिए, यह Stringसेटर के लिए, क्रमबद्ध करने के लिए GSON का उपयोग करता है । फिर डेटा ऑब्जेक्ट के लिए deserializes, गेटर के लिए।

अन्य समाधानों के समान, इसके लिए जीएसओएन को आपकी श्रेणी फ़ाइल में निर्भरता के रूप में जोड़ना आवश्यक है:

implementation 'com.google.code.gson:gson:2.8.6'

यहां एक सरल डेटा वर्ग का एक उदाहरण दिया गया है जिसे हम साझा करना चाहते हैं और साझा करने के लिए स्टोर कर सकते हैं:

data class User(val first: String, val last: String)

यहाँ एक वर्ग है जो संपत्ति प्रतिनिधियों को लागू करता है:

object UserPreferenceProperty : PreferenceProperty<User>(
    key = "USER_OBJECT",
    defaultValue = User(first = "Jane", last = "Doe"),
    clazz = User::class.java)

object NullableUserPreferenceProperty : NullablePreferenceProperty<User?, User>(
    key = "NULLABLE_USER_OBJECT",
    defaultValue = null,
    clazz = User::class.java)

object FirstTimeUser : PreferenceProperty<Boolean>(
        key = "FIRST_TIME_USER",
        defaultValue = false,
        clazz = Boolean::class.java
)

sealed class PreferenceProperty<T : Any>(key: String,
                                         defaultValue: T,
                                         clazz: Class<T>) : NullablePreferenceProperty<T, T>(key, defaultValue, clazz)

@Suppress("UNCHECKED_CAST")
sealed class NullablePreferenceProperty<T : Any?, U : Any>(private val key: String,
                                                           private val defaultValue: T,
                                                           private val clazz: Class<U>) : ReadWriteProperty<Any, T> {

    override fun getValue(thisRef: Any, property: KProperty<*>): T = HandstandApplication.appContext().getPreferences()
            .run {
                when {
                    clazz.isAssignableFrom(String::class.java) -> getString(key, defaultValue as String?) as T
                    clazz.isAssignableFrom(Int::class.java) -> getInt(key, defaultValue as Int) as T
                    clazz.isAssignableFrom(Long::class.java) -> getLong(key, defaultValue as Long) as T
                    clazz.isAssignableFrom(Float::class.java) -> getFloat(key, defaultValue as Float) as T
                    clazz.isAssignableFrom(Boolean::class.java) -> getBoolean(key, defaultValue as Boolean) as T
                    else -> getObject(key, defaultValue, clazz)
                }
            }

    override fun setValue(thisRef: Any, property: KProperty<*>, value: T) = HandstandApplication.appContext().getPreferences()
            .edit()
            .apply {
                when {
                    clazz.isAssignableFrom(String::class.java) -> putString(key, value as String?) as T
                    clazz.isAssignableFrom(Int::class.java) -> putInt(key, value as Int) as T
                    clazz.isAssignableFrom(Long::class.java) -> putLong(key, value as Long) as T
                    clazz.isAssignableFrom(Float::class.java) -> putFloat(key, value as Float) as T
                    clazz.isAssignableFrom(Boolean::class.java) -> putBoolean(key, value as Boolean) as T
                    else -> putObject(key, value)
                }
            }
            .apply()

    private fun Context.getPreferences(): SharedPreferences = getSharedPreferences(APP_PREF_NAME, Context.MODE_PRIVATE)

    private fun <T, U> SharedPreferences.getObject(key: String, defValue: T, clazz: Class<U>): T =
            Gson().fromJson(getString(key, null), clazz) as T ?: defValue

    private fun <T> SharedPreferences.Editor.putObject(key: String, value: T) = putString(key, Gson().toJson(value))

    companion object {
        private const val APP_PREF_NAME = "APP_PREF"
    }
}

नोट: यदि आप में अद्यतन कुछ भी करने की जरूरत नहीं होनी चाहिए sealed class। प्रत्यायोजित गुण ऑब्जेक्ट / सिंगलटन हैं UserPreferenceProperty, NullableUserPreferencePropertyऔरFirstTimeUser

SharedPreferences से बचत / प्राप्त करने के लिए एक नई डेटा ऑब्जेक्ट को सेटअप करने के लिए, अब चार पंक्तियों को जोड़ना जितना आसान है:

object NewPreferenceProperty : PreferenceProperty<String>(
        key = "NEW_PROPERTY",
        defaultValue = "",
        clazz = String::class.java)

अंत में, आप केवल byकीवर्ड का उपयोग करके शेयर्डपिरिफायर को मान पढ़ / लिख सकते हैं :

private var user: User by UserPreferenceProperty
private var nullableUser: User? by NullableUserPreferenceProperty
private var isFirstTimeUser: Boolean by 

Log.d("TAG", user) // outputs the `defaultValue` for User the first time
user = User(first = "John", last = "Doe") // saves this User to the Shared Preferences
Log.d("TAG", user) // outputs the newly retrieved User (John Doe) from Shared Preferences

0

यदि आपकी वस्तु जटिल है, तो मैं इसे सीरियल / XML / JSON को सीरियलाइज़ करने का सुझाव दूंगा और उन सामग्रियों को एसडी कार्ड में सहेजूंगा। आप बाह्य संग्रहण को यहां सहेजने के बारे में अतिरिक्त जानकारी पा सकते हैं: http://developer.android.com/guide/topics/data/data-storage.html#filesExternal


क्या इसके लिए अतिरिक्त अनुमति (एसडी कार्ड) की आवश्यकता नहीं होगी?
ऋषभ

हाँ, यह तब होगा जब आप एसडी कार्ड पर लिख रहे होंगे।
trenpixster

1
मेरे अनुभव से, उपयोगकर्ता के लिए आवश्यक कम अनुमतियाँ, बेहतर। एसडी कार्ड एक द्वितीयक विकल्प होना चाहिए, अगर ऊपर बताए अनुसार गॉन का उपयोग करना एक व्यवहार्य विकल्प नहीं है।
ऋषभ

हाँ, मैं भी इससे सहमत हूँ; केवल अगर JSON परिणाम काफी बड़ा है तो एसडी कार्ड एक विकल्प होना चाहिए। यह एक व्यापार-बंद है जो मैं कहूंगा।
trenpixster 23

0

वहाँ दो फ़ाइल साझा करने के बारे में आपकी सभी समस्या का समाधान कर रहे हैं

1) AppPersistence.java

    public class AppPersistence {
    public enum keys {
        USER_NAME, USER_ID, USER_NUMBER, USER_EMAIL, USER_ADDRESS, CITY, USER_IMAGE,
        DOB, MRG_Anniversary, COMPANY, USER_TYPE, support_phone
    }

    private static AppPersistence mAppPersistance;
    private SharedPreferences sharedPreferences;

    public static AppPersistence start(Context context) {
        if (mAppPersistance == null) {
            mAppPersistance = new AppPersistence(context);
        }
        return mAppPersistance;
    }

    private AppPersistence(Context context) {
        sharedPreferences = context.getSharedPreferences(context.getString(R.string.prefrence_file_name),
                Context.MODE_PRIVATE);
    }

    public Object get(Enum key) {
        Map<String, ?> all = sharedPreferences.getAll();
        return all.get(key.toString());
    }

    void save(Enum key, Object val) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        if (val instanceof Integer) {
            editor.putInt(key.toString(), (Integer) val);
        } else if (val instanceof String) {
            editor.putString(key.toString(), String.valueOf(val));
        } else if (val instanceof Float) {
            editor.putFloat(key.toString(), (Float) val);
        } else if (val instanceof Long) {
            editor.putLong(key.toString(), (Long) val);
        } else if (val instanceof Boolean) {
            editor.putBoolean(key.toString(), (Boolean) val);
        }
        editor.apply();
    }

    void remove(Enum key) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.remove(key.toString());
        editor.apply();
    }

    public void removeAll() {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.clear();
        editor.apply();
    }
}

2) AppPreference.java

public static void setPreference(Context context, Enum Name, String Value) {
        AppPersistence.start(context).save(Name, Value);
    }

    public static String getPreference(Context context, Enum Name) {
        return (String) AppPersistence.start(context).get(Name);
    }

    public static void removePreference(Context context, Enum Name) {
        AppPersistence.start(context).remove(Name);
    }
}

अब आप बचा सकते हैं, हटा सकते हैं या पसंद कर सकते हैं,

-सहेजें

AppPreference.setPreference(context, AppPersistence.keys.USER_ID, userID);

-हटाना

AppPreference.removePreference(context, AppPersistence.keys.USER_ID);

-प्राप्त

 AppPreference.getPreference(context, AppPersistence.keys.USER_ID);

0

SharedPreference में डेटा संग्रहीत करें

SharedPreferences mprefs = getSharedPreferences(AppConstant.PREFS_NAME, MODE_PRIVATE)
mprefs.edit().putString(AppConstant.USER_ID, resUserID).apply();

0

मेरी सूची को बचाने के लिए बर्तन कक्षा SharedPreferences

public class SharedPrefApi {
    private SharedPreferences sharedPreferences;
    private Gson gson;

    public SharedPrefApi(Context context, Gson gson) {
        this.sharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.gson = gson;
    } 

    ...

    public <T> void putObject(String key, T value) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(key, gson.toJson(value));
        editor.apply();
    }

    public <T> T getObject(String key, Class<T> clazz) {
        return gson.fromJson(getString(key, null), clazz);
    }
}

का उपयोग करते हुए

// for save
sharedPrefApi.putList(SharedPrefApi.Key.USER_LIST, userList);

// for retrieve
List<User> userList = sharedPrefApi.getList(SharedPrefApi.Key.USER_LIST, User.class);


मेरे बर्तनों का पूरा कोड // गतिविधि कोड में उदाहरण का उपयोग करके जांच करें


0

मैंने अपनी वस्तुओं ( जैकसन ) को संग्रहीत करने के लिए जैकसन का उपयोग किया है ।

जोड़ा गया जैक्सन पुस्तकालय को हटाने के लिए:

api 'com.fasterxml.jackson.core:jackson-core:2.9.4'
api 'com.fasterxml.jackson.core:jackson-annotations:2.9.4'
api 'com.fasterxml.jackson.core:jackson-databind:2.9.4'

मेरा परीक्षण वर्ग:

public class Car {
    private String color;
    private String type;
    // standard getters setters
}

जावा के लिए जावा ऑब्जेक्ट:

ObjectMapper objectMapper = new ObjectMapper();
String carAsString = objectMapper.writeValueAsString(car);

इसे साझा प्राथमिकताओं में संग्रहीत करें:

preferences.edit().car().put(carAsString).apply();

साझा प्राथमिकताओं से इसे पुनर्स्थापित करें:

ObjectMapper objectMapper = new ObjectMapper();
Car car = objectMapper.readValue(preferences.car().get(), Car.class);
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.