Sous Android, pouvons-nous stocker un objet d'une classe dans les préférences partagées et le récupérer plus tard?
Si c'est possible, comment le faire? Si ce n’est pas possible, quelles sont les autres possibilités de le faire?
Je sais que la sérialisation est une option, mais je recherche des possibilités en utilisant les préférences partagées.
Pas possible.
Vous pouvez uniquement stocker des valeurs simples dans SharedPreferences SharedPreferences.Editor
Qu'en est-il de la classe que vous devez économiser?
Oui, nous pouvons le faire avec Gson
Téléchargez le code de travail de GitHub
SharedPreferences mPrefs = getPreferences(MODE_PRIVATE);
Pour sauvegarder
Editor prefsEditor = mPrefs.edit();
Gson gson = new Gson();
String json = gson.toJson(myObject); // myObject - instance of MyObject
prefsEditor.putString("MyObject", json);
prefsEditor.commit();
Oublier
Gson gson = new Gson();
String json = mPrefs.getString("MyObject", "");
MyObject obj = gson.fromJson(json, MyObject.class);
La dernière version de GSON peut être téléchargée à partir de github.com/google/gson .
Si vous utilisez Gradle/Android Studio, insérez simplement ce qui suit dans la section des dépendances build.gradle
-
compile 'com.google.code.gson:gson:2.6.2'
nous pouvons utiliser Outputstream pour sortir notre objet dans la mémoire interne. Et convertir en chaîne puis enregistrer de préférence. Par exemple:
mPrefs = getPreferences(MODE_PRIVATE);
SharedPreferences.Editor ed = mPrefs.edit();
ByteArrayOutputStream arrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutput;
try {
objectOutput = new ObjectOutputStream(arrayOutputStream);
objectOutput.writeObject(object);
byte[] data = arrayOutputStream.toByteArray();
objectOutput.close();
arrayOutputStream.close();
ByteArrayOutputStream out = new ByteArrayOutputStream();
Base64OutputStream b64 = new Base64OutputStream(out, Base64.DEFAULT);
b64.write(data);
b64.close();
out.close();
ed.putString(key, new String(out.toByteArray()));
ed.commit();
} catch (IOException e) {
e.printStackTrace();
}
lorsque nous devons extraire Object from Preference. Utilisez le code comme ci-dessous
byte[] bytes = mPrefs.getString(indexName, "{}").getBytes();
if (bytes.length == 0) {
return null;
}
ByteArrayInputStream byteArray = new ByteArrayInputStream(bytes);
Base64InputStream base64InputStream = new Base64InputStream(byteArray, Base64.DEFAULT);
ObjectInputStream in;
in = new ObjectInputStream(base64InputStream);
MyObject myObject = (MyObject) in.readObject();
J'ai eu le même problème, voici ma solution:
J'ai la classe MyClass et ArrayList <MyClass> que je veux enregistrer dans les préférences partagées. Au début, j'ai ajouté une méthode à MyClass qui la convertit en objet JSON:
public JSONObject getJSONObject() {
JSONObject obj = new JSONObject();
try {
obj.put("id", this.id);
obj.put("name", this.name);
} catch (JSONException e) {
e.printStackTrace();
}
return obj;
}
Ensuite, voici la méthode pour enregistrer l'objet "ArrayList <MyClass> items":
SharedPreferences mPrefs = context.getSharedPreferences("some_name", 0);
SharedPreferences.Editor editor = mPrefs.edit();
Set<String> set= new HashSet<String>();
for (int i = 0; i < items.size(); i++) {
set.add(items.get(i).getJSONObject().toString());
}
editor.putStringSet("some_name", set);
editor.commit();
Et voici la méthode pour récupérer l'objet:
public static ArrayList<MyClass> loadFromStorage() {
SharedPreferences mPrefs = context.getSharedPreferences("some_name", 0);
ArrayList<MyClass> items = new ArrayList<MyClass>();
Set<String> set = mPrefs.getStringSet("some_name", null);
if (set != null) {
for (String s : set) {
try {
JSONObject jsonObject = new JSONObject(s);
Long id = jsonObject.getLong("id"));
String name = jsonObject.getString("name");
MyClass myclass = new MyClass(id, name);
items.add(myclass);
} catch (JSONException e) {
e.printStackTrace();
}
}
return items;
}
Notez que StringSet dans les préférences partagées est disponible depuis l’API 11.
Utilisation de la bibliothèque Gson:
dependencies {
compile 'com.google.code.gson:gson:2.8.2'
}
Le magasin:
Gson gson = new Gson();
//Your json response object value store in json object
JSONObject jsonObject = response.getJSONObject();
//Convert json object to string
String json = gson.toJson(jsonObject);
//Store in the sharedpreference
getPrefs().setUserJson(json);
Récupérer:
String json = getPrefs().getUserJson();
Vous pouvez utiliser Préférences complexes Android - de Felipe Silvestre library pour stocker vos objets personnalisés . En gros, il utilise le mécanisme GSON pour stocker des objets .
Pour enregistrer un objet dans les préférences:
User user = new User();
user.setName("Felipe");
user.setAge(22);
user.setActive(true);
ComplexPreferences complexPreferences = ComplexPreferences.getComplexPreferences(
this, "mypref", MODE_PRIVATE);
complexPreferences.putObject("user", user);
complexPreferences.commit();
Et pour le récupérer:
ComplexPreferences complexPreferences = ComplexPreferences.getComplexPreferences(this, "mypref", MODE_PRIVATE);
User user = complexPreferences.getObject("user", User.class);
Vous pouvez le faire en utilisant la bibliothèque PowerPreference
en 3 étapes faciles!
https://github.com/AliEsaAssadi/Android-Power-Preference
Object obj = new Object();
PowerPreference.defult().put("object",obj);
Object obj = PowerPreference.defult()
.getObject("object", Object.class);
Vous pouvez utiliser GSON en utilisant Gradle Build.gradle:
implementation 'com.google.code.gson:gson:2.8.0'
Ensuite, dans votre code, par exemple, des paires string/boolean avec Kotlin:
val nestedData = HashMap<String,Boolean>()
for (i in 0..29) {
nestedData.put(i.toString(), true)
}
val gson = Gson()
val jsonFromMap = gson.toJson(nestedData)
Ajout aux SharedPrefs:
val sharedPrefEditor = context.getSharedPreferences(_prefName, Context.MODE_PRIVATE).edit()
sharedPrefEditor.putString("sig_types", jsonFromMap)
sharedPrefEditor.apply()
Maintenant, pour récupérer des données:
val gson = Gson()
val sharedPref: SharedPreferences = context.getSharedPreferences(_prefName, Context.MODE_PRIVATE)
val json = sharedPref.getString("sig_types", "false")
val type = object : TypeToken<Map<String, Boolean>>() {}.type
val map = gson.fromJson(json, type) as LinkedTreeMap<String,Boolean>
for (key in map.keys) {
Log.i("myvalues", key.toString() + map.get(key).toString())
}
En utilisant cet objet -> TinyDB - Android-Shared-Preferences-Turbo c'est très simple ... vous pouvez enregistrer la plupart des objets couramment utilisés comme des tableaux, des entiers, des listes de chaînes, etc.
Avez-vous besoin de récupérer l'objet même après la fermeture de l'application ou juste pendant son exécution?
Vous pouvez le stocker dans une base de données.
Ou créez simplement une classe d'application personnalisée.
public class MyApplication extends Application {
private static Object mMyObject;
// static getter & setter
...
}
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android">
<application ... Android:name=".MyApplication">
<activity ... />
...
</application>
...
</manifest>
Et puis de toutes les activités faire:
((MyApplication) getApplication).getMyObject();
Pas vraiment le meilleur moyen mais ça marche.