GSON: Comment obtenir un élément insensible à la casse de Json?

Code ci-dessous fonctionne bien lorsque JSON objet contient jsonKey comme il a été passé à la méthode. Je me demande ... si il y a un moyen d'obtenir une valeur attribuée à un casse représentation d'une clé?

Exemple:

public String getOutputEventDescription(JsonElement outputEvent) throws ParserException {
    return retrieveString(outputEvent, DESCRIPTION);
}

Devrait fonctionner indépendamment de savoir si la DESCRIPTION est définie comme "Description", "description" ou "DeScRipTIOn"

protected String retrieveString(JsonElement e, String jsonKey) throws ParserException {

JsonElement value = e.getAsJsonObject().get(jsonKey);

if (value == null) {
    throw new ParserException("Key not found: " + jsonKey);
}

if (value.getAsString().trim().isEmpty()) {
    throw new ParserException("Key is empty: " + jsonKey);
}

return e.getAsJsonObject().get(jsonKey).getAsString();
}

source d'informationauteur JAM

5

Malheureusement, il ne semble pas être un chemin dans le courant de mise en œuvre pour ce faire. Si vous regardez la Gson source et plus précisément à l'JsonObject mise en œuvre, vous verrez que les données sous-jacentes de la structure est liée hachage de la carte. La obtenir de l'appel appelle simplement les obtenir sur la carte, qui à son tour utilise le code de hachage et de la méthode equals de votre clé pour trouver l'objet que vous recherchez.

Le seul moyen est de mettre en place des conventions de nommage pour vous les clés. Le plus simple serait de forcer toutes les touches minuscules. Si vous avez besoin des majuscules et des minuscules touches, puis vous aurez plus de difficulté et le besoin d'écrire un algorithme sophistiqué pour transformer les touches au lieu de simplement appeler jsonKey.toLowerCase().
8

Malheureusement, l'enregistrement d'un FieldNamingStrategy avec le GsonBuilder ne serait pas faire beaucoup de bien, qu'il traduit seulement dans l'autre-que-direction souhaitée: à partir de Java nom de champ pour le JSON nom de l'élément. Il ne peut être raisonnablement utilisé pour vos besoins.

(Dans Le Détail:

Le résultat de la demande de traduction se termine à FieldNamingStrategy.translateName(Field)d'où le nom traduit est utilisé pour obtenir la JSON élément à partir d'un JsonObjectqui a un LinkedHashMap<String, JsonElement>appelé memberscartographie JSON élément noms à leurs valeurs associées. Le nom traduit est utilisée en tant que paramètre à la get(String) méthode de memberset Gson ne fournit aucun mécanisme pour cet appel final à fait insensible à la casse.

La members carte est remplie avec des appels à JsonObject.add(String, JsonElement)fabriqués à partir de Streams.parseRecursive(JsonReader)avec le JSON nom de l'élément extrait de la JsonReader utilisé comme clé de "membres". (JsonReader utilise les caractères exactement comme ils le sont dans le JSON, à l'exception des cas où le caractère d'échappement '\'.) Tout au long de cette pile d'appel, Gson ne fournit aucun mécanisme pour les clés utilisées pour remplir members à être modifié, par exemple, pour être fait tout en minuscules ou majuscules.

Un FieldNamingPolicy fonctionne de la même manière.)

Une solution raisonnable pourrait être de simplement utiliser un deserializer, le long des lignes suivantes.

d'entrée.json:
```
[
 {"field":"one"},
 {"Field":"two"},
 {"FIELD":"three"},
 {"fIElD":"four"}
]
```
Foo.java:
```
import java.io.FileReader;
import java.lang.reflect.Type;
import java.util.Map.Entry;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
public class Foo
{
public static void main(String[] args) throws Exception
{
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(MyClass.class, new MyTypeAdapter());
Gson gson = gsonBuilder.create();
MyClass[] myObjects = gson.fromJson(new FileReader("input.json"), MyClass[].class);
System.out.println(gson.toJson(myObjects));
}
}
class MyClass
{
String field;
}
class MyTypeAdapter implements JsonDeserializer<MyClass>
{
@Override
public MyClass deserialize(JsonElement json, Type myClassType, JsonDeserializationContext context)
throws JsonParseException
{
//json = {"field":"one"}
JsonObject originalJsonObject = json.getAsJsonObject();
JsonObject replacementJsonObject = new JsonObject();
for (Entry<String, JsonElement> elementEntry : originalJsonObject.entrySet())
{
String key = elementEntry.getKey();
JsonElement value = originalJsonObject.get(key);
key = key.toLowerCase();
replacementJsonObject.add(key, value);
}
return new Gson().fromJson(replacementJsonObject, MyClass.class);
}
}
```
Sinon, vous pouvez traiter en premier cru JSON de modifier tous les noms d'élément à être le même cas, tous en bas ou de la tige. Ensuite, passer à la modification du JSON à Gson pour la désérialisation. Ce serait bien de ralentir JSON traitement.

Si vous êtes en mesure de modifier Gson code de votre projet, probablement à l'époque de la pièce à changer pour la plupart résultat efficace est l'appel à name = nextString((char) quote); dans JsonReader. Depuis nextString(char) est également utilisé pour obtenir le JSON valeur de l'élément, je serais probablement juste en faire une copie pour obtenir le nom, et puis faire de petits changements à la force de l'élément noms de tous en bas ou tout en majuscules. Bien sûr, cette approche, puis verrouille votre projet à l'un communiqué de Gson, sinon vous auriez besoin de répéter ce changement à la mise à niveau vers une version plus récente de Gson libération.

Avec Jacksonla situation semble malheureusement similaire. Des traductions avec un PropertyNamingStrategy travailler dans, malheureusement, beaucoup de la même manière: ils traduisent de la Java nom de champ pour le JSON nom de l'élément. Aucun des JsonParser.Feature des altérations de personnaliser un JsonParser à force JSON élément noms en majuscules ou en minuscules.

J'ai été confrontée au même problème. Je l'ai fait pour contourner le problème. (Remplacé toutes les clés avec leurs correspondants version en minuscules et avait toutes les minuscules champs dans la correspondance de classe). Espérons que cette aide.

 input = input.replaceAll("\\s","");
Matcher m = Pattern.compile("\"\\b\\w{1,}\\b\"\\s*:").matcher(input);
StringBuilder sanitizedJSON = new StringBuilder();
int last = 0;
while (m.find()) {
sanitizedJSON.append(input.substring(last, m.start()));
sanitizedJSON.append(m.group(0).toLowerCase());
last = m.end();
}
sanitizedJSON.append(input.substring(last));
input = sanitizedJSON.toString();

Vous devez vous connecter pour publier un commentaire.