如何在特定密钥处启动Jackson JSON ObjetMapper？

Question

I have a JSON array that I'd like to map that looks like this:

{
    "library": [
        {
          "key":"val"
        },
        {
          "key":"val"
        }
    ]
}

Is there a way to parse this using the object mapper starting at the array rather than at the root? I know you can do a manual node parse, but I would prefer not to do that if possible. any help with this would be greatly appreciated.

Answer 1

Jackson offers three principal ways to parse json: to a map, to an object, to a jackson node tree. None of these methods offer a way to start from anywhere other than the root. To start from somewhere other than the root, you need to parse your way to there from the root, which means you need to start parsing from the root! :)

That being said, if for example you use mapping to an object, it is very easy to get the array you need out of the object:

package test;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Map;

import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;

public class Test {

    static String json = "{\"library\": [{\"key\":\"val\"},{\"key\":\"val\"}]}";

    static class JsonClass {
        private ArrayList<Map<?,?>> library;

        public ArrayList<Map<?, ?>> getLibrary() {
            return library;
        }

        public void setLibrary(ArrayList<Map<?, ?>> library) {
            this.library = library;
        }
    }

    public static void main(String[] args) 
            throws JsonParseException, JsonMappingException, IOException {

        JsonClass parsed = new ObjectMapper().readValue(json, Test.JsonClass.class);
        System.out.println(parsed.getLibrary());

    }

}

Running this prints:

[{key=val}, {key=val}]

An alternative would be to use a streaming parser... it can pick any node, without bothering about understanding the whole structure. I believe Gson has that. But in your case it would probably be an overkill to use a streaming parser: it makes sense when the overall structure is complex, you need to process a big stream fast, and are interested in relatively small part of the data. These do not seem to apply to your scenario.