Map Serialization and Deserialization with Jackson

1. Overview

In this article, we'll look at serialization and deserialization of Java maps using Jackson.

We'll illustrate how to serialize and deserialize Map<String, String>, Map<Object, String>, and Map<Object, Object> _to and from JSON-formatted _Strings.

2. Maven Configuration

<dependency>    <groupId>com.fasterxml.jackson.core</groupId>    <artifactId>jackson-databind</artifactId>    <version>2.8.7</version></dependency>

You can get the latest version of Jackson here.

3. Serialization

Serialization converts a Java object into a stream of bytes, which can be persisted or shared as needed. Java Maps are collections which map a key Object to a value Object and are often the least intuitive objects to serialize.

3.1. Map<String, String> Serialization

For the simple case, let's create a Map<String, String> and serialize it to JSON:

Map<String, String> map = new HashMap<>();map.put("key", "value");ObjectMapper mapper = new ObjectMapper();String jsonResult = mapper.writerWithDefaultPrettyPrinter()  .writeValueAsString(map);

ObjectMapper _is Jackson's serialization mapper, which allows us to serialize our _map and write it out as a pretty-printed JSON String, using the toString() method in String:

{  "key" : "value"}

3.2. Map<Object, String> Serialization

You can serialize a map containing a custom Java class with a few extra steps. Let's create a MyPair class to represent a pair of related String objects.

Note: the getters/setters should be public, and we annotate toString() _with @JsonValue to ensure Jackson uses this custom _toString() when serializing:

public class MyPair {    private String first;    private String second;    @Override    @JsonValue    public String toString() {        return first + " and " + second;    }    // standard getter, setters, equals, hashCode, constructors}

Now let's tell Jackson how to serialize MyPair by extending Jackson's JsonSerializer:

public class MyPairSerializer extends JsonSerializer<MyPair> {    private ObjectMapper mapper = new ObjectMapper();    @Override    public void serialize(MyPair value,       JsonGenerator gen,      SerializerProvider serializers)       throws IOException, JsonProcessingException {        StringWriter writer = new StringWriter();        mapper.writeValue(writer, value);        gen.writeFieldName(writer.toString());    }}

JsonSerializer, as the name suggests, serializes MyPair to JSON using MyPair's toString() method. Jackson provides many Serializer classes to fit your serialization requirements.

We apply MyPairSerializer to our Map<MyPair, String> with the @JsonSerialize_annotation. Note that we've only told Jackson how to serialize _MyPair _because it already knows how to serialize _String:

@JsonSerialize(keyUsing = MyPairSerializer.class) Map<MyPair, String> map;

Let's test our map serialization:

map = new HashMap<>();MyPair key = new MyPair("Abbott", "Costello");map.put(key, "Comedy");String jsonResult = mapper.writerWithDefaultPrettyPrinter()  .writeValueAsString(map);

The serialized JSON output is:

{  "Abbott and Costello" : "Comedy"}

3.3. Map<Object, Object> Serialization

The most complex case is serializing a Map<Object, Object>, but most of the work is already done. Let's use Jackson's _MapSerializer _for our map, and _MyPairSerializer_from the previous section for the map's key and value types:

@JsonSerialize(keyUsing = MapSerializer.class)Map<MyPair, MyPair> map;@JsonSerialize(keyUsing = MyPairSerializer.class)MyPair mapKey;@JsonSerialize(keyUsing = MyPairSerializer.class)MyPair mapValue;

Let's test out serializing our Map<MyPair, MyPair>:

mapKey = new MyPair("Abbott", "Costello");mapValue = new MyPair("Comedy", "1940s");map.put(mapKey, mapValue);String jsonResult = mapper.writerWithDefaultPrettyPrinter()  .writeValueAsString(map);

The serialized JSON output, using MyPair's toString() method, is:

{  "Abbott and Costello" : "Comedy and 1940s"}

4. Deserialization

Deserialization converts a stream of bytes into a Java object that we can use in code. In this section, we'll deserialize JSON input into _Maps _of different signatures.

4.1. Map<String, String> Deserialization

For the simple case, let's take a JSON-formatted input string and convert it to a Map<String, String> Java collection:

String jsonInput = "{\"key\": \"value\"}";TypeReference<HashMap<String, String>> typeRef   = new TypeReference<HashMap<String, String>>() {};Map<String, String> map = mapper.readValue(jsonInput, typeRef);

We use Jackson's ObjectMapper as we did for serialization, using readValue() _to process the input. Also, note our use of Jackson's _TypeReference, which we'll use in all of our deserialization examples, to describe the type of our destination Map. Here is the _toString() _representation of our map:

{key=value}

4.2. Map<Object, String> Deserialization

Now, let's change our input JSON and the TypeReference _of our destination to_Map<MyPair, String>:

String jsonInput = "{\"Abbott and Costello\" : \"Comedy\"}";TypeReference<HashMap<MyPair, String>> typeRef   = new TypeReference<HashMap<MyPair, String>>() {};Map<MyPair,String> map = mapper.readValue(jsonInput, typeRef);

We need to create a constructor for MyPair that takes a String with both elements and parses them to the MyPair elements:

public MyPair(String both) {    String[] pairs = both.split("and");    this.first = pairs[0].trim();    this.second = pairs[1].trim();}

And the toString() of our Map<MyPair,String> object is:

{Abbott and Costello=Comedy}

There is another option for the case when we deserialize into a Java class that contains a * Map *— we can use Jackson's * KeyDeserializer * class , one of many Deserialization classes that Jackson offers. We annotate our ClassWithAMap with @JsonCreator, @JsonProperty, and @JsonDeserialize:

public class ClassWithAMap {  @JsonProperty("map")  @JsonDeserialize(keyUsing = MyPairDeserializer.class)  private Map<MyPair, String> map;  @JsonCreator  public ClassWithAMap(Map<MyPair, String> map) {    this.map = map;  }  // public getters/setters omitted}

We are telling Jackson to deserialize the Map<MyPair, String> _contained in _ClassWithAMap, so we need to extend KeyDeserializer _to describe how to deserialize the map's key, a _MyPair _object, from an input _String:

public class MyPairDeserializer extends KeyDeserializer {  @Override  public MyPair deserializeKey(    String key,     DeserializationContext ctxt) throws IOException,     JsonProcessingException {      return new MyPair(key);    }}

We test the deserialization out using readValue:

String jsonInput = "{\"Abbott and Costello\":\"Comedy\"}";ClassWithAMap classWithMap = mapper.readValue(jsonInput,  ClassWithAMap.class);

Again, the toString() method of our ClassWithAMap's map gives us the output we expect:

{Abbott and Costello=Comedy}

4.3. Map<Object,Object> Deserialization

Lastly, let's change our input JSON and the TypeReference of our destination to Map<MyPair, MyPair>:

String jsonInput = "{\"Abbott and Costello\" : \"Comedy and 1940s\"}";TypeReference<HashMap<MyPair, MyPair>> typeRef   = new TypeReference<HashMap<MyPair, MyPair>>() {};Map<MyPair,MyPair> map = mapper.readValue(jsonInput, typeRef);

And the toString() of our Map<MyPair, MyPair> object is:

{Abbott and Costello=Comedy and 1940s}

5. Conclusion

In this quick tutorial, we've seen how to serialize and deserialize Java Maps to and from JSON-formatted Strings.

As always, you can check out the example provided in this article in the Github repository.

原文链接：http://www.baeldung.com/jackson-map