laissez Gson lancer des exceptions sur les mauvais types

Malheureusement, la documentation est un peu trompeur.

Il ne fera que jeter de l'exception, si votre classe avait un champ dont le type ne correspond pas à ce qui est dans le JSON, et même alors, il fait des choses folles pour essayer de le réparer (la conversion d'un int dans le JSON pour un String dans votre classe par exemple). Si vous aviez quelque chose comme un Date champ dans votre POJO et il a rencontré une int dans le JSON, il faudrait le jeter. Les champs qui sont présents dans le JSON, mais pas dans votre POJO sont ignorées silencieusement, les champs sont manquants dans le JSON, mais qui existent dans votre POJO sont mis à null.

À l'heure actuelle, GSON ne pas fournir un mécanisme pour toute sorte de "stricte" de la désérialisation où vous auriez quelque chose comme un @Required annotation pour les champs dans votre POJO.

Dans votre cas ... je serais tout simplement élargir mon POJO pour inclure une erreur interne de l'objet ... quelque chose comme:

class Dummy {
   private String foo;
   private int bar;
   private Error error;

   private class Error {
        String publicMsg;
        String msg;
   }

   public boolean isError() {
       return error != null;
   }

   //setters and getters for your data, the error msg, etc.
}

Votre autre option est d'écrire une coutume deserializer qui lève l'exception si le JSON est l'erreur comme:

class MyDeserializer implements JsonDeserializer<Dummy>
{
    @Override
    public Dummy deserialize(JsonElement json, Type typeOfT, 
                              JsonDeserializationContext context)
                    throws JsonParseException
    {
        JsonObject jsonObject = (JsonObject) json;

        if (jsonObject.get("error") != null)
        {
            throw new JsonParseException("Error!");
        }

        return new Gson().fromJson(json, Dummy.class);
    }
} 

Modifier pour Ajouter: Quelqu'un upvoted récemment et re-lisant je me suis dit "Hein, vous savez, vous pourriez le faire vous-même et il pourrait être à portée de main".

Voici une ré-utilisable deserializer et d'annotation qui va faire exactement ce que l'OP voulait. La limitation est que si le POJO nécessaire personnalisé deserializer, vous auriez à aller un peu plus loin et passer dans un Gson objet dans le constructeur pour désérialiser à l'objet lui-même ou déplacer l'annotation de vérifier dans une méthode distincte et à utiliser dans votre deserializer. Vous pouvez également améliorer la gestion des exceptions en créant votre propre exception et de le passer à la JsonParseException de sorte qu'il peut être détecté par l' getCause() en l'appelant.

Que tout est dit, dans la grande majorité des cas, cela fonctionne:

public class App
{
public static void main(String[] args)
{
Gson gson =
new GsonBuilder()
.registerTypeAdapter(TestAnnotationBean.class, new AnnotatedDeserializer<TestAnnotationBean>())
.create();
String json = "{\"foo\":\"This is foo\",\"bar\":\"this is bar\"}";
TestAnnotationBean tab = gson.fromJson(json, TestAnnotationBean.class);
System.out.println(tab.foo);
System.out.println(tab.bar);
json = "{\"foo\":\"This is foo\"}";
tab = gson.fromJson(json, TestAnnotationBean.class);
System.out.println(tab.foo);
System.out.println(tab.bar);
json = "{\"bar\":\"This is bar\"}";
tab = gson.fromJson(json, TestAnnotationBean.class);
System.out.println(tab.foo);
System.out.println(tab.bar);
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface JsonRequired
{
}
class TestAnnotationBean
{
@JsonRequired public String foo;
public String bar;
}
class AnnotatedDeserializer<T> implements JsonDeserializer<T>
{
public T deserialize(JsonElement je, Type type, JsonDeserializationContext jdc) throws JsonParseException
{
T pojo = new Gson().fromJson(je, type);
Field[] fields = pojo.getClass().getDeclaredFields();
for (Field f : fields)
{
if (f.getAnnotation(JsonRequired.class) != null)
{
try
{
f.setAccessible(true);
if (f.get(pojo) == null)
{
throw new JsonParseException("Missing field in JSON: " + f.getName());
}
}
catch (IllegalArgumentException ex)
{
Logger.getLogger(AnnotatedDeserializer.class.getName()).log(Level.SEVERE, null, ex);
}
catch (IllegalAccessException ex)
{
Logger.getLogger(AnnotatedDeserializer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
return pojo;
}
}

De sortie:

C'est foo 
c'est la barre de 
C'est toto 
null 
Exception in thread "main" com.google.gson.JsonParseException: champ Manquant en JSON: foo 

OriginalL'auteur

Je ne suis pas fan de la solution retenue. Cela fonctionne, mais ce n'est pas la façon d'utiliser Gson. Gson cartes un particulier JSON schema pour un objet et vice-versa. Idéalement, le JSON que vous utilisez est bien formé (donc si vous avez le contrôle sur le format JSON, envisager de le changer), mais si pas, vous devez concevoir l'analyse de l'objet à manipuler tous les cas, vous vous attendez à recevoir.

Parfois, vous avez besoin d'écrire une coutume JsonDeserializer, mais ce n'est pas un de ces moments. Envoyer un message ou d'erreur est très courante, et avec la bonne structure de données GSON peut traiter un cas simple d'utilisation directement.

Si vous avez le contrôle sur le JSON schema

Envisager quelque chose comme ceci à la place:

{
"message": {
"foo": "Hello World",
"bar": 3
},
"error": null;
}
{
"message": null,
"error": {
"publicMsg": "Something bad happened",
"msg": "you forgot requesting some parameter"
}
}

Avis, vous pouvez définir un propre classe wrapper qui fournit Dummy objets quand c'est possible:

public class JsonResponse {
private Dummy message;
private RequestError error;
public boolean hasError() { return error != null; }
public Dummy getDummy() {
Preconditions.checkState(!hasError());
return message;
}
public RequestError getError() {
Preconditions.checkState(hasError());
return error;
}
}

Si vous avez à faire avec le JSON schema

Si vous ne pouvez pas restructurer le schéma, vous devez restructurer l'analyse de classe, il devrait ressembler à quelque chose comme ceci:

public class JsonResponse {
private String foo;
private int bar;
private RequestError error;
public boolean hasError() { return error != null; }
public Dummy getDummy() {
Preconditions.checkState(!hasError());
return new Dummy(foo, bar);
}
public RequestError getError() {
Preconditions.checkState(hasError());
return error;
}
}

C'est moins souhaitable que de fixer le schéma, mais vous obtenez le même général de l'API soit - appel hasError() pour voir si la requête a réussi, puis d'appeler getDummy() ou getError() en tant que de besoin. Les appels vers l'autre méthode (par exemple, getDummy() lorsque vous avez reçu une erreur) fail-fast.

OriginalL'auteur