Serialisieren einer SparseArray<T> mit GSON

Ich serialisieren möchten Sie eine benutzerdefinierte Java-Objekt, so kann ich mit SharedPreferences zu speichern, und retreive es in einer anderen Aktivität. Ich brauche keine persistente Speicherung, die SharedPreferences wische ich Sie, wenn meine Anwendung geschlossen wird. Ich bin derzeit mit GSON für diese, aber es scheint nicht zu funktionieren gut mit Android SparseArray geben.

Meine Objekte:

public class PartProfile {

private int gameId;
//Some more primitives
private SparseArray<Part> installedParts = new SparseArray<Part>();

//...
}

public class Part {
   private String partName;
   //More primitives
}

Serialisierung:

Type genericType = new TypeToken<PartProfile>() {}.getType();
String serializedProfile = Helpers.serializeWithJSON(installedParts, genericType);
preferences.edit().putString("Parts", serializedProfile).commit();

serializeWithJSON():

public static String serializeWithJSON(Object o, Type genericType) {
    Gson gson = new Gson();
    return gson.toJson(o, genericType);
}

Deserialisierung:

Type genericType = new TypeToken<PartProfile>() {}.getType();
PartProfile parts = gson.fromJson(preferences.getString("Parts", "PARTS_ERROR"), genericType);

SparseArray<Part> retreivedParts = parts.getInstalledParts();
int key;
for (int i = 0; i < retreivedParts.size(); i++) {
    key = retreivedParts.keyAt(i);
    //Exception here:
    Part part = retreivedParts.get(key);
    //...
}

Ausnahme:

java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.mypackage.objects.Part

Ich verstehe nicht, warum Gson casten will ein LinkedTreeMap zu meinem Objekt, ich benutze nie einen in meinem gesamten Programm. Früher habe ich ein HashMap<Integer,Part> bevor ich wechselte zu den SparseArray<Part>, und hatte nie Probleme damit. Sind SparseArrays nicht unterstützt Gson, oder ist es ein Fehler auf meiner Seite?

Edit: Es scheint, dass die SparseArray wird deserialisiert richtig, aber nicht die Gegenstände im inneren. Statt LinkedTreeMaps diese sollte vom Typ Part.Serialisieren einer SparseArray<T> mit GSON

InformationsquelleAutor Lennart | 2013-06-21
  1. 5

    Scheint es, dass die SparseArray wird deserialisiert richtig, aber nicht die
    Objekte im inneren. Statt LinkedTreeMaps, diese sollte vom Typ
    Teil.

    Ihre Beobachtung ist korrekt, da SparseArray enthält Objekt (nicht Part), Gson keine Ahnung, um Teil als Ihren Objekttyp. Daher ordnen Sie Ihre Liste als seinen berüchtigten internen Typ LinkedTreeMap.

    Um es zu lösen, ich denke, Sie werden nicht in der Lage zu verwenden SparseArray... Oder Sie versuchen retreivedParts.get(key).toString(), dann benutze gson zu analysieren, das Objekt erneut. Aber ich glaube nicht, dass es effizient zu tun, dass

    • Ich werde akzeptieren deine Antwort, da scheint es keine richtige Lösung dafür. Ich ersetzte meine SparseArrays mit HashMaps, aber ich musste Gson gson = new GsonBuilder().enableComplexMapKeySerialization().create() zu serialisieren, da irgendwie meine custom-Objekte nicht ordnungsgemäß deserialisiert werden, ohne dass die option aktiviert ist.
    InformationsquelleAutor Hoàng Long
  2. 13

    Wirklich, es ist ein Weg zu serialisieren jede Art von SparseArray hier ein Beispiel-code:

    public class SparseArrayTypeAdapter<T> extends TypeAdapter<SparseArray<T>> {

    private final Gson gson = new Gson();
    private final Class<T> classOfT;
    private final Type typeOfSparseArrayOfT = new TypeToken<SparseArray<T>>() {}.getType();
    private final Type typeOfSparseArrayOfObject = new TypeToken<SparseArray<Object>>() {}.getType();

    public SparseArrayTypeAdapter(Class<T> classOfT) {
        this.classOfT = classOfT;
    }

    @Override
    public void write(JsonWriter jsonWriter, SparseArray<T> tSparseArray) throws IOException {
        if (tSparseArray == null) {
            jsonWriter.nullValue();
            return;
        }
        gson.toJson(gson.toJsonTree(tSparseArray, typeOfSparseArrayOfT), jsonWriter);
    }

    @Override
    public SparseArray<T> read(JsonReader jsonReader) throws IOException {
        if (jsonReader.peek() == JsonToken.NULL) {
            jsonReader.nextNull();
            return null;
        }
        SparseArray<Object> temp = gson.fromJson(jsonReader, typeOfSparseArrayOfObject);
        SparseArray<T> result = new SparseArray<T>(temp.size());
        int key;
        JsonElement tElement;
        for (int i = 0; i < temp.size(); i++) {
            key = temp.keyAt(i);
            tElement = gson.toJsonTree(temp.get(key));
            result.put(key, gson.fromJson(tElement, classOfT));
        }
        return result;
    }

}

    und zu verwenden, müssen Sie es registrieren es in Ihrem Gson Objekt, so wie hier:

    Type sparseArrayType = new TypeToken<SparseArray<MyCustomClass>>() {}.getType();
Gson gson = new GsonBuilder()
    .registerTypeAdapter(sparseArrayType, new SparseArrayTypeAdapter<MyCustomClass>(MyCustomClass.class))
    .create();

    finden Sie dieses Beispiel in diese gist.

    P. S.: ich weiß, es ist nicht optimiert, aber es ist nur ein Beispiel, um eine Vorstellung zu geben, wie Sie zu erreichen, was Sie brauchen.

    • Dieser code funktioniert. Allerdings habe ich immer noch verwenden Sie es nicht als Lösung, da SparseArray ist nicht Parcable/Serializable. Daher ist es ziemlich schwierig für mich, um es zu übergeben um auf die verschiedenen Aktivitäten und Prozesse. Am Ende Falle ich wieder HashMap.
    • ich lasse eine zukünftige Referenz gist.github.com/dmarcato/6455221
    InformationsquelleAutor dmarcato
Schreibe einen Kommentar