La meilleure façon de mettre en cache json

Mon application devrait fonctionner non seulement en ligne mais aussi en mode hors ligne. Pour cette raison, j'envisage de trouver le meilleur moyen d'encaissement des données. J'aime pas utiliser SharedPreference pour stocker des données, mais dans android documentation rédigé taille Maximum de caractères autorisés pour les préférences de valeur est de 8192. Je ne sais pas c'est ok ou pas? J'ai essayé de sortir de cette idée d'essayer d'utiliser FileCashing sqLite ou d'encaissement.

Donc ce que vous en pensez les gars, quel est le meilleur SharedPreference vs FileCashing ou vs SqLiteCaching?

source d'informationauteur fish40

  1. 12

    Personnellement, j'aime à le faire de la façon suivante. Créer une base de données SQLite qui peut contenir votre contenu. Ensuite, lier l'interface utilisateur directement à la base de données à l'aide de Cartes & des Fournisseurs de Contenu que d'envoyer une notification à chaque fois que les données sont modifiées de sorte que l'INTERFACE utilisateur peut mettre à jour lui-même. Le dernier morceau de l'équation est une certaine forme de service de synchronisation qui télécharge le contenu et l'enregistre dans la base de données de manière asynchrone. De cette façon, vous pouvez gérer vos données très facilement car il est tous dans le même endroit. La seule partie que vous aurez à comprendre pour votre application est la façon dont vous décidez du moment de la mise à jour ou supprimer les données de la base de données.

    Adaptateurs

    ContentProvider

    La synchronisation

  2. 17

    Enregistrer le json dans le répertoire de cache de fichiers....

    Enregistrer:

    //Instantiate a JSON object from the request response
JSONObject jsonObject = new JSONObject(json);
//Save the JSONOvject
ObjectOutput out = new ObjectOutputStream(new FileOutputStream(new File(getCacheDir(),"")+"cacheFile.srl"));
out.writeObject( jsonObject );
out.close();

    Récupérer:

    //Load in an object
ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File(new File(getCacheDir(),"")+"cacheFile.srl")));
JSONObject jsonObject = (JSONObject) in.readObject();
in.close();
  3. 0

    En fonction de vos besoins, je recommanderais de base de données SQLite.

    Depuis partagés préférence est adapté pour le stockage de la configuration - souvent de petites données/cordes.

    Fichier cache est dur à gérer, donc je vous recommande de SQLite - facile à gérer et la capacité de stocker des données en masse.

    Compte tenu de la performance, si le nombre d'index n'est pas énorme, base de données SQLite devrait avoir des performances acceptables. E. g. seulement plusieurs ms plus lent qu'un fichier de cache.

    Vous pourriez être en mesure de combiner ces deux approches ensemble. Utiliser fichier à accès aléatoire avec index offset stockées dans SQLite.

  4. 0

    J'ai utilisé de Stockage Interne qui fichier de la banque dans package d'Application répertoire qui ne peut être accessible par n'dispositif enracinée.

    Ici, la classe qui permet de créer, lire et supprimer le fichier

    public class ReadWriteJsonFileUtils {
Activity activity;
Context context;
public ReadWriteJsonFileUtils(Context context) {
this.context = context;
}
public void createJsonFileData(String filename, String mJsonResponse) {
try {
File checkFile = new File(context.getApplicationInfo().dataDir + "/new_directory_name/");
if (!checkFile.exists()) {
checkFile.mkdir();
}
FileWriter file = new FileWriter(checkFile.getAbsolutePath() + "/" + filename);
file.write(mJsonResponse);
file.flush();
file.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public String readJsonFileData(String filename) {
try {
File f = new File(context.getApplicationInfo().dataDir + "/new_directory_name/" + filename);
if (!f.exists()) {
onNoResult();
return null;
}
FileInputStream is = new FileInputStream(f);
int size = is.available();
byte[] buffer = new byte[size];
is.read(buffer);
is.close();
return new String(buffer);
} catch (IOException e) {
e.printStackTrace();
}
onNoResult();
return null;
}
public void deleteFile() {
File f = new File(context.getApplicationInfo().dataDir + "/new_directory_name/");
File[] files = f.listFiles();
for (File fInDir : files) {
fInDir.delete();
}
}
public void deleteFile(String fileName) {
File f = new File(context.getApplicationInfo().dataDir + "/new_directory_name/" + fileName);
if (f.exists()) {
f.delete();
}
}
}

    Vous pouvez créer, lire et supprimer le fichier en appelant ReadWriteJsonFileUtils les méthodes de la classe comme suit:

    Pour la création de fichier:

    try {
new ReadWriteJsonFileUtils(context).createJsonFileData(file_name, data);
} catch (Exception e) {
e.printStackTrace();
}

    Pour la lecture de fichier:

    String jsonString = new ReadWriteJsonFileUtils(context).readJsonFileData(file_name);

    Pour la suppression de fichier unique

    new ReadWriteJsonFileUtils(context).deleteFile(file_name);

    Pour la suppression de tous les fichiers

    new ReadWriteJsonFileUtils(context).deleteFile();