Generic object serialization in Jackson with Java

Question

I would like to read in the string {"a": 1.0} as a generic Java Object while keeping the same string format. However, when I try, Jackson automatically changes the internal representation to {a = 1}. In other words, how can I get the following code to print {"a": 1.0} instead of {a = 1}? Note that, I have to read it in as an Object (due to other program constraints).

import org.codehaus.jackson.map.ObjectMapper;

public class Main {

    public static void main(String[] args) {
        try
    {
            ObjectMapper mapper = new ObjectMapper();
            Object myObject = mapper.readValue("{\"a\": 1.0}", Object.class);
            System.out.println(myObject.toString());            
    }
    catch (Exception e)
    {
        e.printStackTrace();
      System.err.println(e.getMessage()); 
    }
    }

}

This doesn't make sense to me. Object doesn't have any properties for the key "a", so how can it be read in like that? Don't you need to create a class with this property? — Jeff Foster, Feb 14 '11 at 16:44
Maybe he is assuming Jackson somehow telepathically figures out expected type... what actually happens is that type Object.class has special handling with Jackson: it will create "natural" mapping to Maps, Lists and wrapper types (which are all Objects obviously) — StaxMan, Feb 14 '11 at 20:06

oconnor0 · Answer 1 · 2011-04-22T22:39:43.427

The created object will be a map (like the other comments) and so its toString produces what you're seeing, {a = 1}. To get your code to print something closer to your input value, you need to use Jackson to write it back out with something like:

System.out.println(mapper.writeValueAsString(myObject));

That gives me what I believe you're looking for:

{"a":1.0}

In other words, Jackson has deserialized your input string into an arbitrary Java object. When you call toString on the object, its own toString is, of course, used. This can write the object however it pleases, including using the method from Object. To reproduce the input string, you have to use Jackson to serialize our object back out.

score 3 · Answer 2 · answered Feb 14 '11 at 16:45

3

You need an existing class that matches the desired json structure. Object is not such class. You can still refer to it as Object, if that's needed:

Object myObject = mapper.readValue("{\"a\": 1.0}", SomeClass.class);

answered Feb 14 '11 at 16:45

Bozho

588,226
146
1,060
1,140

Sean Patrick Floyd · Answer 3 · 2011-02-14T16:53:22.627

If you use a debugger, you will see that the type of the returned Object is LinkedHashMap. So what you see is the output of LinkedHashMap.toString(). There's no way for Jackson to change that, so you can either cast it to a Map and create the String yourself or ask for another return type that generates the JSON String for you:

if(myObject instanceof Map<?, ?>){
    final Map<?, ?> map = (Map<?, ?>) myObject;
    final StringBuilder sb = new StringBuilder("{");
    boolean first = true;
    for(final Entry<?, ?> entry : map.entrySet()){
        if(first){
            first = false;
        } else{
            sb.append(",");
        }
        sb.append("\n\t'")
            .append(entry.getKey())
            .append("':'")
            .append(entry.getValue())
            .append("'");
    }
    if(!first){
        sb.append("\n");
    }
    sb.append("}");
    System.out.println(sb.toString());

} else{
    System.out.println(myObject);
}

Output:

{
    'a':'1.0'
}

Jackson has support for writing out maps so you can do something like: `System.out.println(mapper.writeValueAsString(myObject))` instead of writing your own serializer. — oconnor0, Apr 22 '11 at 22:28

score 2 · Answer 4 · answered Feb 14 '11 at 20:09

When Jackson is told to bind JSON into Object.class, it does just that; but since it has no a priori knowledge of what might be in that JSON (or what classes one might want to use), it has to use most basic Java types: Maps, Lists, Numbers, Booleans and Strings. So any JSON Object is represented by Map; JSON Array by List, and so on.

If you want a custom object, you must specify its type; or, when serializing, enable inclusion of explicit type information ("polymorphic type handling"). This will add either class name, or type name, and can be used to deserialize back to exact type.

To do this, either type itself (or one of its supertypes) must use @JsonTypeInfo annotation; or, if it is an Object property, @JsonTypeInfo for property (field or method).

Generic object serialization in Jackson with Java

4 Answers4