Develop Reference

Bean validation in springboot

public class test{
private String id;
private String status;
private Integer alertsCount
}
I have a class test, when a rest api implemented using springboot with post request gets triggered input json looks like
{
"id": "1",
"status": "Cancelled",
"alertCount": 10
}
at my model class i need to add restriction to prevent status to be one of the below values
"Successfull", "Cancelled", "In Progress", "On Hold"
How can i achieve this.

#Pattern(regexp = "^(Successfull)|(Cancelled)|(In Progress)|(On Hold)$"
private String status;
DON'T FORGET TO USE #Valid AT CONTROLLER

Add Dependency
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
then add #Valid to your Request Handler Method parameter
#PostMapping("/test/")
ResponseEntity<String> addTest(#Valid #RequestBody Test test) {
return ResponseEntity.ok();
}
and add bean-validation annotations to your Json Object, for exmaple:
public class Test{
#NotNull
private String id;
#NotNull
#Pattern(regexp="(Successfull)|(Cancelled)|(In Progress)|(On Hold)")
private String status;
#NotNull
private Integer alertsCount
}
Some other example: https://stackoverflow.com/a/9994590/280244 that also contains the handling of validation errors, via BindingResult
BTW: An other idea is to use an Enum instead of an String (that causes other Exception when the string does not match!) but then the whitespace must been replaced)

Since status field has to have value from predefined set of constants, it would be better to provide an enum containing all available status strings.
public class TestModel{
private String id;
private StatusEnum status;
private Integer alertsCount;
}
public enum StatusEnum {
SUCCESSFUL("Successful"),
CANCELLED("Cancelled"),
IN_PROGRESS("In progress"),
ON_HOLD("On hold");
private String statusTag;
StatusEnum(String status){
this.statusTag = status;
}
}
Enums are designed for exactly such situations, according to Java documentation (https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html):
An enum type is a special data type that enables for a variable to be a set of predefined constants. The variable must be equal to one of the values that have been predefined for it. Common examples include compass directions (values of NORTH, SOUTH, EAST, and WEST) and the days of the week.

What about using Enums? This decision is clean and simple.
public class test{
private String id;
private STATUS status;
private Integer alertsCount
}
public enum STATUS {
public Successfull;
public Cancelled;
public InProgress;
public OnHold
}
Write your custom ConstraintValidator.

Object mapper removing empty and null values when converting object to string Java

In response to api call, i'm sending Json Class Object as response.
I need response like this without empty objects being removed.
{
"links": {
"products": [],
"packages": []
},
"embedded":{
"products": [],
"packages": []
}
}
but final Response is looking like this
{
"links": {},
"embedded": {}
}

Two things to be aware of:
null and empty are different things.
AFAIK Jackson is configured to serialize properties with null values by default.
Make sure to properly initialize your properties in your object. For example:
class Dto {
private Link link;
private Embedded embedded;
//constructor, getters and setters...
}
class Link {
//by default these will be empty instead of null
private List<Product> products = new ArrayList<>();
private List<Package> packages = new ArrayList<>();
//constructor, getters and setters...
}
Make sure your classes are not extending another class with this annotation #JsonInclude(JsonInclude.Include.NON_NULL). Example:
//It tells Jackson to exclude any property with null values from being serialized
#JsonInclude(JsonInclude.Include.NON_NULL)
class BaseClass {
}
//Any property with null value will follow the rules stated in BaseClass
class Dto extends BaseClass {
private Link link;
private Embedded embedded;
//constructor, getters and setters...
}
class Link extends BaseClass {
/* rest of the design */
}
If you have the latter and you cannot edit BaseClass then you can define different rules in the specific classes:
class Link extends BaseClass{
//no matter what rules are defined elsewhere, this field will be serialized
#JsonInclude(JsonInclude.Include.ALWAYS)
private List<Product> products;
//same here
#JsonInclude(JsonInclude.Include.ALWAYS)
private List<Package> packages;
//constructor, getters and setters...
}

Fields duplicated during de-serialization

I have a class which looks like this :
public class Item {
private ItemHeader header;
private ItemBody body;
}
public class ItemHeader {
private int id;
private String name;
}
public class ItemBody {
private List<String> values;
private List<String> details;
}
The fields of ItemHeader and ItemBody are accessible via setters and getters from the Item class as well as from their corresponding classes. All said setters and getters EXCEPT get/setItemBody +get/setItemHeader are annotated with #JsonIgnore.
When Item instance is returned by a GET REST method, the Response looks as following :
{
"body": {
"details":[]
"values":[]
},
"header": {
"id": 145,
"name": "name_of_item",
},
"details":[],
"values":[],
"id": 145,
"name": "name_of_item"
}
Internals of itemHeader and itemBody are spilled twice into the deserialized Json , once (correctly) inside the corresponding fields and the second time just outside them.
I do not have much control over Jackson definitions behind the scenes and can basically only control my class hierarchy with annotations and such.
Please advise - how to remove the duplication, the "spilled over" values...

I've ended up removing the double layer of getters/setters which solved the issue, and in the process discovered that indeed, the serialization path and the de- path used different libraries . So https://stackoverflow.com/users/2513573/adamskywalker had the right idea

Want to hide some fields of an object that are being mapped to JSON by Jackson

I have a User class that I want to map to JSON using Jackson.
public class User {
private String name;
private int age;
private int securityCode;
// getters and setters
}
I map this to a JSON string using -
User user = getUserFromDatabase();
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(user);
I don't want to map the securityCode variable. Is there any way of configuring the mapper so that it ignores this field?
I know I can write custom data mappers or use the Streaming API but I would like to know if it possible to do it through configuration?

You have two options:
Jackson works on setters-getters of fields. So, you can just remove getter of field which you want to omit in JSON. ( If you don't need getter at other place.)
Or, you can use the #JsonIgnore annotation of Jackson on getter method of that field and you see there in no such key-value pair in resulted JSON.
#JsonIgnore
public int getSecurityCode(){
return securityCode;
}

Adding this here because somebody else may search this again in future, like me. This Answer is an extension to the Accepted Answer
You have two options:
1. Jackson works on setters-getters of fields. So, you can just remove getter of field which you want to omit in JSON. ( If you don't need getter at other place.)
2. Or, you can use the `#JsonIgnore` [annotation of Jackson][1] on getter method of that field and you see there in no such key-value pair in resulted JSON.
#JsonIgnore
public int getSecurityCode(){
return securityCode;
}
Actually, newer version of Jackson added READ_ONLY and WRITE_ONLY annotation arguments for JsonProperty. So you could also do something like this.
#JsonProperty(access = Access.WRITE_ONLY)
private String securityCode;
instead of
#JsonIgnore
public int getSecurityCode(){
return securityCode;
}

you also can gather all properties on an annotation class
#JsonIgnoreProperties( { "applications" })
public MyClass ...
String applications;

If you don't want to put annotations on your Pojos you can also use Genson.
Here is how you can exclude a field with it without any annotations (you can also use annotations if you want, but you have the choice).
Genson genson = new Genson.Builder().exclude("securityCode", User.class).create();
// and then
String json = genson.serialize(user);

Field Level:
public class User {
private String name;
private int age;
#JsonIgnore
private int securityCode;
// getters and setters
}
Class Level:
#JsonIgnoreProperties(value = { "securityCode" })
public class User {
private String name;
private int age;
private int securityCode;
}

if you are using GSON you have to mark the field/member declarations as #Expose and use the GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()
Don't forget to mark your sub classes with #Expose otherwise the fields won't show.

I suggest you use this.
#JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private int securityCode;
This allows you to set the value of securityCode(especially if you use lombok #Setter) and also prevent the field from showing up in the GET request.

I had a similar case where I needed some property to be deserialized (JSON to Object) but not serialized (Object to JSON)
First i went for #JsonIgnore - it did prevent serialization of unwanted property, but failed to de-serialize it too. Trying value attribute didn't help either as it requires some condition.
Finally, working #JsonProperty with access attribute worked like a charm.

How to map JSON field names to different object field names?

What is the equiv way in Jackson json annotation for the following jax-b annotations?
I need to produce json rather than xml and need to know the conventional jackson annotations that is equivalently denoted in jax-b.
rename a field.
use getters instead of fields.
These features are especially crucial if the json/xml element name is a java reserved word
like "new", "public", "static", etc.
So that we have to name the POJO fields as "_new_", "_public_", "_static_", etc, respectively,
but use jax-b annotation to rename them back to "new", "public", "static", etc
in the generated XML (and json) elements.
Renaming a field
#XmlAccessorType(XmlAccessType.FIELD)
public class Person{
#XmlElement(required = true)
protected String name;
#XmlElement(required = true)
protected String address;
#XmlElement(name = "contractor")
protected boolean _restricted_ ;
#XmlElement(name = "new")
protected boolean _new_ ;
}
Redirect to using property getter (I think this is how it is done in jax-b)
#XmlAccessorType(XmlAccessType.PROPERTY)
public class Person{
protected String name;
protected String address;
protected boolean _restricted_ ;
protected boolean _new_ ;
#XmlElement(required = true)
protected String getName() {return name;}
#XmlElement(required = true)
protected String getAddress() {return address;}
#XmlElement(name = "contractor")
protected boolean getRestricted() {return _restricted_;}
#XmlElement(name = "new")
protected boolean getNew(){return _new_;}
}

Probably it's a bit late but anyway..
you can rename a property just adding
#JsonProperty("contractor")
And by default Jackson use the getter and setter to serialize and deserialize.
For more detailed information: http://wiki.fasterxml.com/JacksonFAQ

With some example, You can also use it in getter and setter to rename it to different field
public class Sample {
private String fruit;
#JsonProperty("get_apple")
public void setFruit(String fruit) {
this.fruit = fruit;
}
#JsonProperty("send_apple")
public String getFruit() {
return fruit;
}
}

Please note that the proper JavaEE API for this is to use the javax.json.bind.annotation.JsonbProperty annotation. Of course Jackson and others are just some implementations of the JSON Binding API, they will likely comply with this.

If you are not using Jackson still want to rename a property you can use #SerializedName("your_original_key_name")
My JSON Data:
{
"default": "0"
}
As you know we never use predefined keywords as a variable name so solution is:
#SerializedName("default")
private String default_value;
public String getDefault_value() {
return default_value;
}
public void setDefault_value(String default_value) {
this.default_value = default_value;
}
That's all you have to do now value comes from the key "default" and you can use it with getter and setter using "default_value"
In this case (Predifind Keywords as Json Key Name) or in any other case where you want to change your variable name to get data from the original key name this is the easiest approach.

I'm just reiterating #Himanshu's Answer,
Java Bean Property Field
#SerializedName("TCS Rate")
private String TCSRate;
Here we need this import
import com.google.gson.annotations.SerializedName;
Maven Dependency
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.9.0</version>
</dependency>