Gson deserialize JSON mit unterschiedlichen Werttypen

Question

Ich versuche, eine JSONArray mit Gson zu deserialisieren, man kann den Typ der Werte variieren, der Wert "in_wanted" kann entweder boolean oder JSONObject sein.

in_wanted als boolean:

{ 
"movies": [ 
     { 
      "title": "example boolean", 
      "in_wanted": false 
     } 
    ]   
} 

in_wanted als JSONObject:

{ 
"movies": [ 
     { 
      "title": "example object", 
      "in_wanted": { 
       "profile": { 
        "value": false 
       } 
      } 
     } 
    ]   
} 

Ich brauche das Objekt, wenn es verfügbar ist, und ich brauche einen Deserializer null zurück, wenn der Wert von "in_wanted" ist ein boolesch. Was wäre der beste Weg, dies mit Gson zu tun?

Answer 1

Sie können dies tun mit benutzerdefiniertem Deserializer. Zu Beginn sollten wir ein Datenmodell erstellen, das Ihren JSON darstellen kann. Jetzt

class JsonEntity { 

    private List<Movie> movies; 

    public List<Movie> getMovies() { 
     return movies; 
    } 

    public void setMovies(List<Movie> movies) { 
     this.movies = movies; 
    } 

    @Override 
    public String toString() { 
     return "JsonEntity [movies=" + movies + "]"; 
    } 
} 

class Movie { 

    private String title; 
    private Profile in_wanted; 

    public String getTitle() { 
     return title; 
    } 

    public void setTitle(String title) { 
     this.title = title; 
    } 

    public Profile getIn_wanted() { 
     return in_wanted; 
    } 

    public void setIn_wanted(Profile in_wanted) { 
     this.in_wanted = in_wanted; 
    } 

    @Override 
    public String toString() { 
     return "Movie [title=" + title + ", in_wanted=" + in_wanted + "]"; 
    } 
} 

class Profile { 

    private boolean value; 

    public boolean isValue() { 
     return value; 
    } 

    public void setValue(boolean value) { 
     this.value = value; 
    } 

    @Override 
    public String toString() { 
     return String.valueOf(value); 
    } 
} 

, wenn wir alle benötigten Klassen sollten wir neuen benutzerdefinierten Deserializer implementieren:

class ProfileJsonDeserializer implements JsonDeserializer<Profile> { 
    @Override 
    public Profile deserialize(JsonElement jsonElement, Type type, 
      JsonDeserializationContext context) throws JsonParseException { 
     if (jsonElement.isJsonPrimitive()) { 
      return null; 
     } 

     return context.deserialize(jsonElement, JsonProfile.class); 
    } 
} 

class JsonProfile extends Profile { 

} 

Bitte haben Sie einen Blick auf JsonProfile Klasse. Wir müssen es erstellen, um "Deserialisierungsschleife" (tricky part) zu vermeiden.

Und jetzt können wir unsere Lösung mit Testmethode testen:

GsonBuilder builder = new GsonBuilder(); 
builder.registerTypeAdapter(Profile.class, new ProfileJsonDeserializer()); 
Gson gson = builder.create(); 

JsonEntity jsonEntity = gson.fromJson(new FileReader("/tmp/json.txt"), 
     JsonEntity.class); 
System.out.println(jsonEntity); 

Answer 2

Sie könnten eine manuelle Parsen tun, so etwas wie:

JsonParser parser = new JsonParser(); 
JsonObject rootObject = parser.parse(yourJsonString).getAsJsonObject(); 
JsonObject movieObject = rootObject 
          .getAsJsonArray("movies") 
          .get(0).getAsJsonObject(); 
JsonElement inWantedElement = movieObject.get("in_wanted"); 

//Check if "in_wanted" element is a boolean or an object 
if (inWantedElement.isJsonObject()) { 
    //Process the element as an object... 
    //for example get the element "value"... 
    boolean value = inWantedElement 
         .getAsJsonObject() 
         .getAsJsonObject("profile") 
         .getAsJsonPrimitive("value") 
         .getAsBoolean(); 
} 
else if (inWantedElement.isJsonPrimitive()) { 
    //Process the element as a boolean... 
    boolean inWanted = inWantedElement.getAsBoolean(); 
} 

Hinweis: siehe Gson API documentation für weitere Informationen über Typen JsonObject, JsonArray, JsonElement, und so weiter ...