We Keep Coding

How to avoid duplicating JSON field when serializing two fields in one custom Jackson JsonSerializer?

Main Goal:
I would like to serialize 2 POJO fields from within 1 field's CustomSerializer while avoiding the default serialization of the second field and keeping the POJO as clean as possible.
POJO:
public class Entity{
// The existence of #JsonProperty on either fields does not change the behavior.
#JsonSerialize(using=MySerializer.class)
#HashTo("hashedKuku")
private String kuku;
private String hashedKuku;
// Public Getters & Setters for both fields
}
MySerializer:
public class MySerializer extends JsonSerializer<String> {
// Some code including try-catch clauses omitted for simplicity.
#Override
public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeString(value);
final String currentFieldName = gen.getOutputContext().getCurrentName();
final Field declaredField = gen.getCurrentValue().getClass().getDeclaredField(currentFieldName);
final HashTo annotation = declaredField.getAnnotation(HashTo.class);
final String hashFieldName;
if(annotation!=null && !(hashFieldName=annotation.value()).isEmpty()) {
// gen.writeStringField(hashFieldName, new Hasher().getHashedValue(value));
// OR
serializers.defaultSerializeField(hashFieldName, new Hasher().getHashedValue(value), gen);
}
}
Expected Result:
{
"kuku": "someValue",
"hashedKuku": "someHash"
}
Actual Result:
{
"kuku": "someValue",
"hashedKuku": "someHash",
"hashedKuku": null
}
The Problem:
MySerializer does the job, and the defualt serializer serializes hashedKuku as well.
Constraints:
MySeializer should be on the field itself and not a class-level serializer.
Keep the POJO as clean as possible (have only 2 annotations on kuku field).
What I've Tried: (Solutions that work but are not good enough)
Using JsonProperty.Access.WRITE_ONLY:
#JsonProperty(JsonProperty.Access.WRITE_ONLY)
private String hashedKuku;
Using #JsonIgnore on the field:
#JsonIgnore
private String hashedKuku;
Using #JsonIgnore on the getter:
#JsonIgnore
public String getHashedKuku() {
return hashedKuku;
}
Many more solutions that I will skip as they're either an overengineering or also not good enough.
Ultimate Solution:
Register the serialization of hashedKuku so the default serializer skips it.Maybe get access to the default serializer in MySerializer and serialize hashedKuku through it?
What I've Researched:
Jackson add custom field with hash of another field - Not good as I have the field in the POJO.
Jackson: How to add custom property to the JSON without modifying the POJO - Same as first.
Jackson add custom field with hash of another field - I do not understand the usage of BeanSerializerModifier or how to register it in a Spring application.
How to add a new Property with BeanSerializerModifier's changeProperties?
How to access default jackson serialization in a custom serializer with the same object - Class-level serializer.
Jackson Custom Serializer shows the same context for 2 different field during the Json Serialization
Jackson - custom serializer that overrides only specific fields
How to access default jackson serialization in a custom serializer - Class-level serializer.
Jackson custom serializer serialize field twice if property name not equal field name
Apply default serializer to properties in custom serializer with Jackson
Duplicate JSON Field with Jackson - Not same case.
Jackson: How to edit existing property to the JSON without modifying the POJO?

Wrapping Json fields into instance variable of a pojo

i am trying to map certain json fields to a class instance variable.
My sample Person class looks like:
public class Person {
private String name;
private Address address;
//many more fields
//getters and setters
}
The sample Address class is:
public class Address {
private String street;
private String city;
//many more fields
// getters and setters
}
The json object to be deserialized to my Person class doesn't contain "address" field. It looks like:
{
"name":"Alexander",
"street":"abc 12",
"city":"London"
}
Is there a way to deserialize the json to the Person pojo where the Address fields are also mapped properly?
I have used a custom Address deserializer as mentioned in so many posts here. However, it's not being called as the Json object doesn't contain "address" field.
I had resolved this problem by mapping each field manually using JsonNode, however in my real project, it's not a nice solution.
Is there any work around for such problem using jackson?
Plus if this question has been asked before then apologies on my behalf as as i have intensively searched for the solution and might have not seen it yet. .

#JsonUnwrapped annotation was introduced for this problem. Model:
class Person {
private String name;
#JsonUnwrapped
private Address address;
// getters, setters, toString
}
class Address {
private String street;
private String city;
// getters, setters, toString
}
Usage:
ObjectMapper mapper = new ObjectMapper();
String json = "{\"name\":\"Alexander\",\"street\":\"abc 12\",\"city\":\"London\"}";
System.out.println(mapper.readValue(json, Person.class));
Prints:
Person{name='Alexander', address=Address{street='abc 12', city='London'}}
For more info read:
Jackson Annotation Examples
Annotation Type JsonUnwrapped
Jackson JSON - Using #JsonUnwrapped to serialize/deserialize properties as flattening data structure

I don't think you really have a deserialization problem here but rather a general Java problem: how to make sure the address field always contains a value. All you need to do is either assign address to a default value in the Person constructor, or generate and assign a default value for address in the Person.getAddress method.

I understood your problem so that it is about flat Json that has all Address fields at the same level as Person. Even if it is not exactly so this might help you. JsonDeserializer will do fine but you need to apply it to Person because it is the level where all the fields are.
So like this:
public class CustomDeserializer extends JsonDeserializer<Person> {
// need to use separate ObjectMapper to prevent recursion
// this om will not be registered with this custom deserializer
private final ObjectMapper om;
{
om = new ObjectMapper();
// this is needed because flat json contains unknown fields
// for both types.
om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
#Override
public Person deserialize(JsonParser parser, DeserializationContext ctxt)
throws IOException, JsonProcessingException {
// make a string of json tree so not any particular object
String json = om.readTree(parser).toString();
// deserialize it as person (ignoring unknown fields)
Person person = om.readValue(json, Person.class);
// set address deserializing it from teh same string, same manner
person.setAddress(om.readValue(json, Address.class));
return person;
}
}
Of course this is not the only way and might not have the best performance but it is only about how you do the deserialization in your custom deserializer. If your Person & Address objects are havin like 10 fields each using this should not be a problem.
Update
I think that in your case - based on your example data - Michał Ziober's
answer might be the best but if you need any more complex handling than plain unwrapping for your data you just need to deserialize Person class somehow like I presented.

Jackson ObjectMapper jsonIgnore issue

I am beginner in Jackson. I am trying this -:
public class A {
boolean property1;
String property2;
// public getters and setters for both
}
public abstract class MixIn {
#JsonIgnore
boolean property1;
}
ObjectMapper mapper = new ObjectMapper();
mapper.addMixInAnnotations(A.class, MixIn.class);
Now,
String result = mapper.writeValueAsString(new A())
gives me result like this - {"property2" : "value"} which is correct but if try to convert the result in the object again -:
mapper.readValue(result, A.class);
I am getting property1 back object A this -:
A {property1 : false, property2 : value}
Why is objectMapper not ignoring the property again. Note - I tried directly putting #JsonIgnore on property1 and it worked fine but I have to use MixIn for this. I had tried putting JsonIgnore on getter and setters in MixIn too but that didn't work too.

Ok. I got it now. #JsonIgnore means that the property won't be written in the serialized string but if any string would be deserialized the same property would have defaults which in case of a boolean is always false which I realised when I tried with adding more properties so mix-in is actually working. It's just that I thought that in some magical way it would remove the property from the object itself. (I know it's silly.)

Jackson mapping: Deserialization of JSON with different property names

I have a server that returns a json string:
{"pId": "ChIJ2Vn0h5wOlR4RsOSteUYYM6g"}
Now, I can use jackson to deserialize it into an object with the variable called pId, but I don't want the variable to be called pId, I would rather deserialize it to placeId.
Current object in android java:
public class Place {
private String pId;
}
What I want the object to look like:
public class Place {
private String placeId;
}
If I change the object's variable to placeId, jackson will not be able to deserialize the JSON as the property names no longer matches.
Is there a jackson annotation I can used to map the "placeId" variable in the java object to the JSON string variable "pId" returned back from the server?

Use #JsonProperty annotation:
public class Place {
#JsonProperty("pId")
private String placeId;
}
For more information you can see the related javadoc.

Jackson Data-Binding with Heterogeneous Json Object

I'm calling a rest service that returns a json object. I'm trying to deserialize the responses to my Java Beans using Jackson and data-binding.
The example Json is something like this:
{
detail1: { property1:value1, property2:value2},
detail2: { property1:value1, property2:value2},
otherObject: {prop3:value1, prop4:[val1, val2, val3]}
}
Essentially, detail1 and detail2 are of the same structure, and thus can be represented by a single class type, whereas OtherObject is of another type.
Currently, I've set up my classes as follows (this is the structure I would prefer):
class ServiceResponse {
private Map<String, Detail> detailMap;
private OtherObject otherObject;
// getters and setters
}
class Detail {
private String property1;
private String property2;
// getters and setters
}
class OtherObject {
private String prop3;
private List<String> prop4;
// getters and setters
}
Then, just do:
String response = <call service and get json response>
ObjectMapper mapper = new ObjectMapper();
mapper.readValue(response, ServiceResponse.class)
The problem is I'm getting lost reading through the documentation about how to configure the mappings and annotations correctly to get the structure that I want. I'd like detail1, detail2 to create Detail classes, and otherObject to create an OtherObject class.
However, I also want the detail classes to be stored in a map, so that they can be easily distinguished and retrieved, and also the fact that the service in in the future will return detail3, detail4, etc. (i.e., the Map in ServiceResponse would look like
"{detail1:Detail object, detail2:Detail object, ...}).
How should these classes be annotated? Or, perhaps there's a better way to structure my classes to fit this JSON model? Appreciate any help.

Simply use #JsonAnySetter on a 2-args method in ServiceResponse, like so:
#JsonAnySetter
public void anySet(String key, Detail value) {
detailMap.put(key, value);
}
Mind you that you can only have one "property" with #JsonAnySetter as it's a fallback for unknown properties. Note that the javadocs of JsonAnySetter is incorrect, as it states that it should be applied to 1-arg methods; you can always open a minor bug in Jackson ;)