Jackson handling Wrapped elements

Question

I'm parsing the response from last.fm API. But it seems that they used some wrapper for some of the responses, which is causing a bit of a pain. To put an example:

 {
   "artists":{
      "artist":[
         {
            "name":"Coldplay",
            "playcount":"816763",
            "listeners":"120815",
            "mbid":"cc197bad-dc9c-440d-a5b5-d52ba2e14234",
            "url":"http:\/\/www.last.fm\/music\/Coldplay",
            "streamable":"1"
         },
         {
            "name":"Radiohead",
            "playcount":"846668",
            "listeners":"99135",
            "mbid":"a74b1b7f-71a5-4011-9441-d0b5e4122711",
            "url":"http:\/\/www.last.fm\/music\/Radiohead",
            "streamable":"1"
         }
      ],
      "@attr":{
         "page":"1",
         "perPage":"2",
         "totalPages":"500",
         "total":"1000"
      }
   }
}

Not only the response is wrapped in the artists object, but the array of object has also an object wrapper.

So a wrapper class like:

public class LastFMArtistWrapper {
    public List<Artist> artists;

}

Would not work. I worked around this, creating two wrapper classes, but this looks really ugly. Is there any way we can use something like the @XMLElementWrapper in Jackson?

One advantage of this setup is that it's extensible. If they add more properties to the JSON response, you can easily add them to your objects. However, if you manipulate it, you may have to undo it later on if the JSON changes again. It might be worth keeping things as-is. That's just my suggestion. Good luck finding an answer. +1 for the question. — jamesmortensen, May 26 '12 at 05:08

score 5 · Accepted Answer · answered May 26 '12 at 05:56

The JSON response you are getting back from the provider is a serialized representation of a hierarchy of different objects, but from your description, it sounds like you really only need to use and work with a specific subset of this representation, the collection of artists.

One solution of mirroring this representation involves creating the same hierarchy of Java classes, which creates extra overhead in the form of unneeded classes. From what I understand, this is what you wish to avoid.

The org.json project created a generic JSONObject class, which represents a single, generic key/value pair in a larger JSON representation. A JSONObject can contain other JSONObjects and JSONArrays, mirroring the representation without the extra overhead of maintaining and writing extra classes.

Thus, these two objects can be reused throughout multiple layers of hierarchy in a JSON representation, without requiring you to replicate the structure. Here is an example of how you could proceed:

// jsonText is the string representation of your JSON
JSONObject jsonObjectWrapper = new JSONObject(jsonText);  

// get the "artists" object
JSONObject jsonArtists = jsonObjectWrapper.get("artists");

// get the array and pass it to Jackson's ObjectMapper, using TypeReference
  // to deserialize the JSON ArrayList to a Java ArrayList.
List<Artist> artists = objectMapper.readValue(
        jsonObjectWrapper.getString("artist"),
            new TypeReference<ArrayList<Artist>>() { });

Using the above method, you cut out the extra overhead of having to write extra layers of POJO objects that do nothing but add unnecessary clutter.

TestCollectionDeserialization contains some examples of the readValue method when working with collections and may be helpful.

is there no function of the jackson library to take care of this? a Wrapper Ignor function would be nice — jiduvah, Oct 12 '12 at 18:37
@jiduvah - It would be nice! I've looked, and I've always concluded that, unless you need that level of granularity, it's easier just to use the JSONObject and JSONArray objects. If someone did create a wrapper that maybe just used metadata to serialize and deserialize instead of requiring real objects, that would be awesome! — jamesmortensen, Oct 13 '12 at 05:01

Jackson handling Wrapped elements

1 Answers1