How do I serialize a java.util.Map with the Jackson JSON processor if the key is a custom class?

Question

Kjetil Valstadsve · Answer

Sorry, you can't do this. Look at the JSON spec:

http://www.json.org/

It's very simple. The first words of the first bullet point say it clearly: "A collection of name/value pairs".

Keep in mind that JSON is basically lifted from Javascript syntax for object and array literals. Your map in Java is mapped to/from a Javascript object, when and if it is evaluated in a browser context. A Javascript object has fields, and the fields have names. Names can't be objects, they are strings.

Jackson is doing what it can here, resorting to toString().

You can, of course, create an object where the fields have names that are JSON strings. And, of course, this would be insane.

On second thought, you probably can't even do that, since field names obviously can't hold arbitrary characters. So this would require some string encoding of JSON that obeys Javascript syntax for field names! Is there a quora board for mad computer science?

Toby Thain · Answer

As Kjetil Valstadsve's answer [ https://www.quora.com/How-do-I-serialize-a-java-util-Map-with-the-Jackson-JSON-processor-if-the-key-is-a-custom-class/answer/Kjetil-Valstadsve ] says, in JSON, keys must be strings. However, you can still represent your map in JSON, just not as a JSON object:

[code=javascript]
[
  [ {"LongAttr":123, "IntegerAtt":456}, "stringValue" ],
  [ {"LongAttr":129, "IntegerAtt":442}, "somethingelse" ],
  ...
]
[/code]

You can even probably persuade Jackson to do this.

Paulina Jonušaitė · Answer

[code ]HashMap[/code] has no way of identifying the key class as “custom” or not.

Any broken behaviour you notice in a [code ]HashMap[/code] usually points to:

* fucked up [code ]hashCode[/code] method, or even worse, the fact that you didn’t even bother to override it
 * fucked up [code ]equals[/code] method, or even worse, the fact that you didn’t even bother to override it
 * mutual fuck up, where you somehow ended up in a situation where [code ]foo.equals(bar)[/code], yet [code ]foo.hashCode() != bar.hashCode()[/code]
Specifically, if you use the default implementation of [code ]hashCode[/code] and [code ]equals[/code], they assume that two things are only equal if they are the same exact thing, and therefore you will never be able to retrieve contents from your hash map when you lose the reference to your original key.

[code]class Foo {
    private String id;
    public Foo(String id) {
        this.id = id;
    }
}

// ...

Map%3CFoo, Integer%3E fooMap = new HashMap%3C%3E();
fooMap.put(new Foo("foo"), 420);

// prints "null"
// even if the contents are the same, these objects are different
System.out.println(fooMap.get(new Foo("foo"))); 
[/code]

ChatGPT · Answer

To serialize a [code]java.util.Map[/code] with a custom class as the key using the Jackson JSON processor, you'll need to follow a few steps. Jackson requires that the key class implements the [code]hashCode()[/code] and [code]equals()[/code] methods properly, so it can manage the keys in the map. Additionally, you may need to register a custom serializer for your key class if it requires special handling.
Here’s a step-by-step guide:
1. Implement [code]hashCode()[/code] and [code]equals()[/code]
Ensure that your custom key class overrides the [code]hashCode()[/code] and [code]equals()[/code] methods. This is crucial for the correct functioning of the map.
[code]public class CustomKey {
    private String id;

public CustomKey(String id) {
        this.id = id;
    }

// Getters, setters, etc.

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CustomKey)) return false;
        CustomKey that = (CustomKey) o;
        return id.equals(that.id);
    }

@Override
    public int hashCode() {
        return id.hashCode();
    }
}[/code]
2. Create the Map
Create your map with the custom key and a value type (e.g., [code]String[/code]):
[code]Map%3CCustomKey, String%3E map = new HashMap%3C%3E();
map.put(new CustomKey("key1"), "value1");
map.put(new CustomKey("key2"), "value2");[/code]
3. Serialize the Map
Use Jackson to serialize the map. You may need to configure an [code]ObjectMapper[/code].
[code]import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

Map%3CCustomKey, String%3E map = new HashMap%3C%3E();
            map.put(new CustomKey("key1"), "value1");
            map.put(new CustomKey("key2"), "value2");

// Serialize the map
            String jsonString = objectMapper.writeValueAsString(map);
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}[/code]
4. Custom Serializer (if needed)
If your custom key class needs special handling during serialization, you can create a custom serializer.
[code]import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.JsonSerializer;

@JsonSerialize(using = CustomKeySerializer.class)
public class CustomKey {
    // ... existing code ...
}

class CustomKeySerializer extends JsonSerializer%3CCustomKey%3E {
    @Override
    public void serialize(CustomKey value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(value.getId()); // or however you want to serialize it
    }
}[/code]
Conclusion
By following these steps, you can serialize a [code]java.util.Map[/code] with a custom class as the key using Jackson. Ensure that your custom key class is properly defined, and if necessary, implement a custom serializer to control how the keys are represented in JSON.

Tirthankar Kundu · Answer

Here’s a quick implementation for a small JSON.

The input JSON is:

[code]{
	"name": "John Doe",
	"occupation": "Software Engineer",
	"age": 25
}
[/code]We will first create a bean class for this as below:

[code]import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class Person {
    @SerializedName("name")
    @Expose    private String name;
    @SerializedName("occupation")
    @Expose    private String occupation;
    @SerializedName("age")
    @Expose    private Integer age;

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public String getOccupation() {
        return occupation;
    }

public void setOccupation(String occupation) {
        this.occupation = occupation;
    }

public Integer getAge() {
        return age;
    }

public void setAge(Integer age) {
        this.age = age;
    }

@Override    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", occupation='" + occupation + '\'' +
                ", age=" + age +
                '}';
    }
}
[/code]It is good to override toString to display the content easily.

Next we implement this bean using Gson as below:

[code]String jsonString = "{'name':'John Doe','occupation': 'Software Engineer', 'age':23}";
Gson gson = new Gson();
Person person = gson.fromJson(jsonString, Person.class);
System.out.println(person.toString());
[/code]Things will be bit tricky when we input JSON array instead of JSON Object.

We use TypeToken in this case as below:

[code]String jsonString = "[{'name':'John Doe','occupation': 'Software Engineer', 'age':23}," +
        "{'name':'Mark Doe','occupation': 'Senior Manager', 'age':40}]";
Type type = new TypeToken%3CList%3CPerson%3E%3E() { }.getType();
List%3CPerson%3E persons = gson.fromJson(jsonString, type);
System.out.println(persons.toString());
[/code]Check the output of the above codes:

Hope you liked it. Cheers.

Mark Hetherington · Answer

Practically speaking: pick a library implementation for (de)serializing JSON, e.g. GSON, then read its documentation. Don’t write code for it yourself unless truly necessary.

But let’s suppose that you’re not allowed a library; if we have to roll our own, we’ll try to make use of Java’s base interfaces for ease of development.

I’d start by considering the data structure. JSON is analogous to [code ]Map[/code], where the keys are strings and the values can be various types, including other JSON objects. This implies recursion. So I’d start by creating a class:

[code]public class JSONObject%3CT%3E implements Map%3CString, T%3E
[/code]Now we have a problem: we need to have a type for [code ]T[/code] that can either be another [code ]JSONObject [/code]or a data object at the “bottom” of such a structure. So let’s define a type that acts like a [code ]JSONObject[/code] but contains exactly one item:

[code]public class JSONData%3CT%3E extends JSONObject%3CT%3E implements Map.Entry%3CString, T%3E
[/code]Note that we extend both [code ]Map[/code] and [code ]Map.Entry[/code]; that’s a bit odd, but it should work fine for a map with strictly one entry. We’ll probably have to throw [code ]UnsupportedOperationException[/code]s for some [code ]Map[/code] methods, but that’s fair where those methods are documented as optional.

With [code ]JSONData%3CT%3E[/code] set up, each of our items will either be a [code ]JSONObject%3CJSONObject%3E[/code], or a [code ]JSONData%3CT%3E[/code], where [code ]T[/code] is one of the basic types available to JSON, with primitives boxed: [code ]String[/code], [code ]Float[/code] (JavaScript has only floating-point numbers), [code ]Boolean[/code], or [code ]Object[/code] (that last one just to support [code ]null[/code]).

“But wait,” you say, “what about arrays?” Uh, oh, we’re missing an option. And since JavaScript’s array elements can be of mixed types, we have to account for the possibility. We’re going to end up with another class:

[code]public class JSONArray extends JSONObject%3CJSONObject%3E implements List%3CJSONObject%3E
[/code]It’s a fudge again, because [code ]JSONData[/code] objects in a [code ]JSONArray[/code] have to have [code ]String[/code] keys when they probably ought to strictly have [code ]Integer[/code] ones, but we can just use the [code ]toString()[/code] method from [code ]Integer[/code] to make those.

Now that we support all the structural elements, we can write a static deserializer in [code ]JSONObject[/code] that splits by commas, ignoring ones inside brackets or braces, into a list of items, and recursively deserializes that list, using a factory method that produces [code ]JSONObject[/code], [code ]JSONData[/code], or [code ]JSONArray[/code] sub-elements as appropriate (brackets means an array, braces mean an object, neither means data); here’s the signature:

[code]public static JSONObject%3CJSONObject%3E deserialize(String serialized)
[/code]Clever people might notice that I’ve got a key bit missing here: I probably want to create one or more [code ]Exception[/code] classes along the lines of [code ]MalformedJSONException[/code] or similar, and cause [code ]deserialize(String)[/code] to throw it if the input [code ]String[/code] is invalid.

That done, we can traverse the whole structure as a nested group of [code ]Map%3CString, Map%3E[/code] objects, and use [code ]instanceof JSONArray[/code] or [code ]instanceof JSONData[/code] on specific objects to help handle those. Naturally, the rest of your code would have to specify what sort of logic to use when traversing the data, but this is enough to make it traversable without assuming a particular schema for the JSON.

TL;DR: to do it manually, do a lot of needless work and debugging. Use a library.

Anonymous · Answer

Just my thought:

Create your POJO with an overloaded constructor that can:

1. Accept the JSON String and populate the fields.
2. Accept JSONObject and populate the fields.
Create two accessors:

1. One that can build a JSONObject from the fields.
2. One that calls the above and overrides toString() to return a JSON String.
3. 
1. I'd call #1 to get the Object and simply use toString(true) for formatted JSON strings

Everything else would be private. This insures everything is encapsulated.

Me, from a readability standpoint would create an interface, an abstract class that suites my general purpose needs and then any concrete classes I may need.

Gabor Jakab · Answer

Interesting question. [code ]toString()[/code] is a method in [code ]java.lang.Object[/code]. It is possible to invoke [code ]toString()[/code] on any [code ]JSONObject[/code] like it is possible to invoke [code ]toString()[/code] on any other Java Object. For example:

jakarta.json.JsonObject (ex javax.json.JsonObject):

[code]JsonObject jsonObject = Json.createObjectBuilder()
						.add("userName", "myUserName")
						.add("email", "myEmailAddress@myDomain.com")
						.add("address", Json.createObjectBuilder()
											.add("city", "MyCity")
											.add("zip", "33010"))
								.build();
System.out.println("JsonObject: "+jsonObject.toString());
[/code]org.json.JSONObject

[code]Map%3CString, Object%3E map = new HashMap%3CString, Object%3E();
map.put("UUID", generateUUID());
JSONObject jsonObject = new JSONObject(map);
System.out.println(jsonObject.toString());
[/code]

Scott Brickner · Answer

Deserializing arbitrary JSON in Java doesn’t have any choice but to represent it so that JSON objects are deserialized as Map%3CObject%3E.

If you’re trying to deserialize to an actual type, like a User, then there are only two possibilities when you encounter an unknown field—either you’re deserializing an unknown subclass of User (in which case, you should throw the unknown property away) or you’re mistaken in thinking you were deserializing a User in the first place, in which case you should raise an exception.

Which of those two cases applies depends on the context. It’s a design decision somebody has to make.

Hanumantha Reddy · Answer

convert a JSON object to a custom C# object is called as “Deserialization”.

Deserialization is the reading back in from the same types of storage you saved on a hard-disk, or by internet protocols, or other protocols , refresh the state of existing objects by setting their properties, field, etc.

Or you may deserialize to completely re-create classes, user interfaces, and code, instances of classes, values for properties, fields, etc.

Here we use DeserializeObject generic method with JsonConvert class to do deserialization.

We use “NewtonSoft.Json library” to convert from JSON to C# object.

Follow below videos to understand more on how to deserialize JSON to C# object.

https://www.youtube.com/watch?v=N9ZN5yhJSAI
https://www.youtube.com/watch?v=RKw5UM0Hi0g&t=33s

Ashutosh Jha · Answer

If you using spring then @Requestbody take the responsibility to map json to pojo.

If you want manually you have 2ways

1. Gson
2. ObjectMapper
But in all cases you need to take care, json key shoud be same as pojo variable name.

Mariusz Kasolik · Answer

Yes, Java object can be serialized to JSON object and back. You can use Jackson library to accomplish this: FasterXML/jackson [ https://github.com/FasterXML/jackson ].

K Karthik · Answer

Convert an object into json/bytes called serialization and vice versa is deserialization ,which helps you to store, transfer object over the network.

Nicolae Marasoiu · Answer

It is Serializable so all that is needed is to use the Object Output Stream in order to serialize it, more details in Serialization and Deserialization in Java with Example [ https://www.geeksforgeeks.org/serialization-in-java/amp/ ]

Alternatively, calling the writeObject method also does it.

Java serializing is not efficient. This is why in production where some performance cost ratio is required, various replacements can be used, that either are a drop in replacement or have a different API.

Gupteshwar Chand · Answer

JSON is yet another but most widely used format for transmitting data over the network.You can serialize your Java/C# class to JSON and deserialize JSON back to your class.Json appears in form of key/value pairs and it is very simple to understand for any client consuming it thanks to plethora of open source libraries. With restful services becoming a buzz, Json is becoming a standard.

David Roldán Martínez · Answer

JSON is a format that encodes objects in a string. Serialization means to convert an object into that string, and deserialization is its inverse operation (convert string -%3E object).

Biranchi Narayan Padhi · Answer

Hello Buddy,

You can use Built in Function Provided by Python and convert it to dictionary directly.Now, you can use this if you do not know the Format of the Incoming JSON.

[code]import json

# Opening JSON file 
with open('data.json') as json_file: 
 data = json.load(json_file)

#printing the data as Dicti
print(data)

#printing the type of Data Variable:
print(type(data)) #it will print the class Dict as the json is already converted to dictionary, you can verify using this Method
[/code]Now, if you know the Format of the incoming JSON Object , you can loop through it and easily make a Dictionary of your own without any Built in Methods.

For Example if your JSON looks something like this:

JSON={

“AGE”:23,

“Inocme”:100000,

“Height”:6

}

You can make your dictionary writing Python Logic:

[code]print(type(JSON)) #this will print the type as JSON Object
Dicti={}
for key in JSON:
	Dicti[key]=JSON[Key]

print(type(Dicti)) #this will print the type of Object as Dictionary.
[/code]Hope that helped you in some way to understand .Give it a Thumbs Up!!!

Adios!!

Alan Mellor · Answer

Use something like Google GSON or the Jackson library to turn a Java object into a JSON String. And back again.

Martin Gainty · Answer

When you serialise a JSON formatted data stream to storage

[code][JsonConverter(typeof(DictionaryWrapperConverter))]
class MyWrapper : IEnumerable
{
    Dictionary%3Cstring, string%3E values = new Dictionary%3Cstring, string%3E();

public void Add(string key, string value)
    {
        values.Add(key, value);
    }

IEnumerator IEnumerable.GetEnumerator()
    {
        return values.GetEnumerator();
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyWrapper wrapper = new MyWrapper();
        wrapper.Add("foo", "bar");
        wrapper.Add("fizz", "bang");

// serialize single wrapper instance
        string json = JsonConvert.SerializeObject(wrapper, Formatting.Indented);
}
}
[/code]

Paul Lautman · Answer

Let me ask you a similar question. How do you map the french language to a car? Of course you don't since one is a language and the other is a physical object. Likewise SQL is a language and JSON is an object. They are not compatible. Not sure where the Java comes into it either.